ART: Add object-array-alloc-inl.h

In an effort to reduce the (transitive) proliferation of heap-inl
add a specific inline header for object array allocation.

Bug: 118385392
Test: mmma art
Test: m test-art-host
Change-Id: I0d7c40ed53708d4c759190961b40f0cac3fe696d

1 files changed, 1 insertions, 48 deletions

diff --git a/runtime/mirror/object_array-inl.h b/runtime/mirror/object_array-inl.h
index 4198d36778..98cc4a886c 100644
--- a/runtime/mirror/object_array-inl.h
+++ b/runtime/mirror/object_array-inl.h
@@ -23,49 +23,18 @@
 
 #include "android-base/stringprintf.h"
 
-#include "array-alloc-inl.h"
 #include "array-inl.h"
 #include "base/utils.h"
 #include "class.h"
-#include "gc/heap.h"
-#include "handle_scope-inl.h"
 #include "obj_ptr-inl.h"
 #include "object-inl.h"
 #include "runtime.h"
-#include "thread.h"
+#include "thread-current-inl.h"
 #include "write_barrier-inl.h"
 
 namespace art {
 namespace mirror {
 
-template<class T>
-inline ObjPtr<ObjectArray<T>> ObjectArray<T>::Alloc(Thread* self,
-                                                    ObjPtr<Class> object_array_class,
-                                                    int32_t length,
-                                                    gc::AllocatorType allocator_type) {
-  ObjPtr<Array> array = Array::Alloc<true>(self,
-                                           object_array_class,
-                                           length,
-                                           ComponentSizeShiftWidth(kHeapReferenceSize),
-                                           allocator_type);
-  if (UNLIKELY(array == nullptr)) {
-    return nullptr;
-  }
-  DCHECK_EQ(array->GetClass()->GetComponentSizeShift(),
-            ComponentSizeShiftWidth(kHeapReferenceSize));
-  return array->AsObjectArray<T>();
-}
-
-template<class T>
-inline ObjPtr<ObjectArray<T>> ObjectArray<T>::Alloc(Thread* self,
-                                                    ObjPtr<Class> object_array_class,
-                                                    int32_t length) {
-  return Alloc(self,
-               object_array_class,
-               length,
-               Runtime::Current()->GetHeap()->GetCurrentAllocator());
-}
-
 template<class T> template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption>
 inline T* ObjectArray<T>::Get(int32_t i) {
   if (!CheckIsValidIndex<kVerifyFlags>(i)) {
@@ -349,22 +318,6 @@ inline void ObjectArray<T>::AssignableCheckingMemcpy(int32_t dst_pos,
 }
 
 template<class T>
-inline ObjPtr<ObjectArray<T>> ObjectArray<T>::CopyOf(Thread* self, int32_t new_length) {
-  DCHECK_GE(new_length, 0);
-  // We may get copied by a compacting GC.
-  StackHandleScope<1> hs(self);
-  Handle<ObjectArray<T>> h_this(hs.NewHandle(this));
-  gc::Heap* heap = Runtime::Current()->GetHeap();
-  gc::AllocatorType allocator_type = heap->IsMovableObject(this) ? heap->GetCurrentAllocator() :
-      heap->GetCurrentNonMovingAllocator();
-  ObjPtr<ObjectArray<T>> new_array = Alloc(self, GetClass(), new_length, allocator_type);
-  if (LIKELY(new_array != nullptr)) {
-    new_array->AssignableMemcpy(0, h_this.Get(), 0, std::min(h_this->GetLength(), new_length));
-  }
-  return new_array;
-}
-
-template<class T>
 inline MemberOffset ObjectArray<T>::OffsetOfElement(int32_t i) {
   return MemberOffset(DataOffset(kHeapReferenceSize).Int32Value() + (i * kHeapReferenceSize));
 }