Update to Chromium //base at Chromium commit 3e81715e6d3a4324362635aea46ce1f1a163cca1.

android/linker/modern_linker_jni.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This is the version of the Android-specific Chromium linker that uses
 // the Android M and later system linker to load libraries.
 
 // This source code *cannot* depend on anything from base/ or the C++
 // STL, to keep the final library small, and avoid ugly dependency issues.
 
@@ skipping 26 matching lines @@
 //
 // The returned string is used to construct the path to libchrome.so when
 // loading directly from APK.
 //
 // |env| is the current JNI environment handle.
 // |clazz| is the static class handle for org.chromium.base.Linker,
 // and is ignored here.
 // Returns the CPU ABI string for which the linker is running.
 jstring GetCpuAbi(JNIEnv* env, jclass clazz) {
 #if defined(__arm__) && defined(__ARM_ARCH_7A__)
-  static const char* kCurrentABI = "armeabi-v7a";
+  static const char* kCurrentAbi = "armeabi-v7a";
 #elif defined(__arm__)
-  static const char* kCurrentABI = "armeabi";
+  static const char* kCurrentAbi = "armeabi";
 #elif defined(__i386__)
-  static const char* kCurrentABI = "x86";
+  static const char* kCurrentAbi = "x86";
 #elif defined(__mips__)
-  static const char* kCurrentABI = "mips";
+  static const char* kCurrentAbi = "mips";
 #elif defined(__x86_64__)
-  static const char* kCurrentABI = "x86_64";
+  static const char* kCurrentAbi = "x86_64";
 #elif defined(__aarch64__)
-  static const char* kCurrentABI = "arm64-v8a";
+  static const char* kCurrentAbi = "arm64-v8a";
 #else
 #error "Unsupported target abi"
 #endif
-  return env->NewStringUTF(kCurrentABI);
+  return env->NewStringUTF(kCurrentAbi);
 }
 
 // Convenience wrapper around dlsym() on the main executable. Returns
 // the address of the requested symbol, or nullptr if not found. Status
 // is available from dlerror().
 void* Dlsym(const char* symbol_name) {
   static void* handle = nullptr;
 
   if (!handle)
     handle = dlopen(nullptr, RTLD_NOW);
@@ skipping 62 matching lines @@
     if (!function_ptr) {
       LOG_ERROR("dlsym: android_dlopen_ext: %s", dlerror());
       return false;
     }
   }
 
   const android_dlextinfo* extinfo = &dlextinfo->extinfo;
   LOG_INFO(
       "android_dlopen_ext:"
       " flags=0x%llx, reserved_addr=%p, reserved_size=%d, relro_fd=%d",
-      extinfo->flags, extinfo->reserved_addr, extinfo->reserved_size,
-      extinfo->relro_fd);
+      static_cast<long long>(extinfo->flags), extinfo->reserved_addr,
+      static_cast<int>(extinfo->reserved_size), extinfo->relro_fd);
 
   *status = (*function_ptr)(filename, flag, extinfo);
   return true;
 }
 
 // Callback data for FindLoadedLibrarySize().
 struct CallbackData {
   explicit CallbackData(void* address) : load_address(address), load_size(0) {}
 
   const void* load_address;
@@ skipping 74 matching lines @@
     if (addr < reinterpret_cast<void*>(kBreakpadGuardRegionBytes)) {
       LOG_ERROR("Fixed address %p is too low to accommodate Breakpad guard",
                 addr);
       addr_ = MAP_FAILED;
       size_ = 0;
       return;
     }
     addr = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(addr) -
                                    kBreakpadGuardRegionBytes);
   }
-  LOG_INFO("Added %d to size, for Breakpad guard", kBreakpadGuardRegionBytes);
+  LOG_INFO("Added %d to size, for Breakpad guard",
+           static_cast<int>(kBreakpadGuardRegionBytes));
 #endif
 
   addr_ = mmap(addr, size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
   if (addr_ != MAP_FAILED) {
     size_ = size;
   } else {
     LOG_INFO("mmap failed: %s", strerror(errno));
     size_ = 0;
   }
   effective_addr_ = addr_;
@@ skipping 34 matching lines @@
   *load_size = callback_data.load_size;
   return true;
 }
 
 // Helper for LoadLibrary(). We reserve an address space larger than
 // needed. After library loading we want to trim that reservation to only
 // what is needed.
 bool ResizeReservedAddressSpace(void* addr,
                                 size_t reserved_size,
                                 size_t load_size) {
-  LOG_INFO("Called for %p, reserved %d, loaded %d", addr, reserved_size,
-           load_size);
+  LOG_INFO("Called for %p, reserved %d, loaded %d", addr,
+           static_cast<int>(reserved_size), static_cast<int>(load_size));
 
   if (reserved_size < load_size) {
     LOG_ERROR("WARNING: library reservation was too small");
     return true;
   }
 
   // Unmap the part of the reserved address space that is beyond the end of
   // the loaded library data.
   void* unmap =
       reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(addr) + load_size);
@@ skipping 279 matching lines @@
   env->RegisterNatives(linker_class, kNativeMethods,
                        sizeof(kNativeMethods) / sizeof(kNativeMethods[0]));
 
   // Record the Java VM handle.
   s_java_vm = vm;
 
   return true;
 }
 
 }  // namespace chromium_android_linker