1 files changed, 63 insertions, 55 deletions

diff --git a/runtime/class_linker_test.cc b/runtime/class_linker_test.cc
index 8cd0604ac3..6ed029ceb1 100644
--- a/runtime/class_linker_test.cc
+++ b/runtime/class_linker_test.cc
@@ -62,9 +62,10 @@ class ClassLinkerTest : public CommonRuntimeTest {
     Thread* self = Thread::Current();
     EXPECT_TRUE(class_linker_->FindSystemClass(self, descriptor.c_str()) == nullptr);
     EXPECT_TRUE(self->IsExceptionPending());
-    mirror::Object* exception = self->GetException();
+    StackHandleScope<1> hs(self);
+    Handle<mirror::Object> exception = hs.NewHandle<mirror::Object>(self->GetException());
     self->ClearException();
-    mirror::Class* exception_class =
+    ObjPtr<mirror::Class> exception_class =
         class_linker_->FindSystemClass(self, "Ljava/lang/NoClassDefFoundError;");
     EXPECT_TRUE(exception->InstanceOf(exception_class));
   }
@@ -75,7 +76,7 @@ class ClassLinkerTest : public CommonRuntimeTest {
     AssertPrimitiveClass(descriptor, class_linker_->FindSystemClass(self, descriptor.c_str()));
   }
 
