[Android log] Promote using hardcoded string tags

base/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 android.text.TextUtils;
 
 import org.chromium.base.annotations.NoSideEffects;
 
@@ skipping 11 matching lines @@
  * Please make use of the formatting capability of the logging methods rather than doing
  * concatenations in the calling code. In the release builds of Chrome, debug and verbose log
  * calls will be stripped out of the binary. Concatenations and method calls however will still
  * remain and be executed. If they can't be avoided, try to generate the logs in a method annotated
  * with {@link NoSideEffects}. Another possibility is to use
  * {@link android.util.Log#isLoggable(String, int)} to guard those calls.
  * </p>
  *
  * Usage:
  * <pre>
- * private static final String TAG = Log.makeTag("Group");
+ * private static final String TAG = "cr.Group";
  *
  * private void myMethod(String awesome) {
  *   Log.i(TAG, "My %s message.", awesome);
  *   Log.d(TAG, "My debug message");
  * }
  * </pre>
  *
  * Logcat output:
  * <pre>
  * I/cr.Group (999): My awesome message
  * D/cr.Group (999): [MyClass.java:42] My debug message
  * </pre>
  *
  * Set the log level for a given group:
  * <pre>
- * $ adb shell setprop log.tag.chromium.Group VERBOSE
+ * $ adb shell setprop log.tag.cr.Group VERBOSE
  * </pre>
  */
 public class Log {
-    private static final String BASE_TAG = "cr";
-
     /** 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}. */
     public static final int ERROR = android.util.Log.ERROR;
 
     /** Convenience property, same as {@link android.util.Log#INFO}. */
@@ skipping 27 matching lines @@
     }
 
     /**
      * Returns a full tag for the provided group tag. Full tags longer than 23 characters
      * will cause a runtime exception.
      *
      * @param groupTag {@code null} and empty string are allowed.
      *
      * @see android.util.Log#isLoggable(String, int)
      * @throws IllegalArgumentException if the tag is too long.
+     * @deprecated Directly use a string (e.g. "cr.Tag") in your class. See http://crbug.com/485772
      */
+    @Deprecated
     public static String makeTag(String groupTag) {
-        if (TextUtils.isEmpty(groupTag)) return BASE_TAG;
-        String tag = BASE_TAG + "." + groupTag;
+        if (TextUtils.isEmpty(groupTag)) return "cr";
+        String tag = "cr." + groupTag;
         if (tag.length() > 23) {
             throw new IllegalArgumentException(
                     "The full tag (" + tag + ") is longer than 23 characters.");
         }
         return tag;
     }
 
     /** Convenience function, forwards to {@link android.util.Log#isLoggable(String, int)}. */
     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 NoSideEffects}.
      *
-     * @param tag Used to identify the source of a log message. Should be created using
-     *            {@link #makeTag(String)}.
-     *
+     * @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 (android.util.Log.isLoggable(tag, android.util.Log.VERBOSE)) {
             String message = formatLogWithStack(messageTemplate, args);
             Throwable tr = getThrowableToLog(args);
             if (tr != null) {
@@ skipping 49 matching lines @@
         verbose(tag, messageTemplate, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
     }
 
     /**
      * Sends a {@link android.util.Log#DEBUG} 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 NoSideEffects}.
      *
-     * @param tag Used to identify the source of a log message. Should be created using
-     *            {@link #makeTag(String)}.
-     *
+     * @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 (android.util.Log.isLoggable(tag, android.util.Log.VERBOSE)) {
             String message = formatLogWithStack(messageTemplate, args);
             Throwable tr = getThrowableToLog(args);
             if (tr != null) {
@@ skipping 43 matching lines @@
 
     /** Sends a {@link android.util.Log#DEBUG} log message. 7 args version */
     public static void d(String tag, String messageTemplate, Object arg1, Object arg2, Object arg3,
             Object arg4, Object arg5, Object arg6, Object arg7) {
         debug(tag, messageTemplate, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
     }
 
     /**
      * Sends an {@link android.util.Log#INFO} log message.
      *
-     * @param tag Used to identify the source of a log message. Should be created using
-     *            {@link #makeTag(String)}.
+     * @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.
      */
     public static void i(String tag, String messageTemplate, Object... args) {
         if (android.util.Log.isLoggable(tag, android.util.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);
             }
         }
     }
 
     /**
      * Sends a {@link android.util.Log#WARN} log message.
      *
-     * @param tag Used to identify the source of a log message. Should be created using
-     *            {@link #makeTag(String)}.
+     * @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.
      */
     public static void w(String tag, String messageTemplate, Object... args) {
         if (android.util.Log.isLoggable(tag, android.util.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);
             }
         }
     }
 
     /**
      * Sends an {@link android.util.Log#ERROR} log message.
      *
-     * @param tag Used to identify the source of a log message. Should be created using
-     *            {@link #makeTag(String)}.
+     * @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.
      */
     public static void e(String tag, String messageTemplate, Object... args) {
         if (android.util.Log.isLoggable(tag, android.util.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);
             }
         }
     }
 
     /**
      * 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. Should be created using
-     *            {@link #makeTag(String)}.
+     * @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.
      */
     public static void wtf(String tag, String messageTemplate, Object... args) {
         if (android.util.Log.isLoggable(tag, android.util.Log.ERROR)) {
             String message = formatLog(messageTemplate, args);
             Throwable tr = getThrowableToLog(args);
             if (tr != null) {
@@ skipping 30 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();
     }
 }