Revert^4 "Use cpplint.py from repohooks"

This reverts commit dc26639f11ef2a97bc9aa9d9f4a8b8cbf9791481.

Reason for revert: repohooks now in sync across branches
                   (thanks to tavila@).
Bug: 200914293
Test: Treehugger
Test: m cpplint-art

Change-Id: I55cf52db799e7d99dde488ff0bfbc7b3dc158a59

7 files changed, 80 insertions, 41 deletions

diff --git a/build/Android.cpplint.mk b/build/Android.cpplint.mk
index ce68214a9e..ab70e97ac5 100644
--- a/build/Android.cpplint.mk
+++ b/build/Android.cpplint.mk
@@ -20,7 +20,7 @@ include art/build/Android.common_build.mk
 LOCAL_PATH := $(art_path)
 
 # Use upstream cpplint (toolpath from .repo/manifests/GLOBAL-PREUPLOAD.cfg).
-ART_CPPLINT := external/google-styleguide/cpplint/cpplint.py
+ART_CPPLINT := tools/repohooks/tools/cpplint.py
 
 # This file previously configured many cpplint settings.
 # Everything that could be moved to CPPLINT.cfg has moved there.
diff --git a/dex2oat/common_compiler_driver_test.cc b/dex2oat/common_compiler_driver_test.cc
index 2007c5a970..7e71976729 100644
--- a/dex2oat/common_compiler_driver_test.cc
+++ b/dex2oat/common_compiler_driver_test.cc
@@ -67,7 +67,7 @@ void CommonCompilerDriverTest::ReserveImageSpace() {
   MemMap::Init();
   image_reservation_ = MemMap::MapAnonymous("image reservation",
                                             reinterpret_cast<uint8_t*>(ART_BASE_ADDRESS),
-                                            (size_t)120 * 1024 * 1024,  // 120MB
+                                            static_cast<size_t>(120 * 1024 * 1024),  // 120MB
                                             PROT_NONE,
                                             false /* no need for 4gb flag with fixed mmap */,
                                             /*reuse=*/ false,
diff --git a/dexdump/dexdump.cc b/dexdump/dexdump.cc
index 1d1eab8f01..d10ed26f84 100644
--- a/dexdump/dexdump.cc
+++ b/dexdump/dexdump.cc
@@ -1367,7 +1367,7 @@ static void dumpMethod(const ClassAccessor::Method& method, int i) {
     }
   }
 
- bail:
+bail:
   free(typeDescriptor);
   free(accessStr);
 }
diff --git a/dexlayout/dexlayout.cc b/dexlayout/dexlayout.cc
index 75afc78b0b..86973f6520 100644
--- a/dexlayout/dexlayout.cc
+++ b/dexlayout/dexlayout.cc
@@ -1272,7 +1272,7 @@ void DexLayout::DumpMethod(uint32_t idx,
     }
   }
 
- bail:
+bail:
   free(type_descriptor);
   free(access_str);
 }
