Chromium -> Mojo roll.

base/android/java/src/org/chromium/base/library_loader/Linker.java

 // Copyright 2014 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.
 
 package org.chromium.base.library_loader;
 
 import android.os.Bundle;
 import android.os.Parcel;
 import android.os.ParcelFileDescriptor;
 import android.os.Parcelable;
@@ skipping 219 matching lines @@
             if (NativeLibraries.sUseLinker) {
                 if (DEBUG) Log.i(TAG, "Loading lib" + TAG + ".so");
                 try {
                     System.loadLibrary(TAG);
                 } catch (UnsatisfiedLinkError  e) {
                     // In a component build, the ".cr" suffix is added to each library name.
                     Log.w(TAG, "Couldn't load lib" + TAG + ".so, trying lib" + TAG + ".cr.so");
                     System.loadLibrary(TAG + ".cr");
                 }
                 sRelroSharingSupported = nativeCanUseSharedRelro();
-                if (!sRelroSharingSupported)
+                if (!sRelroSharingSupported) {
                     Log.w(TAG, "This system cannot safely share RELRO sections");
-                else {
+                } else {
                     if (DEBUG) Log.i(TAG, "This system supports safe shared RELRO sections");
                 }
 
                 if (sMemoryDeviceConfig == MEMORY_DEVICE_CONFIG_INIT) {
                     sMemoryDeviceConfig = SysUtils.isLowEndDevice()
                             ? MEMORY_DEVICE_CONFIG_LOW : MEMORY_DEVICE_CONFIG_NORMAL;
                 }
 
                 switch (BROWSER_SHARED_RELRO_CONFIG) {
                     case BROWSER_SHARED_RELRO_CONFIG_NEVER:
                         sBrowserUsesSharedRelro = false;
                         break;
                     case BROWSER_SHARED_RELRO_CONFIG_LOW_RAM_ONLY:
                         sBrowserUsesSharedRelro =
                                 (sMemoryDeviceConfig == MEMORY_DEVICE_CONFIG_LOW);
-                        if (sBrowserUsesSharedRelro)
+                        if (sBrowserUsesSharedRelro) {
                             Log.w(TAG, "Low-memory device: shared RELROs used in all processes");
+                        }
                         break;
                     case BROWSER_SHARED_RELRO_CONFIG_ALWAYS:
                         Log.w(TAG, "Beware: shared RELROs used in all processes!");
                         sBrowserUsesSharedRelro = true;
                         break;
                     default:
                         assert false : "Unreached";
                         break;
                 }
             } else {
@@ skipping 68 matching lines @@
      */
     public static void setMemoryDeviceConfig(int memoryDeviceConfig) {
         if (DEBUG) Log.i(TAG, "setMemoryDeviceConfig(" + memoryDeviceConfig + ") called");
         // Sanity check. This method should only be called during tests.
         assert NativeLibraries.sEnableLinkerTests;
         synchronized (Linker.class) {
             assert sMemoryDeviceConfig == MEMORY_DEVICE_CONFIG_INIT;
             assert memoryDeviceConfig == MEMORY_DEVICE_CONFIG_LOW
                    || memoryDeviceConfig == MEMORY_DEVICE_CONFIG_NORMAL;
             if (DEBUG) {
-                if (memoryDeviceConfig == MEMORY_DEVICE_CONFIG_LOW)
+                if (memoryDeviceConfig == MEMORY_DEVICE_CONFIG_LOW) {
                     Log.i(TAG, "Simulating a low-memory device");
-                else
+                } else {
                     Log.i(TAG, "Simulating a regular-memory device");
+                }
             }
             sMemoryDeviceConfig = memoryDeviceConfig;
         }
     }
 
     /**
      * Call this method to determine if this chromium project must
      * use this linker. If not, System.loadLibrary() should be used to load
      * libraries instead.
      */
     public static boolean isUsed() {
         // Only GYP targets that are APKs and have the 'use_chromium_linker' variable
         // defined as 1 will use this linker. For all others (the default), the
         // auto-generated NativeLibraries.sUseLinker variable will be false.
-        if (!NativeLibraries.sUseLinker)
-            return false;
+        if (!NativeLibraries.sUseLinker) return false;
 
         synchronized (Linker.class) {
             ensureInitializedLocked();
             // At the moment, there is also no point in using this linker if the
             // system does not support RELRO sharing safely.
             return sRelroSharingSupported;
         }
     }
 
     /**
@@ skipping 308 matching lines @@
             String libName = entry.getKey();
             LibInfo libInfo = entry.getValue();
             if (!nativeUseSharedRelro(libName, libInfo)) {
                 Log.w(TAG, "Could not use shared RELRO section for " + libName);
             } else {
                 if (DEBUG) Log.i(TAG, "Using shared RELRO section for " + libName);
             }
         }
 
         // In service processes, close all file descriptors from the map now.
-        if (!sInBrowserProcess)
-            closeLibInfoMap(relroMap);
+        if (!sInBrowserProcess) closeLibInfoMap(relroMap);
 
         if (DEBUG) Log.i(TAG, "Linker.useSharedRelrosLocked() exiting");
     }
 
     /**
      * Load a native shared library with the Chromium linker. If the zip file
      * is not null, the shared library must be uncompressed and page aligned
      * inside the zipfile. Note the crazy linker treats libraries and files as
      * equivalent, so you can only open one library in a given zip file. The
      * library must not be the Chromium linker library.
@@ skipping 426 matching lines @@
         }
     }
 
     // The map of libraries that are currently loaded in this process.
     private static HashMap<String, LibInfo> sLoadedLibraries = null;
 
     // Used to pass the shared RELRO Bundle through Binder.
     public static final String EXTRA_LINKER_SHARED_RELROS =
             "org.chromium.base.android.linker.shared_relros";
 }