Use ArrayRef<> instead of ArraySlice<> in JVMTI.

And clean up ArrayRef<> a little bit.

Test: m test-art-host-gtest
Test: testrunner.py --host
Change-Id: I4832006b991fc87b2baec9aa605ff70653b029b3

9 files changed, 43 insertions, 38 deletions

diff --git a/runtime/base/array_ref.h b/runtime/base/array_ref.h
index 00b9bad6bf..630a036f3d 100644
--- a/runtime/base/array_ref.h
+++ b/runtime/base/array_ref.h
@@ -40,17 +40,17 @@ namespace art {
 template <typename T>
 class ArrayRef {
  public:
-  typedef T value_type;
-  typedef T& reference;
-  typedef const T& const_reference;
-  typedef T* pointer;
-  typedef const T* const_pointer;
-  typedef T* iterator;
-  typedef const T* const_iterator;
-  typedef std::reverse_iterator<iterator> reverse_iterator;
-  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-  typedef ptrdiff_t difference_type;
-  typedef size_t size_type;
+  using value_type = T;
+  using reference = T&;
+  using const_reference = const T&;
+  using pointer = T*;
+  using const_pointer = const T*;
+  using iterator = T*;
+  using const_iterator = const T*;
+  using reverse_iterator = std::reverse_iterator<iterator>;
+  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+  using difference_type = ptrdiff_t;
+  using size_type = size_t;
 
   // Constructors.
 
@@ -140,22 +140,22 @@ class ArrayRef {
   }
 
   reference front() {
-    DCHECK_NE(size_, 0u);
+    DCHECK(!empty());
     return array_[0];
   }
 
   const_reference front() const {
-    DCHECK_NE(size_, 0u);
+    DCHECK(!empty());
     return array_[0];
   }
 
   reference back() {
-    DCHECK_NE(size_, 0u);
+    DCHECK(!empty());
     return array_[size_ - 1u];
   }
 
   const_reference back() const {
-    DCHECK_NE(size_, 0u);
+    DCHECK(!empty());
     return array_[size_ - 1u];
   }
 
@@ -165,14 +165,17 @@ class ArrayRef {
   ArrayRef SubArray(size_type pos) {
     return SubArray(pos, size() - pos);
   }
+
   ArrayRef<const T> SubArray(size_type pos) const {
     return SubArray(pos, size() - pos);
   }
+
   ArrayRef SubArray(size_type pos, size_type length) {
     DCHECK_LE(pos, size());
     DCHECK_LE(length, size() - pos);
     return ArrayRef(data() + pos, length);
   }
+
   ArrayRef<const T> SubArray(size_type pos, size_type length) const {
     DCHECK_LE(pos, size());
     DCHECK_LE(length, size() - pos);
diff --git a/runtime/openjdkjvmti/art_jvmti.h b/runtime/openjdkjvmti/art_jvmti.h
index 2a2aa4c199..c6f53a66d2 100644
--- a/runtime/openjdkjvmti/art_jvmti.h
+++ b/runtime/openjdkjvmti/art_jvmti.h
@@ -37,7 +37,6 @@
 
 #include <jni.h>
 
-#include "base/array_slice.h"
 #include "base/casts.h"
 #include "base/logging.h"
 #include "base/macros.h"
diff --git a/runtime/openjdkjvmti/ti_class.cc b/runtime/openjdkjvmti/ti_class.cc
index 0aa93dfb57..d67769e8c9 100644
--- a/runtime/openjdkjvmti/ti_class.cc
+++ b/runtime/openjdkjvmti/ti_class.cc
@@ -37,6 +37,7 @@
 #include <unordered_set>
 
 #include "art_jvmti.h"
+#include "base/array_ref.h"
 #include "base/macros.h"
 #include "class_table-inl.h"
 #include "class_linker.h"
@@ -83,7 +84,7 @@ static std::unique_ptr<const art::DexFile> MakeSingleDexFile(art::Thread* self,
       REQUIRES_SHARED(art::Locks::mutator_lock_) {
   // Make the mmap
   std::string error_msg;
-  art::ArraySlice<const unsigned char> final_data(final_dex_data, final_len);
+  art::ArrayRef<const unsigned char> final_data(final_dex_data, final_len);
   std::unique_ptr<art::MemMap> map(Redefiner::MoveDataToMemMap(orig_location,
                                                                final_data,
                                                                &error_msg));
diff --git a/runtime/openjdkjvmti/ti_class_definition.cc b/runtime/openjdkjvmti/ti_class_definition.cc
index 180895b597..8e8ab196f6 100644
--- a/runtime/openjdkjvmti/ti_class_definition.cc
+++ b/runtime/openjdkjvmti/ti_class_definition.cc
@@ -56,7 +56,7 @@ bool ArtClassDefinition::IsModified() const {
   // be that agents were removed in the mean-time so we still have a different dex file. The dex
   // checksum means this is likely to be fairly fast.
   return static_cast<jint>(original_dex_file_.size()) != dex_len_ ||
-      memcmp(&original_dex_file_.At(0), dex_data_.get(), dex_len_) != 0;
+      memcmp(original_dex_file_.data(), dex_data_.get(), dex_len_) != 0;
 }
 
 jvmtiError ArtClassDefinition::InitCommon(ArtJvmTiEnv* env, jclass klass) {
@@ -152,12 +152,12 @@ jvmtiError ArtClassDefinition::Init(ArtJvmTiEnv* env, jclass klass) {
     unsigned char* original_data_memory = nullptr;
     res = CopyDataIntoJvmtiBuffer(env, dex_data_.get(), dex_len_, &original_data_memory);
     original_dex_file_memory_ = MakeJvmtiUniquePtr(env, original_data_memory);
-    original_dex_file_ = art::ArraySlice<const unsigned char>(original_data_memory, dex_len_);
+    original_dex_file_ = art::ArrayRef<const unsigned char>(original_data_memory, dex_len_);
   } else {
     // We know that we have been redefined at least once (there is an original_dex_file set in
     // the class) so we can just use the current dex file directly.
     const art::DexFile& dex_file = m_klass->GetDexFile();
-    original_dex_file_ = art::ArraySlice<const unsigned char>(dex_file.Begin(), dex_file.Size());
+    original_dex_file_ = art::ArrayRef<const unsigned char>(dex_file.Begin(), dex_file.Size());
   }
   return res;
 }
@@ -168,7 +168,7 @@ jvmtiError ArtClassDefinition::Init(ArtJvmTiEnv* env, const jvmtiClassDefinition
     return res;
   }
   unsigned char* new_data = nullptr;
-  original_dex_file_ = art::ArraySlice<const unsigned char>(def.class_bytes, def.class_byte_count);
+  original_dex_file_ = art::ArrayRef<const unsigned char>(def.class_bytes, def.class_byte_count);
   redefined_ = true;
   dex_len_ = def.class_byte_count;
   res = CopyDataIntoJvmtiBuffer(env, def.class_bytes, def.class_byte_count, /*out*/ &new_data);
diff --git a/runtime/openjdkjvmti/ti_class_definition.h b/runtime/openjdkjvmti/ti_class_definition.h
index 43d0c3fc62..2c268ddd4c 100644
--- a/runtime/openjdkjvmti/ti_class_definition.h
+++ b/runtime/openjdkjvmti/ti_class_definition.h
@@ -34,6 +34,8 @@
 
 #include "art_jvmti.h"
 
+#include "base/array_ref.h"
+
 namespace openjdkjvmti {
 
 // A struct that stores data needed for redefining/transforming classes. This structure should only
@@ -68,12 +70,12 @@ class ArtClassDefinition {
     }
   }
 
-  art::ArraySlice<const unsigned char> GetNewOriginalDexFile() const {
+  art::ArrayRef<const unsigned char> GetNewOriginalDexFile() const {
     DCHECK(IsInitialized());
     if (redefined_) {
       return original_dex_file_;
     } else {
-      return art::ArraySlice<const unsigned char>();
+      return art::ArrayRef<const unsigned char>();
     }
   }
 
@@ -103,9 +105,9 @@ class ArtClassDefinition {
     return protection_domain_;
   }
 
-  art::ArraySlice<const unsigned char> GetDexData() const {
+  art::ArrayRef<const unsigned char> GetDexData() const {
     DCHECK(IsInitialized());
-    return art::ArraySlice<const unsigned char>(dex_data_.get(), dex_len_);
+    return art::ArrayRef<const unsigned char>(dex_data_.get(), dex_len_);
   }
 
  private:
@@ -118,7 +120,7 @@ class ArtClassDefinition {
   jint dex_len_;
   JvmtiUniquePtr<unsigned char> dex_data_;
   JvmtiUniquePtr<unsigned char> original_dex_file_memory_;
-  art::ArraySlice<const unsigned char> original_dex_file_;
+  art::ArrayRef<const unsigned char> original_dex_file_;
   bool redefined_;
 
   DISALLOW_COPY_AND_ASSIGN(ArtClassDefinition);
diff --git a/runtime/openjdkjvmti/ti_class_loader.cc b/runtime/openjdkjvmti/ti_class_loader.cc
index 5544dde219..205046c894 100644
--- a/runtime/openjdkjvmti/ti_class_loader.cc
+++ b/runtime/openjdkjvmti/ti_class_loader.cc
@@ -37,7 +37,6 @@
 
 #include "art_field-inl.h"
 #include "art_jvmti.h"
-#include "base/array_slice.h"
 #include "base/logging.h"
 #include "dex_file.h"
 #include "dex_file_types.h"
diff --git a/runtime/openjdkjvmti/ti_redefine.cc b/runtime/openjdkjvmti/ti_redefine.cc
index b382a3e7c3..341de0df72 100644
--- a/runtime/openjdkjvmti/ti_redefine.cc
+++ b/runtime/openjdkjvmti/ti_redefine.cc
@@ -38,7 +38,7 @@
 #include "art_field-inl.h"
 #include "art_method-inl.h"
 #include "art_jvmti.h"
-#include "base/array_slice.h"
+#include "base/array_ref.h"
 #include "base/logging.h"
 #include "class_linker-inl.h"
 #include "debugger.h"
@@ -265,7 +265,7 @@ jvmtiError Redefiner::GetClassRedefinitionError(art::Handle<art::mirror::Class>
 
 // Moves dex data to an anonymous, read-only mmap'd region.
 std::unique_ptr<art::MemMap> Redefiner::MoveDataToMemMap(const std::string& original_location,
-                                                         art::ArraySlice<const unsigned char> data,
+                                                         art::ArrayRef<const unsigned char> data,
                                                          std::string* error_msg) {
   std::unique_ptr<art::MemMap> map(art::MemMap::MapAnonymous(
       StringPrintf("%s-transformed", original_location.c_str()).c_str(),
@@ -278,7 +278,7 @@ std::unique_ptr<art::MemMap> Redefiner::MoveDataToMemMap(const std::string& orig
   if (map == nullptr) {
     return map;
   }
-  memcpy(map->Begin(), &data.At(0), data.size());
+  memcpy(map->Begin(), data.data(), data.size());
   // Make the dex files mmap read only. This matches how other DexFiles are mmaped and prevents
   // programs from corrupting it.
   map->Protect(PROT_READ);
@@ -290,7 +290,7 @@ Redefiner::ClassRedefinition::ClassRedefinition(
     jclass klass,
     const art::DexFile* redefined_dex_file,
     const char* class_sig,
-    art::ArraySlice<const unsigned char> orig_dex_file) :
+    art::ArrayRef<const unsigned char> orig_dex_file) :
       driver_(driver),
       klass_(klass),
       dex_file_(redefined_dex_file),
@@ -493,7 +493,7 @@ art::mirror::Object* Redefiner::ClassRedefinition::AllocateOrGetOriginalDexFile(
   if (original_dex_file_.size() != 0) {
     return art::mirror::ByteArray::AllocateAndFill(
         driver_->self_,
-        reinterpret_cast<const signed char*>(&original_dex_file_.At(0)),
+        reinterpret_cast<const signed char*>(original_dex_file_.data()),
         original_dex_file_.size());
   }
 
diff --git a/runtime/openjdkjvmti/ti_redefine.h b/runtime/openjdkjvmti/ti_redefine.h
index 5e31627694..ec4a8b2789 100644
--- a/runtime/openjdkjvmti/ti_redefine.h
+++ b/runtime/openjdkjvmti/ti_redefine.h
@@ -38,7 +38,7 @@
 
 #include "art_jvmti.h"
 #include "art_method.h"
-#include "base/array_slice.h"
+#include "base/array_ref.h"
 #include "class_linker.h"
 #include "dex_file.h"
 #include "gc_root-inl.h"
@@ -95,7 +95,7 @@ class Redefiner {
   static jvmtiError IsModifiableClass(jvmtiEnv* env, jclass klass, jboolean* is_redefinable);
 
   static std::unique_ptr<art::MemMap> MoveDataToMemMap(const std::string& original_location,
-                                                       art::ArraySlice<const unsigned char> data,
+                                                       art::ArrayRef<const unsigned char> data,
                                                        std::string* error_msg);
 
  private:
@@ -105,7 +105,7 @@ class Redefiner {
                       jclass klass,
                       const art::DexFile* redefined_dex_file,
                       const char* class_sig,
-                      art::ArraySlice<const unsigned char> orig_dex_file)
+                      art::ArrayRef<const unsigned char> orig_dex_file)
       REQUIRES_SHARED(art::Locks::mutator_lock_);
 
     // NO_THREAD_SAFETY_ANALYSIS so we can unlock the class in the destructor.
@@ -205,7 +205,7 @@ class Redefiner {
     jclass klass_;
     std::unique_ptr<const art::DexFile> dex_file_;
     std::string class_sig_;
-    art::ArraySlice<const unsigned char> original_dex_file_;
+    art::ArrayRef<const unsigned char> original_dex_file_;
   };
 
   jvmtiError result_;
diff --git a/runtime/openjdkjvmti/transform.cc b/runtime/openjdkjvmti/transform.cc
index 15d8dd0fc2..1d7f137f2b 100644
--- a/runtime/openjdkjvmti/transform.cc
+++ b/runtime/openjdkjvmti/transform.cc
@@ -35,6 +35,7 @@
 #include "transform.h"
 
 #include "art_method.h"
+#include "base/array_ref.h"
 #include "class_linker.h"
 #include "dex_file.h"
 #include "dex_file_types.h"
@@ -70,7 +71,7 @@ jvmtiError Transformer::RetransformClassesDirect(
   for (ArtClassDefinition& def : *definitions) {
     jint new_len = -1;
     unsigned char* new_data = nullptr;
-    art::ArraySlice<const unsigned char> dex_data = def.GetDexData();
+    art::ArrayRef<const unsigned char> dex_data = def.GetDexData();
     event_handler->DispatchEvent<ArtJvmtiEvent::kClassFileLoadHookRetransformable>(
         self,
         GetJniEnv(env),
@@ -79,7 +80,7 @@ jvmtiError Transformer::RetransformClassesDirect(
         def.GetName().c_str(),
         def.GetProtectionDomain(),
         static_cast<jint>(dex_data.size()),
-        &dex_data.At(0),
+        dex_data.data(),
         /*out*/&new_len,
         /*out*/&new_data);
     def.SetNewDexData(env, new_len, new_data);