diff --git a/runtime/native/jdk_internal_misc_Unsafe.cc b/runtime/native/jdk_internal_misc_Unsafe.cc
index 61154d063e..6acf4a541b 100644
--- a/runtime/native/jdk_internal_misc_Unsafe.cc
+++ b/runtime/native/jdk_internal_misc_Unsafe.cc
@@ -38,6 +38,30 @@
 
 namespace art {
 
+namespace {
+  // Checks a JNI argument `size` fits inside a size_t and throws a RuntimeException if not (see
+  // jdk/internal/misc/Unsafe.java comments).
+  bool ValidJniSizeArgument(jlong size) REQUIRES_SHARED(Locks::mutator_lock_) {
+    const jlong maybe_truncated_size = static_cast<jlong>(static_cast<size_t>(size));
+    if (LIKELY(size >= 0 && size == maybe_truncated_size)) {
+      return true;
+    }
+    ThrowRuntimeException("Bad size: %" PRIu64, size);
+    return false;
+  }
+
+  // Checks a JNI argument `offset` fits inside a size_t and is less than the size. This method
+  // and throws a RuntimeException if not (see jdk/internal/misc/Unsafe.java comments).
+  bool ValidJniOffsetArgument(jlong offset, jlong size) REQUIRES_SHARED(Locks::mutator_lock_) {
+    const jlong maybe_truncated_offset = static_cast<jlong>(static_cast<size_t>(offset));
+    if (LIKELY(offset >= 0 && offset < size && offset == maybe_truncated_offset)) {
+      return true;
+    }
+    ThrowRuntimeException("Bad offset %" PRIu64 " size %" PRIu64, offset, size);
+    return false;
+  }
+}  // namespace
+
 static jboolean Unsafe_compareAndSetInt(JNIEnv* env, jobject, jobject javaObj, jlong offset,
                                         jint expectedValue, jint newValue) {
   ScopedFastNativeObjectAccess soa(env);
@@ -253,17 +277,21 @@ static jint Unsafe_pageSize(JNIEnv* env ATTRIBUTE_UNUSED, jobject ob ATTRIBUTE_U
 
 static jlong Unsafe_allocateMemory(JNIEnv* env, jobject, jlong bytes) {
   ScopedFastNativeObjectAccess soa(env);
+  if (bytes == 0) {
+    return 0;
+  }
   // bytes is nonnegative and fits into size_t
-  if (bytes < 0 || bytes != (jlong)(size_t) bytes) {
-    ThrowIllegalAccessException("wrong number of bytes");
+  if (!ValidJniSizeArgument(bytes)) {
+    DCHECK(soa.Self()->IsExceptionPending());
     return 0;
   }
-  void* mem = malloc(bytes);
+  const size_t malloc_bytes = static_cast<size_t>(bytes);
+  void* mem = malloc(malloc_bytes);
   if (mem == nullptr) {
     soa.Self()->ThrowOutOfMemoryError("native alloc");
     return 0;
   }
-  return (uintptr_t) mem;
+  return reinterpret_cast<uintptr_t>(mem);
 }
 
 static void Unsafe_freeMemory(JNIEnv* env ATTRIBUTE_UNUSED, jobject, jlong address) {
@@ -331,16 +359,17 @@ static void Unsafe_putDoubleJD(JNIEnv* env ATTRIBUTE_UNUSED, jobject, jlong addr
 
 static void Unsafe_copyMemory(JNIEnv *env, jobject unsafe ATTRIBUTE_UNUSED, jlong src,
                               jlong dst, jlong size) {
+  ScopedFastNativeObjectAccess soa(env);
   if (size == 0) {
     return;
   }
   // size is nonnegative and fits into size_t
-  if (size < 0 || size != (jlong)(size_t) size) {
-    ScopedFastNativeObjectAccess soa(env);
-    ThrowIllegalAccessException("wrong number of bytes");
+  if (!ValidJniSizeArgument(size)) {
+    DCHECK(soa.Self()->IsExceptionPending());
+    return;
   }
-  size_t sz = (size_t)size;
-  memcpy(reinterpret_cast<void *>(dst), reinterpret_cast<void *>(src), sz);
+  const size_t memcpy_size = static_cast<size_t>(size);
+  memcpy(reinterpret_cast<void *>(dst), reinterpret_cast<void *>(src), memcpy_size);
 }
 
 template<typename T>
@@ -382,27 +411,32 @@ static void Unsafe_copyMemoryToPrimitiveArray(JNIEnv *env,
     return;
   }
   // size is nonnegative and fits into size_t
-  if (size < 0 || size != (jlong)(size_t) size) {
-    ThrowIllegalAccessException("wrong number of bytes");
+  if (!ValidJniSizeArgument(size)) {
+    DCHECK(soa.Self()->IsExceptionPending());
+    return;
+  }
+  if (!ValidJniOffsetArgument(dstOffset, size)) {
+    DCHECK(soa.Self()->IsExceptionPending());
+    return;
   }
-  size_t sz = (size_t)size;
-  size_t dst_offset = (size_t)dstOffset;
+  const size_t copy_bytes = static_cast<size_t>(size);
+  const size_t dst_offset = static_cast<size_t>(dstOffset);
   ObjPtr<mirror::Object> dst = soa.Decode<mirror::Object>(dstObj);
   ObjPtr<mirror::Class> component_type = dst->GetClass()->GetComponentType();
   if (component_type->IsPrimitiveByte() || component_type->IsPrimitiveBoolean()) {
     // Note: Treating BooleanArray as ByteArray.
-    copyToArray(srcAddr, ObjPtr<mirror::ByteArray>::DownCast(dst), dst_offset, sz);
+    copyToArray(srcAddr, ObjPtr<mirror::ByteArray>::DownCast(dst), dst_offset, copy_bytes);
   } else if (component_type->IsPrimitiveShort() || component_type->IsPrimitiveChar()) {
     // Note: Treating CharArray as ShortArray.
-    copyToArray(srcAddr, ObjPtr<mirror::ShortArray>::DownCast(dst), dst_offset, sz);
+    copyToArray(srcAddr, ObjPtr<mirror::ShortArray>::DownCast(dst), dst_offset, copy_bytes);
   } else if (component_type->IsPrimitiveInt() || component_type->IsPrimitiveFloat()) {
     // Note: Treating FloatArray as IntArray.
-    copyToArray(srcAddr, ObjPtr<mirror::IntArray>::DownCast(dst), dst_offset, sz);
+    copyToArray(srcAddr, ObjPtr<mirror::IntArray>::DownCast(dst), dst_offset, copy_bytes);
   } else if (component_type->IsPrimitiveLong() || component_type->IsPrimitiveDouble()) {
     // Note: Treating DoubleArray as LongArray.
-    copyToArray(srcAddr, ObjPtr<mirror::LongArray>::DownCast(dst), dst_offset, sz);
+    copyToArray(srcAddr, ObjPtr<mirror::LongArray>::DownCast(dst), dst_offset, copy_bytes);
   } else {
-    ThrowIllegalAccessException("not a primitive array");
+    ThrowIllegalArgumentException("not a primitive array");
   }
 }
 
@@ -417,27 +451,32 @@ static void Unsafe_copyMemoryFromPrimitiveArray(JNIEnv *env,
     return;
   }
   // size is nonnegative and fits into size_t
-  if (size < 0 || size != (jlong)(size_t) size) {
-    ThrowIllegalAccessException("wrong number of bytes");
+  if (!ValidJniSizeArgument(size)) {
+    DCHECK(soa.Self()->IsExceptionPending());
+    return;
+  }
+  if (!ValidJniOffsetArgument(srcOffset, size)) {
+    DCHECK(soa.Self()->IsExceptionPending());
+    return;
   }
-  size_t sz = (size_t)size;
-  size_t src_offset = (size_t)srcOffset;
+  const size_t copy_bytes = static_cast<size_t>(size);
+  const size_t src_offset = static_cast<size_t>(srcOffset);
   ObjPtr<mirror::Object> src = soa.Decode<mirror::Object>(srcObj);
   ObjPtr<mirror::Class> component_type = src->GetClass()->GetComponentType();
   if (component_type->IsPrimitiveByte() || component_type->IsPrimitiveBoolean()) {
     // Note: Treating BooleanArray as ByteArray.
-    copyFromArray(dstAddr, ObjPtr<mirror::ByteArray>::DownCast(src), src_offset, sz);
+    copyFromArray(dstAddr, ObjPtr<mirror::ByteArray>::DownCast(src), src_offset, copy_bytes);
   } else if (component_type->IsPrimitiveShort() || component_type->IsPrimitiveChar()) {
     // Note: Treating CharArray as ShortArray.
-    copyFromArray(dstAddr, ObjPtr<mirror::ShortArray>::DownCast(src), src_offset, sz);
+    copyFromArray(dstAddr, ObjPtr<mirror::ShortArray>::DownCast(src), src_offset, copy_bytes);
   } else if (component_type->IsPrimitiveInt() || component_type->IsPrimitiveFloat()) {
     // Note: Treating FloatArray as IntArray.
-    copyFromArray(dstAddr, ObjPtr<mirror::IntArray>::DownCast(src), src_offset, sz);
+    copyFromArray(dstAddr, ObjPtr<mirror::IntArray>::DownCast(src), src_offset, copy_bytes);
   } else if (component_type->IsPrimitiveLong() || component_type->IsPrimitiveDouble()) {
     // Note: Treating DoubleArray as LongArray.
-    copyFromArray(dstAddr, ObjPtr<mirror::LongArray>::DownCast(src), src_offset, sz);
+    copyFromArray(dstAddr, ObjPtr<mirror::LongArray>::DownCast(src), src_offset, copy_bytes);
   } else {
-    ThrowIllegalAccessException("not a primitive array");
+    ThrowIllegalArgumentException("not a primitive array");
   }
 }
 static jboolean Unsafe_getBoolean(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
diff --git a/runtime/native/sun_misc_Unsafe.cc b/runtime/native/sun_misc_Unsafe.cc
index 5014f340cd..e9c5af013d 100644
--- a/runtime/native/sun_misc_Unsafe.cc
+++ b/runtime/native/sun_misc_Unsafe.cc
@@ -230,7 +230,7 @@ static jint Unsafe_pageSize(JNIEnv* env ATTRIBUTE_UNUSED, jobject ob ATTRIBUTE_U
 static jlong Unsafe_allocateMemory(JNIEnv* env, jobject, jlong bytes) {
   ScopedFastNativeObjectAccess soa(env);
   // bytes is nonnegative and fits into size_t
-  if (bytes < 0 || bytes != (jlong)(size_t) bytes) {
+  if (bytes < 0 || bytes != static_cast<jlong>(static_cast<size_t>(bytes))) {
     ThrowIllegalAccessException("wrong number of bytes");
     return 0;
   }
@@ -311,11 +311,11 @@ static void Unsafe_copyMemory(JNIEnv *env, jobject unsafe ATTRIBUTE_UNUSED, jlon
     return;
   }
   // size is nonnegative and fits into size_t
-  if (size < 0 || size != (jlong)(size_t) size) {
+  if (size < 0 || size != static_cast<jlong>(static_cast<size_t>(size))) {
     ScopedFastNativeObjectAccess soa(env);
     ThrowIllegalAccessException("wrong number of bytes");
   }
-  size_t sz = (size_t)size;
+  size_t sz = static_cast<size_t>(size);
   memcpy(reinterpret_cast<void *>(dst), reinterpret_cast<void *>(src), sz);
 }
 
@@ -358,11 +358,11 @@ static void Unsafe_copyMemoryToPrimitiveArray(JNIEnv *env,
     return;
   }
   // size is nonnegative and fits into size_t
-  if (size < 0 || size != (jlong)(size_t) size) {
+  if (size < 0 || size != static_cast<jlong>(static_cast<size_t>(size))) {
     ThrowIllegalAccessException("wrong number of bytes");
   }
-  size_t sz = (size_t)size;
-  size_t dst_offset = (size_t)dstOffset;
+  size_t sz = static_cast<size_t>(size);
+  size_t dst_offset = static_cast<size_t>(dstOffset);
   ObjPtr<mirror::Object> dst = soa.Decode<mirror::Object>(dstObj);
   ObjPtr<mirror::Class> component_type = dst->GetClass()->GetComponentType();
   if (component_type->IsPrimitiveByte() || component_type->IsPrimitiveBoolean()) {
@@ -393,11 +393,11 @@ static void Unsafe_copyMemoryFromPrimitiveArray(JNIEnv *env,
     return;
   }
   // size is nonnegative and fits into size_t
-  if (size < 0 || size != (jlong)(size_t) size) {
+  if (size < 0 || size != static_cast<jlong>(static_cast<size_t>(size))) {
     ThrowIllegalAccessException("wrong number of bytes");
   }
-  size_t sz = (size_t)size;
-  size_t src_offset = (size_t)srcOffset;
+  size_t sz = static_cast<size_t>(size);
+  size_t src_offset = static_cast<size_t>(srcOffset);
   ObjPtr<mirror::Object> src = soa.Decode<mirror::Object>(srcObj);
   ObjPtr<mirror::Class> component_type = src->GetClass()->GetComponentType();
   if (component_type->IsPrimitiveByte() || component_type->IsPrimitiveBoolean()) {
diff --git a/tools/dmtracedump/tracedump.cc b/tools/dmtracedump/tracedump.cc
index 42527c5699..3cb737474f 100644
--- a/tools/dmtracedump/tracedump.cc
+++ b/tools/dmtracedump/tracedump.cc
@@ -849,7 +849,7 @@ DataKeys* parseKeys(FILE* fp, int32_t verbose) {
     return nullptr;
   }
 
-  if (fread(pKeys->fileData, 1, pKeys->fileLen, fp) != (size_t)pKeys->fileLen) {
+  if (fread(pKeys->fileData, 1, pKeys->fileLen, fp) != static_cast<size_t>(pKeys->fileLen)) {
     fprintf(stderr, "ERROR: unable to read %" PRIu64 " bytes from trace file\n", pKeys->fileLen);
     freeDataKeys(pKeys);
     return nullptr;