Update to Chromium //base at Chromium commit e3a753f17bac62738b0dbf0b36510f767b081e4b.

android/java/src/org/chromium/base/Log.java

 // 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.
 
 package org.chromium.base;
 
 import org.chromium.base.annotations.RemovableInRelease;
 
 import java.util.Locale;
 
 /**
  * Utility class for Logging.
  *
  * <p>
  * Defines logging access points for each feature. They format and forward the logs to
  * {@link android.util.Log}, allowing to standardize the output, to make it easy to identify
  * the origin of logs, and enable or disable logging in different parts of the code.
  * </p>
  * <p>
- * @see usage documentation: <a href="README_logging.md">README_logging.md</a>.
+ * Usage documentation: {@code //docs/logging.md}.
  * </p>
  */
 public class Log {
     /** Convenience property, same as {@link android.util.Log#ASSERT}. */
     public static final int ASSERT = android.util.Log.ASSERT;
 
     /** Convenience property, same as {@link android.util.Log#DEBUG}. */
     public static final int DEBUG = android.util.Log.DEBUG;
 
     /** Convenience property, same as {@link android.util.Log#ERROR}. */
@@ skipping 22 matching lines @@
     }
 
     /**
      * Returns a formatted log message, using the supplied format and arguments.
      * The message will be prepended with the filename and line number of the call.
      */
     private static String formatLogWithStack(String messageTemplate, Object... params) {
         return "[" + getCallOrigin() + "] " + formatLog(messageTemplate, params);
     }
 
