Partially ObjPtr<>-ify Object, fix stale ref in test.

Test: m test-art-host-gtest
Test: testrunner.py --host --optimizing
Bug: 31113334
Change-Id: I0c0bc669c0ab8d99185e662a2fec16f32a42a0a2

11 files changed, 40 insertions, 39 deletions

diff --git a/runtime/arch/stub_test.cc b/runtime/arch/stub_test.cc
index 8eaa00ae4b..c82b445f81 100644
--- a/runtime/arch/stub_test.cc
+++ b/runtime/arch/stub_test.cc
@@ -940,7 +940,7 @@ TEST_F(StubTest, AllocObject) {
     EXPECT_FALSE(self->IsExceptionPending());
     EXPECT_NE(reinterpret_cast<size_t>(nullptr), result);
     ObjPtr<mirror::Object> obj = reinterpret_cast<mirror::Object*>(result);
-    EXPECT_EQ(c.Get(), obj->GetClass());
+    EXPECT_OBJ_PTR_EQ(c.Get(), obj->GetClass());
     VerifyObject(obj);
   }
 
@@ -952,7 +952,7 @@ TEST_F(StubTest, AllocObject) {
     EXPECT_FALSE(self->IsExceptionPending());
     EXPECT_NE(reinterpret_cast<size_t>(nullptr), result);
     ObjPtr<mirror::Object> obj = reinterpret_cast<mirror::Object*>(result);
-    EXPECT_EQ(c.Get(), obj->GetClass());
+    EXPECT_OBJ_PTR_EQ(c.Get(), obj->GetClass());
     VerifyObject(obj);
   }
 
@@ -964,7 +964,7 @@ TEST_F(StubTest, AllocObject) {
     EXPECT_FALSE(self->IsExceptionPending());
     EXPECT_NE(reinterpret_cast<size_t>(nullptr), result);
     ObjPtr<mirror::Object> obj = reinterpret_cast<mirror::Object*>(result);
-    EXPECT_EQ(c.Get(), obj->GetClass());
+    EXPECT_OBJ_PTR_EQ(c.Get(), obj->GetClass());
     VerifyObject(obj);
   }
 