-  void AssertPrimitiveClass(const std::string& descriptor, mirror::Class* primitive)
+  void AssertPrimitiveClass(const std::string& descriptor, ObjPtr<mirror::Class> primitive)
       REQUIRES_SHARED(Locks::mutator_lock_) {
     ASSERT_TRUE(primitive != nullptr);
     ASSERT_TRUE(primitive->GetClass() != nullptr);
@@ -113,13 +114,13 @@ class ClassLinkerTest : public CommonRuntimeTest {
     EXPECT_EQ(kAccPublic | kAccFinal | kAccAbstract, primitive->GetAccessFlags());
   }
 
-  void AssertObjectClass(mirror::Class* JavaLangObject)
+  void AssertObjectClass(ObjPtr<mirror::Class> JavaLangObject)
       REQUIRES_SHARED(Locks::mutator_lock_) {
     ASSERT_TRUE(JavaLangObject != nullptr);
     ASSERT_TRUE(JavaLangObject->GetClass() != nullptr);
     ASSERT_EQ(JavaLangObject->GetClass(),
               JavaLangObject->GetClass()->GetClass());
-    EXPECT_EQ(JavaLangObject, JavaLangObject->GetClass()->GetSuperClass());
+    EXPECT_OBJ_PTR_EQ(JavaLangObject, JavaLangObject->GetClass()->GetSuperClass());
     std::string temp;
     ASSERT_STREQ(JavaLangObject->GetDescriptor(&temp), "Ljava/lang/Object;");
     EXPECT_TRUE(JavaLangObject->GetSuperClass() == nullptr);
@@ -172,7 +173,7 @@ class ClassLinkerTest : public CommonRuntimeTest {
 
   void AssertArrayClass(const std::string& array_descriptor,
                         const std::string& component_type,
-                        mirror::ClassLoader* class_loader)
+                        ObjPtr<mirror::ClassLoader> class_loader)
       REQUIRES_SHARED(Locks::mutator_lock_) {
     Thread* self = Thread::Current();
     StackHandleScope<2> hs(self);
@@ -181,7 +182,7 @@ class ClassLinkerTest : public CommonRuntimeTest {
         hs.NewHandle(class_linker_->FindClass(self, array_descriptor.c_str(), loader)));
     std::string temp;
     EXPECT_STREQ(component_type.c_str(), array->GetComponentType()->GetDescriptor(&temp));
-    EXPECT_EQ(class_loader, array->GetClassLoader());
+    EXPECT_OBJ_PTR_EQ(loader.Get(), array->GetClassLoader());
     EXPECT_EQ(kAccFinal | kAccAbstract, (array->GetAccessFlags() & (kAccFinal | kAccAbstract)));
     AssertArrayClass(array_descriptor, array);
   }
@@ -234,7 +235,7 @@ class ClassLinkerTest : public CommonRuntimeTest {
     EXPECT_OBJ_PTR_EQ(class_linker_->FindArrayClass(self, &array_ptr), array.Get());
 
     PointerSize pointer_size = class_linker_->GetImagePointerSize();
-    mirror::Class* JavaLangObject =
+    ObjPtr<mirror::Class> JavaLangObject =
         class_linker_->FindSystemClass(self, "Ljava/lang/Object;");
     ImTable* JavaLangObject_imt = JavaLangObject->GetImt(pointer_size);
     // IMT of a array class should be shared with the IMT of the java.lag.Object
@@ -292,9 +293,9 @@ class ClassLinkerTest : public CommonRuntimeTest {
       }
     }
     EXPECT_EQ(klass->IsInterface(), !klass->HasVTable());
-    mirror::IfTable* iftable = klass->GetIfTable();
+    ObjPtr<mirror::IfTable> iftable = klass->GetIfTable();
     for (int i = 0; i < klass->GetIfTableCount(); i++) {
-      mirror::Class* interface = iftable->GetInterface(i);
+      ObjPtr<mirror::Class> interface = iftable->GetInterface(i);
       ASSERT_TRUE(interface != nullptr);
       if (klass->IsInterface()) {
         EXPECT_EQ(0U, iftable->GetMethodArrayCount(i));
@@ -322,13 +323,13 @@ class ClassLinkerTest : public CommonRuntimeTest {
     for (ArtMethod& method : klass->GetDirectMethods(kRuntimePointerSize)) {
       AssertMethod(&method);
       EXPECT_TRUE(method.IsDirect());
-      EXPECT_EQ(klass.Get(), method.GetDeclaringClass());
+      EXPECT_OBJ_PTR_EQ(klass.Get(), method.GetDeclaringClass());
     }
 
     for (ArtMethod& method : klass->GetDeclaredVirtualMethods(kRuntimePointerSize)) {
       AssertMethod(&method);
       EXPECT_FALSE(method.IsDirect());
-      EXPECT_EQ(klass.Get(), method.GetDeclaringClass());
+      EXPECT_OBJ_PTR_EQ(klass.Get(), method.GetDeclaringClass());
     }
 
     for (ArtMethod& method : klass->GetCopiedMethods(kRuntimePointerSize)) {
@@ -386,7 +387,7 @@ class ClassLinkerTest : public CommonRuntimeTest {
     ASSERT_EQ(end_ref_offset.Uint32Value(), current_ref_offset.Uint32Value());
 
     uint32_t total_num_reference_instance_fields = 0;
-    mirror::Class* k = klass.Get();
+    ObjPtr<mirror::Class> k = klass.Get();
     while (k != nullptr) {
       total_num_reference_instance_fields += k->NumReferenceInstanceFields();
       k = k->GetSuperClass();
@@ -400,7 +401,7 @@ class ClassLinkerTest : public CommonRuntimeTest {
     }
   }
 
-  void AssertDexFileClass(mirror::ClassLoader* class_loader, const std::string& descriptor)
+  void AssertDexFileClass(ObjPtr<mirror::ClassLoader> class_loader, const std::string& descriptor)
       REQUIRES_SHARED(Locks::mutator_lock_) {
     ASSERT_TRUE(descriptor != nullptr);
     Thread* self = Thread::Current();
@@ -409,8 +410,8 @@ class ClassLinkerTest : public CommonRuntimeTest {
         hs.NewHandle(class_linker_->FindSystemClass(self, descriptor.c_str())));
     ASSERT_TRUE(klass != nullptr);
     std::string temp;
-    EXPECT_STREQ(descriptor.c_str(), klass.Get()->GetDescriptor(&temp));
-    EXPECT_EQ(class_loader, klass->GetClassLoader());
+    EXPECT_STREQ(descriptor.c_str(), klass->GetDescriptor(&temp));
+    EXPECT_OBJ_PTR_EQ(class_loader, klass->GetClassLoader());
     if (klass->IsPrimitive()) {
       AssertPrimitiveClass(descriptor, klass.Get());
     } else if (klass->IsArrayClass()) {
@@ -420,7 +421,7 @@ class ClassLinkerTest : public CommonRuntimeTest {
     }
   }
 
-  void AssertDexFile(const DexFile& dex, mirror::ClassLoader* class_loader)
+  void AssertDexFile(const DexFile& dex, ObjPtr<mirror::ClassLoader> class_loader)
       REQUIRES_SHARED(Locks::mutator_lock_) {
     // Verify all the classes defined in this file
     for (size_t i = 0; i < dex.NumClassDefs(); i++) {
@@ -469,7 +470,7 @@ struct CheckOffsets {
 
   bool Check() REQUIRES_SHARED(Locks::mutator_lock_) {
     Thread* self = Thread::Current();
-    mirror::Class* klass =
+    ObjPtr<mirror::Class> klass =
         Runtime::Current()->GetClassLinker()->FindSystemClass(self, class_descriptor.c_str());
     CHECK(klass != nullptr) << class_descriptor;
 
@@ -875,12 +876,13 @@ TEST_F(ClassLinkerTest, FindClassNested) {
   Handle<mirror::ClassLoader> class_loader(
       hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("Nested"))));
 
-  mirror::Class* outer = class_linker_->FindClass(soa.Self(), "LNested;", class_loader);
+  ObjPtr<mirror::Class> outer = class_linker_->FindClass(soa.Self(), "LNested;", class_loader);
   ASSERT_TRUE(outer != nullptr);
   EXPECT_EQ(0U, outer->NumVirtualMethods());
   EXPECT_EQ(1U, outer->NumDirectMethods());
 
-  mirror::Class* inner = class_linker_->FindClass(soa.Self(), "LNested$Inner;", class_loader);
+  ObjPtr<mirror::Class> inner =
+      class_linker_->FindClass(soa.Self(), "LNested$Inner;", class_loader);
   ASSERT_TRUE(inner != nullptr);
   EXPECT_EQ(0U, inner->NumVirtualMethods());
   EXPECT_EQ(1U, inner->NumDirectMethods());
@@ -902,23 +904,24 @@ TEST_F(ClassLinkerTest, FindClass_Primitives) {
 
 TEST_F(ClassLinkerTest, FindClass) {
   ScopedObjectAccess soa(Thread::Current());
-  mirror::Class* JavaLangObject = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;");
-  AssertObjectClass(JavaLangObject);
+  StackHandleScope<2> hs(soa.Self());
+  Handle<mirror::Class> JavaLangObject = hs.NewHandle(
+      class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;"));
+  AssertObjectClass(JavaLangObject.Get());
 
-  StackHandleScope<1> hs(soa.Self());
   Handle<mirror::ClassLoader> class_loader(
       hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("MyClass"))));
   AssertNonExistentClass("LMyClass;");
-  mirror::Class* MyClass = class_linker_->FindClass(soa.Self(), "LMyClass;", class_loader);
+  ObjPtr<mirror::Class> MyClass = class_linker_->FindClass(soa.Self(), "LMyClass;", class_loader);
   ASSERT_TRUE(MyClass != nullptr);
   ASSERT_TRUE(MyClass->GetClass() != nullptr);
   ASSERT_EQ(MyClass->GetClass(), MyClass->GetClass()->GetClass());
-  EXPECT_EQ(JavaLangObject, MyClass->GetClass()->GetSuperClass());
+  EXPECT_OBJ_PTR_EQ(JavaLangObject.Get(), MyClass->GetClass()->GetSuperClass());
   std::string temp;
   ASSERT_STREQ(MyClass->GetDescriptor(&temp), "LMyClass;");
-  EXPECT_TRUE(MyClass->GetSuperClass() == JavaLangObject);
+  EXPECT_OBJ_PTR_EQ(MyClass->GetSuperClass(), JavaLangObject.Get());
   EXPECT_TRUE(MyClass->HasSuperClass());
-  EXPECT_EQ(class_loader.Get(), MyClass->GetClassLoader());
+  EXPECT_OBJ_PTR_EQ(class_loader.Get(), MyClass->GetClassLoader());
   EXPECT_EQ(ClassStatus::kResolved, MyClass->GetStatus());
   EXPECT_FALSE(MyClass->IsErroneous());
   EXPECT_TRUE(MyClass->IsLoaded());
@@ -1057,8 +1060,9 @@ TEST_F(ClassLinkerTest, LibCore) {
 // start of the object
 TEST_F(ClassLinkerTest, ValidateObjectArrayElementsOffset) {
   ScopedObjectAccess soa(Thread::Current());
-  mirror::Class* array_class = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;");
-  mirror::ObjectArray<mirror::String>* array =
+  ObjPtr<mirror::Class> array_class =
+      class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;");
+  ObjPtr<mirror::ObjectArray<mirror::String>> array =
       mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), array_class, 0);
   uintptr_t data_offset =
       reinterpret_cast<uintptr_t>(array->GetRawData(sizeof(mirror::HeapReference<mirror::String>),
@@ -1106,7 +1110,7 @@ TEST_F(ClassLinkerTest, ValidateBoxedTypes) {
   // This lets UnboxPrimitive avoid searching for the field by name at runtime.
   ScopedObjectAccess soa(Thread::Current());
   ScopedNullHandle<mirror::ClassLoader> class_loader;
-  mirror::Class* c;
+  ObjPtr<mirror::Class> c;
   c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Boolean;", class_loader);
   EXPECT_STREQ("value", c->GetIFieldsPtr()->At(0).GetName());
   c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Byte;", class_loader);
@@ -1127,16 +1131,18 @@ TEST_F(ClassLinkerTest, ValidateBoxedTypes) {
 
 TEST_F(ClassLinkerTest, TwoClassLoadersOneClass) {
   ScopedObjectAccess soa(Thread::Current());
-  StackHandleScope<2> hs(soa.Self());
+  StackHandleScope<3> hs(soa.Self());
   Handle<mirror::ClassLoader> class_loader_1(
       hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("MyClass"))));
   Handle<mirror::ClassLoader> class_loader_2(
       hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("MyClass"))));
-  mirror::Class* MyClass_1 = class_linker_->FindClass(soa.Self(), "LMyClass;", class_loader_1);
-  mirror::Class* MyClass_2 = class_linker_->FindClass(soa.Self(), "LMyClass;", class_loader_2);
+  Handle<mirror::Class> MyClass_1 = hs.NewHandle(
+      class_linker_->FindClass(soa.Self(), "LMyClass;", class_loader_1));
+  ObjPtr<mirror::Class> MyClass_2 =
+      class_linker_->FindClass(soa.Self(), "LMyClass;", class_loader_2);
   EXPECT_TRUE(MyClass_1 != nullptr);
   EXPECT_TRUE(MyClass_2 != nullptr);
-  EXPECT_NE(MyClass_1, MyClass_2);
+  EXPECT_OBJ_PTR_NE(MyClass_1.Get(), MyClass_2);
 }
 
 TEST_F(ClassLinkerTest, StaticFields) {
@@ -1200,7 +1206,7 @@ TEST_F(ClassLinkerTest, StaticFields) {
       soa.Self(), statics.Get(), "s8", "Ljava/lang/String;");
   EXPECT_EQ(s8->GetTypeAsPrimitiveType(), Primitive::kPrimNot);
   EXPECT_TRUE(s8->GetObject(statics.Get())->AsString()->Equals("android"));
-  mirror::String* str_value = mirror::String::AllocFromModifiedUtf8(soa.Self(), "robot");
+  ObjPtr<mirror::String> str_value = mirror::String::AllocFromModifiedUtf8(soa.Self(), "robot");
   s8->SetObject<false>(s8->GetDeclaringClass(), str_value);
 
   // TODO: Remove EXPECT_FALSE when GCC can handle EXPECT_EQ
@@ -1300,7 +1306,8 @@ TEST_F(ClassLinkerTest, ResolveVerifyAndClinit) {
   StackHandleScope<1> hs(soa.Self());
   Handle<mirror::ClassLoader> class_loader(
       hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader)));
-  mirror::Class* klass = class_linker_->FindClass(soa.Self(), "LStaticsFromCode;", class_loader);
+  ObjPtr<mirror::Class> klass =
+      class_linker_->FindClass(soa.Self(), "LStaticsFromCode;", class_loader);
   ArtMethod* clinit = klass->FindClassInitializer(kRuntimePointerSize);
   ArtMethod* getS0 =
       klass->FindClassMethod("getS0", "()Ljava/lang/Object;", kRuntimePointerSize);
@@ -1345,7 +1352,7 @@ TEST_F(ClassLinkerTest, ErroneousClass) {
 
 TEST_F(ClassLinkerTest, FinalizableBit) {
   ScopedObjectAccess soa(Thread::Current());
-  mirror::Class* c;
+  ObjPtr<mirror::Class> c;
 
   // Object has a finalize method, but we know it's empty.
   c = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;");
@@ -1381,7 +1388,7 @@ TEST_F(ClassLinkerTest, ClassRootDescriptors) {
   ScopedObjectAccess soa(Thread::Current());
   std::string temp;
   for (int i = 0; i < ClassLinker::kClassRootsMax; i++) {
-    mirror::Class* klass = class_linker_->GetClassRoot(ClassLinker::ClassRoot(i));
+    ObjPtr<mirror::Class> klass = class_linker_->GetClassRoot(ClassLinker::ClassRoot(i));
     EXPECT_GT(strlen(klass->GetDescriptor(&temp)), 0U);
     EXPECT_STREQ(klass->GetDescriptor(&temp),
                  class_linker_->GetClassRootDescriptor(ClassLinker::ClassRoot(i))) << " i = " << i;
@@ -1391,7 +1398,7 @@ TEST_F(ClassLinkerTest, ClassRootDescriptors) {
 TEST_F(ClassLinkerTest, ValidatePredefinedClassSizes) {
   ScopedObjectAccess soa(Thread::Current());
   ScopedNullHandle<mirror::ClassLoader> class_loader;
-  mirror::Class* c;
+  ObjPtr<mirror::Class> c;
 
   c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Class;", class_loader);
   ASSERT_TRUE(c != nullptr);
@@ -1418,7 +1425,7 @@ static void CheckMethod(ArtMethod* method, bool verified)
   }
 }
 
-static void CheckVerificationAttempted(mirror::Class* c, bool preverified)
+static void CheckVerificationAttempted(ObjPtr<mirror::Class> c, bool preverified)
     REQUIRES_SHARED(Locks::mutator_lock_) {
   EXPECT_EQ((c->GetAccessFlags() & kAccVerificationAttempted) != 0U, preverified)
       << "Class " << mirror::Class::PrettyClass(c) << " not as expected";
@@ -1430,7 +1437,8 @@ static void CheckVerificationAttempted(mirror::Class* c, bool preverified)
 TEST_F(ClassLinkerTest, Preverified_InitializedBoot) {
   ScopedObjectAccess soa(Thread::Current());
 
-  mirror::Class* JavaLangObject = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;");
+  ObjPtr<mirror::Class> JavaLangObject =
+      class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;");
   ASSERT_TRUE(JavaLangObject != nullptr);
   EXPECT_TRUE(JavaLangObject->IsInitialized()) << "Not testing already initialized class from the "
                                                   "core";
@@ -1479,13 +1487,13 @@ TEST_F(ClassLinkerTest, IsBootStrapClassLoaded) {
   Handle<mirror::Class> jlo_class(
       hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;")));
   ASSERT_TRUE(jlo_class != nullptr);
-  EXPECT_TRUE(jlo_class.Get()->IsBootStrapClassLoaded());
+  EXPECT_TRUE(jlo_class->IsBootStrapClassLoaded());
 
   // Statics is not a bootstrap class.
   Handle<mirror::Class> statics(
       hs.NewHandle(class_linker_->FindClass(soa.Self(), "LStatics;", class_loader)));
   ASSERT_TRUE(statics != nullptr);
-  EXPECT_FALSE(statics.Get()->IsBootStrapClassLoaded());
+  EXPECT_FALSE(statics->IsBootStrapClassLoaded());
 }
 
 // Regression test for b/26799552.
@@ -1563,13 +1571,13 @@ TEST_F(ClassLinkerMethodHandlesTest, TestResolveMethodTypes) {
   Handle<mirror::Class> string_class(hs.NewHandle(class_linker_->FindClass(soa.Self(),
                                                                            "Ljava/lang/String;",
                                                                            class_loader)));
-  ASSERT_EQ(string_class.Get(), method1_type->GetRType());
-  ASSERT_EQ(string_class.Get(), method1_type->GetPTypes()->Get(0));
+  ASSERT_OBJ_PTR_EQ(string_class.Get(), method1_type->GetRType());
+  ASSERT_OBJ_PTR_EQ(string_class.Get(), method1_type->GetPTypes()->Get(0));
 
   // Resolve the method type again and assert that we get back the same value.
   Handle<mirror::MethodType> method1_type2 = hs.NewHandle(
       class_linker_->ResolveMethodType(soa.Self(), method1_id.proto_idx_, dex_cache, class_loader));
-  ASSERT_EQ(method1_type.Get(), method1_type2.Get());
+  ASSERT_OBJ_PTR_EQ(method1_type.Get(), method1_type2.Get());
 
   // Resolve the MethodType associated with a different method signature
   // and assert it's different.
@@ -1582,7 +1590,7 @@ TEST_F(ClassLinkerMethodHandlesTest, TestResolveMethodTypes) {
   const DexFile::MethodId& method2_id = dex_file.GetMethodId(method2->GetDexMethodIndex());
   Handle<mirror::MethodType> method2_type = hs.NewHandle(
       class_linker_->ResolveMethodType(soa.Self(), method2_id.proto_idx_, dex_cache, class_loader));
-  ASSERT_TRUE(method1_type.Get() != method2_type.Get());
+  ASSERT_OBJ_PTR_NE(method1_type.Get(), method2_type.Get());
 }
 
 // Verify that ClassLinker's CreateWellknownClassLoader works as expected
@@ -1599,18 +1607,18 @@ TEST_F(ClassLinkerTest, CreateWellKnownClassLoader) {
 TEST_F(ClassLinkerTest, PrettyClass) {
   ScopedObjectAccess soa(Thread::Current());
   EXPECT_EQ("null", mirror::Class::PrettyClass(nullptr));
-  mirror::Class* c = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;");
+  ObjPtr<mirror::Class> c = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;");
   ASSERT_TRUE(c != nullptr);
-  mirror::Object* o = mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), c, 0);
+  ObjPtr<mirror::Object> o = mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), c, 0);
   EXPECT_EQ("java.lang.Class<java.lang.String[]>", mirror::Class::PrettyClass(o->GetClass()));
 }
 
 TEST_F(ClassLinkerTest, PrettyClassAndClassLoader) {
   ScopedObjectAccess soa(Thread::Current());
   EXPECT_EQ("null", mirror::Class::PrettyClassAndClassLoader(nullptr));
-  mirror::Class* c = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;");
+  ObjPtr<mirror::Class> c = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;");
   ASSERT_TRUE(c != nullptr);
-  mirror::Object* o = mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), c, 0);
+  ObjPtr<mirror::Object> o = mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), c, 0);
   EXPECT_EQ("java.lang.Class<java.lang.String[],null>",
             mirror::Class::PrettyClassAndClassLoader(o->GetClass()));
 }
@@ -1619,8 +1627,8 @@ TEST_F(ClassLinkerTest, PrettyField) {
   ScopedObjectAccess soa(Thread::Current());
   EXPECT_EQ("null", ArtField::PrettyField(nullptr));
 
-  mirror::Class* java_lang_String = class_linker_->FindSystemClass(soa.Self(),
-                                                                   "Ljava/lang/String;");
+  ObjPtr<mirror::Class> java_lang_String = class_linker_->FindSystemClass(soa.Self(),
+                                                                          "Ljava/lang/String;");
 
   ArtField* f;
   f = java_lang_String->FindDeclaredInstanceField("count", "I");
@@ -1630,7 +1638,7 @@ TEST_F(ClassLinkerTest, PrettyField) {
 
 TEST_F(ClassLinkerTest, JniShortName_JniLongName) {
   ScopedObjectAccess soa(Thread::Current());
-  mirror::Class* c = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/String;");
+  ObjPtr<mirror::Class> c = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/String;");
   ASSERT_TRUE(c != nullptr);
   ArtMethod* m;
 
@@ -1682,7 +1690,7 @@ class ClassLinkerClassLoaderTest : public ClassLinkerTest {
       ASSERT_TRUE(klass != nullptr) << descriptor;
       Handle<mirror::ClassLoader> expected_class_loader(
           hs.NewHandle(soa.Decode<mirror::ClassLoader>(expected_class_loader_obj)));
-      ASSERT_EQ(klass->GetClassLoader(), expected_class_loader.Get());
+      ASSERT_OBJ_PTR_EQ(klass->GetClassLoader(), expected_class_loader.Get());
     }
   }
 };