-    /** Convenience function, forwards to {@link android.util.Log#isLoggable(String, int)}. */
+    /**
+     * Convenience function, forwards to {@link android.util.Log#isLoggable(String, int)}.
+     *
+     * Note: Has no effect on whether logs are sent or not. Use a method with
+     * {@link RemovableInRelease} to log something in Debug builds only.
+     */
     public static boolean isLoggable(String tag, int level) {
         return android.util.Log.isLoggable(tag, level);
     }
 
     /**
      * Sends a {@link android.util.Log#VERBOSE} log message.
      *
      * For optimization purposes, only the fixed parameters versions are visible. If you need more
      * than 7 parameters, consider building your log message using a function annotated with
      * {@link RemovableInRelease}.
      *
      * @param tag Used to identify the source of a log message.
      * @param messageTemplate The message you would like logged. It is to be specified as a format
      *                        string.
      * @param args Arguments referenced by the format specifiers in the format string. If the last
      *             one is a {@link Throwable}, its trace will be printed.
      */
     private static void verbose(String tag, String messageTemplate, Object... args) {
-        if (Log.isLoggable(tag, Log.VERBOSE)) {
-            String message = formatLogWithStack(messageTemplate, args);
-            Throwable tr = getThrowableToLog(args);
-            if (tr != null) {
-                android.util.Log.v(tag, message, tr);
-            } else {
-                android.util.Log.v(tag, message);
-            }
+        String message = formatLogWithStack(messageTemplate, args);
+        Throwable tr = getThrowableToLog(args);
+        if (tr != null) {
+            android.util.Log.v(tag, message, tr);
+        } else {
+            android.util.Log.v(tag, message);
         }
     }
 
     /** Sends a {@link android.util.Log#VERBOSE} log message. 0 args version. */
     @RemovableInRelease
     @VisibleForTesting
     public static void v(String tag, String message) {
         verbose(tag, message);
     }
 
@@ skipping 58 matching lines @@
      * than 7 parameters, consider building your log message using a function annotated with
      * {@link RemovableInRelease}.
      *
      * @param tag Used to identify the source of a log message.
      * @param messageTemplate The message you would like logged. It is to be specified as a format
      *                        string.
      * @param args Arguments referenced by the format specifiers in the format string. If the last
      *             one is a {@link Throwable}, its trace will be printed.
      */
     private static void debug(String tag, String messageTemplate, Object... args) {
-        if (isLoggable(tag, Log.DEBUG)) {
-            String message = formatLogWithStack(messageTemplate, args);
-            Throwable tr = getThrowableToLog(args);
-            if (tr != null) {
-                android.util.Log.d(tag, message, tr);
-            } else {
-                android.util.Log.d(tag, message);
-            }
+        String message = formatLogWithStack(messageTemplate, args);
+        Throwable tr = getThrowableToLog(args);
+        if (tr != null) {
+            android.util.Log.d(tag, message, tr);
+        } else {
+            android.util.Log.d(tag, message);
         }
     }
 
     /** Sends a {@link android.util.Log#DEBUG} log message. 0 args version. */
     @RemovableInRelease
     @VisibleForTesting
     public static void d(String tag, String message) {
         debug(tag, message);
     }
 
@@ skipping 53 matching lines @@
      * Sends an {@link android.util.Log#INFO} log message.
      *
      * @param tag Used to identify the source of a log message.
      * @param messageTemplate The message you would like logged. It is to be specified as a format
      *                        string.
      * @param args Arguments referenced by the format specifiers in the format string. If the last
      *             one is a {@link Throwable}, its trace will be printed.
      */
     @VisibleForTesting
     public static void i(String tag, String messageTemplate, Object... args) {
-        if (Log.isLoggable(tag, Log.INFO)) {
-            String message = formatLog(messageTemplate, args);
-            Throwable tr = getThrowableToLog(args);
-            if (tr != null) {
-                android.util.Log.i(tag, message, tr);
-            } else {
-                android.util.Log.i(tag, message);
-            }
+        String message = formatLog(messageTemplate, args);
+        Throwable tr = getThrowableToLog(args);
+        if (tr != null) {
+            android.util.Log.i(tag, message, tr);
+        } else {
+            android.util.Log.i(tag, message);
         }
     }
 
     /**
      * Sends a {@link android.util.Log#WARN} log message.
      *
      * @param tag Used to identify the source of a log message.
      * @param messageTemplate The message you would like logged. It is to be specified as a format
      *                        string.
      * @param args Arguments referenced by the format specifiers in the format string. If the last
      *             one is a {@link Throwable}, its trace will be printed.
      */
     @VisibleForTesting
     public static void w(String tag, String messageTemplate, Object... args) {
-        if (Log.isLoggable(tag, Log.WARN)) {
-            String message = formatLog(messageTemplate, args);
-            Throwable tr = getThrowableToLog(args);
-            if (tr != null) {
-                android.util.Log.w(tag, message, tr);
-            } else {
-                android.util.Log.w(tag, message);
-            }
+        String message = formatLog(messageTemplate, args);
+        Throwable tr = getThrowableToLog(args);
+        if (tr != null) {
+            android.util.Log.w(tag, message, tr);
+        } else {
+            android.util.Log.w(tag, message);
         }
     }
 
     /**
      * Sends an {@link android.util.Log#ERROR} log message.
      *
      * @param tag Used to identify the source of a log message.
      * @param messageTemplate The message you would like logged. It is to be specified as a format
      *                        string.
      * @param args Arguments referenced by the format specifiers in the format string. If the last
      *             one is a {@link Throwable}, its trace will be printed.
      */
     @VisibleForTesting
     public static void e(String tag, String messageTemplate, Object... args) {
-        if (Log.isLoggable(tag, Log.ERROR)) {
-            String message = formatLog(messageTemplate, args);
-            Throwable tr = getThrowableToLog(args);
-            if (tr != null) {
-                android.util.Log.e(tag, message, tr);
-            } else {
-                android.util.Log.e(tag, message);
-            }
+        String message = formatLog(messageTemplate, args);
+        Throwable tr = getThrowableToLog(args);
+        if (tr != null) {
+            android.util.Log.e(tag, message, tr);
+        } else {
+            android.util.Log.e(tag, message);
         }
     }
 
     /**
      * What a Terrible Failure: Used for conditions that should never happen, and logged at
      * the {@link android.util.Log#ASSERT} level. Depending on the configuration, it might
      * terminate the process.
      *
      * @see android.util.Log#wtf(String, String, Throwable)
      *
      * @param tag Used to identify the source of a log message.
      * @param messageTemplate The message you would like logged. It is to be specified as a format
      *                        string.
      * @param args Arguments referenced by the format specifiers in the format string. If the last
      *             one is a {@link Throwable}, its trace will be printed.
      */
     @VisibleForTesting
     public static void wtf(String tag, String messageTemplate, Object... args) {
-        if (Log.isLoggable(tag, Log.ASSERT)) {
-            String message = formatLog(messageTemplate, args);
-            Throwable tr = getThrowableToLog(args);
-            if (tr != null) {
-                android.util.Log.wtf(tag, message, tr);
-            } else {
-                android.util.Log.wtf(tag, message);
-            }
+        String message = formatLog(messageTemplate, args);
+        Throwable tr = getThrowableToLog(args);
+        if (tr != null) {
+            android.util.Log.wtf(tag, message, tr);
+        } else {
+            android.util.Log.wtf(tag, message);
         }
     }
 
     private static Throwable getThrowableToLog(Object[] args) {
         if (args == null || args.length == 0) return null;
 
         Object lastArg = args[args.length - 1];
 
         if (!(lastArg instanceof Throwable)) return null;
         return (Throwable) lastArg;
@@ skipping 16 matching lines @@
         for (callerStackIndex = 0; callerStackIndex < st.length; callerStackIndex++) {
             if (st[callerStackIndex].getClassName().equals(logClassName)) {
                 callerStackIndex += 4;
                 break;
             }
         }
 
         return st[callerStackIndex].getFileName() + ":" + st[callerStackIndex].getLineNumber();
     }
 }