@@ -1062,7 +1062,7 @@ TEST_F(StubTest, AllocObjectArray) {
     ObjPtr<mirror::Object> obj = reinterpret_cast<mirror::Object*>(result);
     EXPECT_TRUE(obj->IsArrayInstance());
     EXPECT_TRUE(obj->IsObjectArray());
-    EXPECT_EQ(c.Get(), obj->GetClass());
+    EXPECT_OBJ_PTR_EQ(c.Get(), obj->GetClass());
     VerifyObject(obj);
     ObjPtr<mirror::Array> array = reinterpret_cast<mirror::Array*>(result);
     EXPECT_EQ(array->GetLength(), 10);
@@ -2082,7 +2082,7 @@ TEST_F(StubTest, ReadBarrier) {
   EXPECT_FALSE(self->IsExceptionPending());
   EXPECT_NE(reinterpret_cast<size_t>(nullptr), result);
   mirror::Class* klass = reinterpret_cast<mirror::Class*>(result);
-  EXPECT_EQ(klass, obj->GetClass());
+  EXPECT_OBJ_PTR_EQ(klass, obj->GetClass());
 
   // Tests done.
 #else
@@ -2117,7 +2117,7 @@ TEST_F(StubTest, ReadBarrierForRoot) {
   EXPECT_FALSE(self->IsExceptionPending());
   EXPECT_NE(reinterpret_cast<size_t>(nullptr), result);
   mirror::Class* klass = reinterpret_cast<mirror::Class*>(result);
-  EXPECT_EQ(klass, obj->GetClass());
+  EXPECT_OBJ_PTR_EQ(klass, obj->GetClass());
 
   // Tests done.
 #else
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index 6e12eba794..db79128014 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -2985,7 +2985,7 @@ ObjPtr<mirror::Class> ClassLinker::FindClass(Thread* self,
   if (UNLIKELY(old != result_ptr)) {
     // Return `old` (even if `!descriptor_equals`) to mimic the RI behavior for parallel
     // capable class loaders.  (All class loaders are considered parallel capable on Android.)
-    mirror::Class* loader_class = class_loader->GetClass();
+    ObjPtr<mirror::Class> loader_class = class_loader->GetClass();
     const char* loader_class_name =
         loader_class->GetDexFile().StringByTypeIdx(loader_class->GetDexTypeIndex());
     LOG(WARNING) << "Initiating class loader of type " << DescriptorToDot(loader_class_name)
diff --git a/runtime/class_linker_test.cc b/runtime/class_linker_test.cc
index a9343e9aec..1a91abe1ed 100644
--- a/runtime/class_linker_test.cc
+++ b/runtime/class_linker_test.cc
@@ -85,7 +85,7 @@ class ClassLinkerTest : public CommonRuntimeTest {
       REQUIRES_SHARED(Locks::mutator_lock_) {
     ASSERT_TRUE(primitive != nullptr);
     ASSERT_TRUE(primitive->GetClass() != nullptr);
-    ASSERT_EQ(primitive->GetClass(), primitive->GetClass()->GetClass());
+    ASSERT_OBJ_PTR_EQ(primitive->GetClass(), primitive->GetClass()->GetClass());
     EXPECT_TRUE(primitive->GetClass()->GetSuperClass() != nullptr);
     std::string temp;
     ASSERT_STREQ(descriptor.c_str(), primitive->GetDescriptor(&temp));
@@ -124,8 +124,7 @@ class ClassLinkerTest : public CommonRuntimeTest {
       REQUIRES_SHARED(Locks::mutator_lock_) {
     ASSERT_TRUE(JavaLangObject != nullptr);
     ASSERT_TRUE(JavaLangObject->GetClass() != nullptr);
-    ASSERT_EQ(JavaLangObject->GetClass(),
-              JavaLangObject->GetClass()->GetClass());
+    ASSERT_OBJ_PTR_EQ(JavaLangObject->GetClass(), JavaLangObject->GetClass()->GetClass());
     EXPECT_OBJ_PTR_EQ(JavaLangObject, JavaLangObject->GetClass()->GetSuperClass());
     std::string temp;
     ASSERT_STREQ(JavaLangObject->GetDescriptor(&temp), "Ljava/lang/Object;");
@@ -197,7 +196,7 @@ class ClassLinkerTest : public CommonRuntimeTest {
       REQUIRES_SHARED(Locks::mutator_lock_) {
     ASSERT_TRUE(array != nullptr);
     ASSERT_TRUE(array->GetClass() != nullptr);
-    ASSERT_EQ(array->GetClass(), array->GetClass()->GetClass());
+    ASSERT_OBJ_PTR_EQ(array->GetClass(), array->GetClass()->GetClass());
     EXPECT_TRUE(array->GetClass()->GetSuperClass() != nullptr);
     std::string temp;
     ASSERT_STREQ(array_descriptor.c_str(), array->GetDescriptor(&temp));
@@ -274,7 +273,7 @@ class ClassLinkerTest : public CommonRuntimeTest {
       EXPECT_TRUE(klass->GetSuperClass() != nullptr);
     }
     EXPECT_TRUE(klass->GetClass() != nullptr);
-    EXPECT_EQ(klass->GetClass(), klass->GetClass()->GetClass());
+    EXPECT_OBJ_PTR_EQ(klass->GetClass(), klass->GetClass()->GetClass());
     EXPECT_TRUE(klass->GetDexCache() != nullptr);
     EXPECT_TRUE(klass->IsLoaded());
     EXPECT_TRUE(klass->IsResolved());
@@ -927,7 +926,7 @@ TEST_F(ClassLinkerTest, FindClass) {
   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());
+  ASSERT_OBJ_PTR_EQ(MyClass->GetClass(), MyClass->GetClass()->GetClass());
   EXPECT_OBJ_PTR_EQ(JavaLangObject.Get(), MyClass->GetClass()->GetSuperClass());
   std::string temp;
   ASSERT_STREQ(MyClass->GetDescriptor(&temp), "LMyClass;");
@@ -955,7 +954,7 @@ TEST_F(ClassLinkerTest, FindClass) {
   EXPECT_EQ(0U, MyClass->NumStaticFields());
   EXPECT_EQ(0U, MyClass->NumDirectInterfaces());
 
-  EXPECT_EQ(JavaLangObject->GetClass()->GetClass(), MyClass->GetClass()->GetClass());
+  EXPECT_OBJ_PTR_EQ(JavaLangObject->GetClass()->GetClass(), MyClass->GetClass()->GetClass());
 
   // created by class_linker
   AssertArrayClass("[C", "C", nullptr);
diff --git a/runtime/class_loader_utils.h b/runtime/class_loader_utils.h
index 562dc47d21..b809bafc7f 100644
--- a/runtime/class_loader_utils.h
+++ b/runtime/class_loader_utils.h
@@ -22,6 +22,7 @@
 #include "handle_scope.h"
 #include "jni/jni_internal.h"
 #include "mirror/class_loader.h"
+#include "mirror/object-inl.h"
 #include "native/dalvik_system_DexFile.h"
 #include "scoped_thread_state_change-inl.h"
 #include "well_known_classes.h"
@@ -33,7 +34,7 @@ namespace art {
 inline bool IsPathOrDexClassLoader(ScopedObjectAccessAlreadyRunnable& soa,
                                    Handle<mirror::ClassLoader> class_loader)
     REQUIRES_SHARED(Locks::mutator_lock_) {
-  mirror::Class* class_loader_class = class_loader->GetClass();
+  ObjPtr<mirror::Class> class_loader_class = class_loader->GetClass();
   return
       (class_loader_class ==
           soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_PathClassLoader)) ||
@@ -45,7 +46,7 @@ inline bool IsPathOrDexClassLoader(ScopedObjectAccessAlreadyRunnable& soa,
 inline bool IsInMemoryDexClassLoader(ScopedObjectAccessAlreadyRunnable& soa,
                                      Handle<mirror::ClassLoader> class_loader)
     REQUIRES_SHARED(Locks::mutator_lock_) {
-  mirror::Class* class_loader_class = class_loader->GetClass();
+  ObjPtr<mirror::Class> class_loader_class = class_loader->GetClass();
   return (class_loader_class ==
       soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_InMemoryDexClassLoader));
 }
@@ -53,7 +54,7 @@ inline bool IsInMemoryDexClassLoader(ScopedObjectAccessAlreadyRunnable& soa,
 inline bool IsDelegateLastClassLoader(ScopedObjectAccessAlreadyRunnable& soa,
                                       Handle<mirror::ClassLoader> class_loader)
     REQUIRES_SHARED(Locks::mutator_lock_) {
-  mirror::Class* class_loader_class = class_loader->GetClass();
+  ObjPtr<mirror::Class> class_loader_class = class_loader->GetClass();
   return class_loader_class ==
       soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_DelegateLastClassLoader);
 }
diff --git a/runtime/interpreter/unstarted_runtime.cc b/runtime/interpreter/unstarted_runtime.cc
index 6d4d2093b4..9b905eeaed 100644
--- a/runtime/interpreter/unstarted_runtime.cc
+++ b/runtime/interpreter/unstarted_runtime.cc
@@ -1525,7 +1525,7 @@ void UnstartedRuntime::UnstartedUnsafeGetObjectVolatile(
     return;
   }
   int64_t offset = shadow_frame->GetVRegLong(arg_offset + 2);
-  mirror::Object* value = obj->GetFieldObjectVolatile<mirror::Object>(MemberOffset(offset));
+  ObjPtr<mirror::Object> value = obj->GetFieldObjectVolatile<mirror::Object>(MemberOffset(offset));
   result->SetL(value);
 }
 
diff --git a/runtime/jni/check_jni.cc b/runtime/jni/check_jni.cc
index 727929930b..4a8453a721 100644
--- a/runtime/jni/check_jni.cc
+++ b/runtime/jni/check_jni.cc
@@ -359,7 +359,7 @@ class ScopedCheck {
     if (f == nullptr) {
       return false;
     }
-    mirror::Class* c = o->GetClass();
+    ObjPtr<mirror::Class> c = o->GetClass();
     if (c->FindInstanceField(f->GetName(), f->GetTypeDescriptor()) == nullptr) {
       AbortF("jfieldID %s not valid for an object of class %s",
              f->PrettyField().c_str(), o->PrettyTypeOf().c_str());
diff --git a/runtime/mirror/object.cc b/runtime/mirror/object.cc
index 739e0b1970..4afabe2e91 100644
--- a/runtime/mirror/object.cc
+++ b/runtime/mirror/object.cc
@@ -74,9 +74,9 @@ class CopyReferenceFieldsWithReadBarrierVisitor {
   const ObjPtr<Object> dest_obj_;
 };
 
-Object* Object::CopyObject(ObjPtr<mirror::Object> dest,
-                           ObjPtr<mirror::Object> src,
-                           size_t num_bytes) {
+ObjPtr<Object> Object::CopyObject(ObjPtr<mirror::Object> dest,
+                                  ObjPtr<mirror::Object> src,
+                                  size_t num_bytes) {
   // Copy instance data.  Don't assume memcpy copies by words (b/32012820).
   {
     const size_t offset = sizeof(Object);
@@ -131,7 +131,7 @@ Object* Object::CopyObject(ObjPtr<mirror::Object> dest,
   } else {
     WriteBarrier::ForEveryFieldWrite(dest);
   }
-  return dest.Ptr();
+  return dest;
 }
 
 // An allocation pre-fence visitor that copies the object.
@@ -151,7 +151,7 @@ class CopyObjectVisitor {
   DISALLOW_COPY_AND_ASSIGN(CopyObjectVisitor);
 };
 
-Object* Object::Clone(Thread* self) {
+ObjPtr<Object> Object::Clone(Thread* self) {
   CHECK(!IsClass()) << "Can't clone classes.";
   // Object::SizeOf gets the right size even if we're an array. Using c->AllocObject() here would
   // be wrong.
@@ -169,7 +169,7 @@ Object* Object::Clone(Thread* self) {
   if (this_object->GetClass()->IsFinalizable()) {
     heap->AddFinalizerReference(self, &copy);
   }
-  return copy.Ptr();
+  return copy;
 }
 
 uint32_t Object::GenerateIdentityHashCode() {
diff --git a/runtime/mirror/object.h b/runtime/mirror/object.h
index fea6eb5ed2..e68183554e 100644
--- a/runtime/mirror/object.h
+++ b/runtime/mirror/object.h
@@ -130,7 +130,7 @@ class MANAGED LOCKABLE Object {
   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
   size_t SizeOf() REQUIRES_SHARED(Locks::mutator_lock_);
 
-  Object* Clone(Thread* self) REQUIRES_SHARED(Locks::mutator_lock_)
+  ObjPtr<Object> Clone(Thread* self) REQUIRES_SHARED(Locks::mutator_lock_)
       REQUIRES(!Roles::uninterruptible_);
 
   int32_t IdentityHashCode()
@@ -758,9 +758,9 @@ class MANAGED LOCKABLE Object {
   // A utility function that copies an object in a read barrier and write barrier-aware way.
   // This is internally used by Clone() and Class::CopyOf(). If the object is finalizable,
   // it is the callers job to call Heap::AddFinalizerReference.
-  static Object* CopyObject(ObjPtr<mirror::Object> dest,
-                            ObjPtr<mirror::Object> src,
-                            size_t num_bytes)
+  static ObjPtr<Object> CopyObject(ObjPtr<mirror::Object> dest,
+                                   ObjPtr<mirror::Object> src,
+                                   size_t num_bytes)
       REQUIRES_SHARED(Locks::mutator_lock_);
 
   template<VerifyObjectFlags kVerifyFlags, Primitive::Type kType>
diff --git a/runtime/mirror/object_array-inl.h b/runtime/mirror/object_array-inl.h
index 42cabab666..154302e0e8 100644
--- a/runtime/mirror/object_array-inl.h
+++ b/runtime/mirror/object_array-inl.h
@@ -285,7 +285,7 @@ inline void ObjectArray<T>::AssignableCheckingMemcpy(int32_t dst_pos,
         SetWithoutChecks<kTransactionActive>(dst_pos + i, nullptr);
       } else {
         // TODO: use the underlying class reference to avoid uncompression when not necessary.
-        Class* o_class = o->GetClass();
+        ObjPtr<Class> o_class = o->GetClass();
         if (LIKELY(lastAssignableElementClass == o_class)) {
           SetWithoutChecks<kTransactionActive>(dst_pos + i, o);
         } else if (LIKELY(dst_class->IsAssignableFrom(o_class))) {
diff --git a/runtime/mirror/object_test.cc b/runtime/mirror/object_test.cc
index 27987c083f..1cb22f2a5e 100644
--- a/runtime/mirror/object_test.cc
+++ b/runtime/mirror/object_test.cc
@@ -111,7 +111,7 @@ TEST_F(ObjectTest, Clone) {
   StackHandleScope<2> hs(soa.Self());
   Handle<ObjectArray<Object>> a1(hs.NewHandle(AllocObjectArray<Object>(soa.Self(), 256)));
   size_t s1 = a1->SizeOf();
-  Object* clone = a1->Clone(soa.Self());
+  ObjPtr<Object> clone = a1->Clone(soa.Self());
   EXPECT_EQ(s1, clone->SizeOf());
   EXPECT_TRUE(clone->GetClass() == a1->GetClass());
 }
@@ -340,7 +340,8 @@ TEST_F(ObjectTest, CreateMultiArray) {
       dims->Set<false>(0, i);
       dims->Set<false>(1, j);
       multi.Assign(Array::CreateMultiArray(soa.Self(), int_class, dims));
-      EXPECT_TRUE(multi->GetClass() == class_linker_->FindSystemClass(soa.Self(), "[[I"));
+      ObjPtr<mirror::Class> expected_class = class_linker_->FindSystemClass(soa.Self(), "[[I");
+      EXPECT_OBJ_PTR_EQ(multi->GetClass(), expected_class);
       EXPECT_EQ(i, multi->GetLength());
       for (int k = 0; k < i; ++k) {
         ObjPtr<Array> outer = multi->AsObjectArray<Array>()->Get(k);
diff --git a/runtime/transaction_test.cc b/runtime/transaction_test.cc
index fb0a5d9e24..aea2211040 100644
--- a/runtime/transaction_test.cc
+++ b/runtime/transaction_test.cc
@@ -99,10 +99,10 @@ TEST_F(TransactionTest, Object_class) {
   Runtime::Current()->EnterTransactionMode();
   Handle<mirror::Object> h_obj(hs.NewHandle(h_klass->AllocObject(soa.Self())));
   ASSERT_TRUE(h_obj != nullptr);
-  ASSERT_EQ(h_obj->GetClass(), h_klass.Get());
+  ASSERT_OBJ_PTR_EQ(h_obj->GetClass(), h_klass.Get());
   // Rolling back transaction's changes must not clear the Object::class field.
   Runtime::Current()->RollbackAndExitTransactionMode();
-  EXPECT_EQ(h_obj->GetClass(), h_klass.Get());
+  EXPECT_OBJ_PTR_EQ(h_obj->GetClass(), h_klass.Get());
 }
 
 // Tests object's monitor state is preserved after transaction rollback.
@@ -114,7 +114,7 @@ TEST_F(TransactionTest, Object_monitor) {
   ASSERT_TRUE(h_klass != nullptr);
   Handle<mirror::Object> h_obj(hs.NewHandle(h_klass->AllocObject(soa.Self())));
   ASSERT_TRUE(h_obj != nullptr);
-  ASSERT_EQ(h_obj->GetClass(), h_klass.Get());
+  ASSERT_OBJ_PTR_EQ(h_obj->GetClass(), h_klass.Get());
 
   // Lock object's monitor outside the transaction.
   h_obj->MonitorEnter(soa.Self());
@@ -151,7 +151,7 @@ TEST_F(TransactionTest, Array_length) {
                                      h_klass->GetComponentSizeShift(),
                                      Runtime::Current()->GetHeap()->GetCurrentAllocator())));
   ASSERT_TRUE(h_obj != nullptr);
-  ASSERT_EQ(h_obj->GetClass(), h_klass.Get());
+  ASSERT_OBJ_PTR_EQ(h_obj->GetClass(), h_klass.Get());
   Runtime::Current()->RollbackAndExitTransactionMode();
 
   // Rolling back transaction's changes must not reset array's length.
@@ -227,7 +227,7 @@ TEST_F(TransactionTest, StaticFieldsTest) {
   ASSERT_TRUE(object_klass != nullptr);
   Handle<mirror::Object> h_obj(hs.NewHandle(h_klass->AllocObject(soa.Self())));
   ASSERT_TRUE(h_obj != nullptr);
-  ASSERT_EQ(h_obj->GetClass(), h_klass.Get());
+  ASSERT_OBJ_PTR_EQ(h_obj->GetClass(), h_klass.Get());
 
   // Modify fields inside transaction then rollback changes.
   Runtime::Current()->EnterTransactionMode();
@@ -327,7 +327,7 @@ TEST_F(TransactionTest, InstanceFieldsTest) {
   ASSERT_TRUE(object_klass != nullptr);
   Handle<mirror::Object> h_obj(hs.NewHandle(h_klass->AllocObject(soa.Self())));
   ASSERT_TRUE(h_obj != nullptr);
-  ASSERT_EQ(h_obj->GetClass(), h_klass.Get());
+  ASSERT_OBJ_PTR_EQ(h_obj->GetClass(), h_klass.Get());
 
   // Modify fields inside transaction then rollback changes.
   Runtime::Current()->EnterTransactionMode();
@@ -450,7 +450,7 @@ TEST_F(TransactionTest, StaticArrayFieldsTest) {
   ASSERT_TRUE(object_klass != nullptr);
   Handle<mirror::Object> h_obj(hs.NewHandle(h_klass->AllocObject(soa.Self())));
   ASSERT_TRUE(h_obj != nullptr);
-  ASSERT_EQ(h_obj->GetClass(), h_klass.Get());
+  ASSERT_OBJ_PTR_EQ(h_obj->GetClass(), h_klass.Get());
 
   // Modify fields inside transaction then rollback changes.
   Runtime::Current()->EnterTransactionMode();