Update //base to chromium 9659b08ea5a34f889dc4166217f438095ddc10d2

base/android/java/src/org/chromium/base/README_logging.md

 ## Logging ##
 
 Logging used to be done using Android's [android.util.Log]
 (http://developer.android.com/reference/android/util/Log.html).
 
 A wrapper on that is now available: org.chromium.base.Log. It is designed to write logs as
 belonging to logical groups going beyond single classes, and to make it easy to switch logging on
 or off for individual groups.
 
 Usage:
@@ skipping 25 matching lines @@
 
 *   By default, Verbose and Debug logs are not enabled, see guarding:
 
 ### Log calls are guarded: Tag groups can be enabled or disabled using ADB ###
 
     adb shell setprop log.tag.cr.YourModuleTag <LEVEL>
 
 Level here is either `VERBOSE`, `DEBUG`, `INFO`, `WARN`, `ERROR`, `ASSERT`, or `SUPPRESS`
 By default, the level for all tags is `INFO`.
 
+### An exception trace is printed when the exception is the last parameter ###
+
+As with `java.util.Log`, putting a throwable as last parameter will dump the corresponding stack
+trace:
+
+    Log.i(TAG, "An error happened: %s", e)
+
+    I/cr.YourModuleTag: ( 999): An error happened: This is the exception's message
+    I/cr.YourModuleTag: ( 999): java.lang.Exception: This is the exception's message
+    I/cr.YourModuleTag: ( 999):     at foo.bar.MyClass.test(MyClass.java:42)
+    I/cr.YourModuleTag: ( 999):     ...
+
+Having the exception as last parameter doesn't prevent it from being used for string formatting.
+
 ### Logging Best Practices
 
 #### Rule #1: Never log PII (Personal Identification Information):
 
 This is a huge concern, because other applications can access the log and extract a lot of data
 from your own by doing so. Even if JellyBean restricted this, people are going to run your
 application on rooted devices and allow some apps to access it. Also anyone with USB access to the
 device can use ADB to get the full logcat and get the same data right now.
 
 If you really need to print something , print a series of Xs instead (e.g. "XXXXXX"), or print a
@@ skipping 48 matching lines @@
         if (DEBUG) {
           Log.i(TAG, createThatExpensiveLogMessage(activity))
         }
 
     Because the variable is a `static final` that can be evaluated at compile time, the Java
     compiler will optimize out all guarded calls from the generated `.class` file. Changing it
     however requires editing each of the files for which debug should be enabled and recompiling,
     while the previous method can enable or disable debugging for a whole feature without changing
     any source file.
 
--   Annotate debug functions with the `@NoSideEffects` annotation.
+-   Annotate debug functions with the `@RemovableInRelease` annotation.
 
     That annotation tells Proguard to assume that a given function has no side effects, and is
     called only for its returned value. If this value is unused, the call will be removed. If the
     function is not called at all, it will also be removed. Since Proguard is already used to
     strip debug and verbose calls out of release builds, this annotation allows it to have a
     deeper action by removing also function calls used to generate the log call's arguments.
   
         /* If that function is only used in Log.d calls, proguard should completely remove it from
          * the release builds. */
-        @NoSideEffects
+        @RemovableInRelease
         private static String getSomeDebugLogString(Thing[] things) {
           /* Still needs to be guarded to avoid impacting debug builds, or in case it's used for
            * some other log levels. But at least it is done only once, inside the function. */
           if (!Log.isLoggable(TAG, Log.DEBUG)) return null;
 
           StringBuilder sb = new StringBuilder("Reporting " + thing.length + " things:");
           for (Thing thing : things) {
             sb.append('\n').append(thing.id).append(' ').append(report.foo);
           }
           return sb.toString();
@@ skipping 23 matching lines @@
 
 Instead, write this as:
 
     Log.d(TAG, "field1 = %s, field2 = %s, field3 = %s", value1, value2, value3);
 
 That doesn't seem to be much different if you count overall character counts, but each independent
 log entry also implies a small, but non-trivial header, in the kernel log buffer.
 And since every byte count, you can also try something even shorter, as in:
 
     Log.d(TAG, "fields [%s,%s,%s]", value1, value2, value3);