Use Chromium's Logging instead of Android's Logging for media files

media/base/android/java/src/org/chromium/media/MediaDrmBridge.java

 // Copyright 2013 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.media;
 
 import android.annotation.TargetApi;
 import android.media.MediaCrypto;
 import android.media.MediaDrm;
 import android.os.AsyncTask;
@@ skipping 38 matching lines @@
     //   b) Finish createSession() if previous createSession() was interrupted
     //      by a NotProvisionedException.
     // - Whenever an unexpected error occurred, we'll call release() to release
     //   all resources and clear all states. In that case all calls to this
     //   object will be no-op. All public APIs and callbacks should check
     //   mMediaBridge to make sure release() hasn't been called. Also, we call
     //   release() immediately after the error happens (e.g. after mMediaDrm)
     //   calls. Indirect calls should not call release() again to avoid
     //   duplication (even though it doesn't hurt to call release() twice).
 
-    private static final String TAG = "MediaDrmBridge";
+    private static final String TAG = Log.makeTag("media.MediaDrmBridge");
     private static final String SECURITY_LEVEL = "securityLevel";
     private static final String SERVER_CERTIFICATE = "serviceCertificate";
     private static final String PRIVACY_MODE = "privacyMode";
     private static final String SESSION_SHARING = "sessionSharing";
     private static final String ENABLE = "enable";
     private static final int INVALID_SESSION_ID = 0;
     private static final char[] HEX_CHAR_LOOKUP = "0123456789ABCDEF".toCharArray();
     private static final long INVALID_NATIVE_MEDIA_DRM_BRIDGE = 0;
 
     // KeyStatus for CDM key information. MUST keep this value in sync with
@@ skipping 134 matching lines @@
         assert !mProvisioningPending;
         assert mMediaCryptoSession == null;
         assert mMediaCrypto == null;
 
         // Open media crypto session.
         mMediaCryptoSession = openSession();
         if (mMediaCryptoSession == null) {
             Log.e(TAG, "Cannot create MediaCrypto Session.");
             return false;
         }
-        Log.d(TAG, "MediaCrypto Session created: " + bytesToHexString(mMediaCryptoSession));
+        Log.d(TAG, "MediaCrypto Session created: %s", bytesToHexString(mMediaCryptoSession));
 
         // Create MediaCrypto object.
         try {
             // TODO: This requires KitKat. Is this class used on pre-KK devices?
             if (MediaCrypto.isCryptoSchemeSupported(mSchemeUUID)) {
                 mMediaCrypto = new MediaCrypto(mSchemeUUID, mMediaCryptoSession);
                 Log.d(TAG, "MediaCrypto successfully created!");
                 // Notify the native code that MediaCrypto is ready.
                 onMediaCryptoReady();
                 return true;
@@ skipping 90 matching lines @@
      * @param securityLevel Security level to be set.
      * @return whether the security level was successfully set.
      */
     @CalledByNative
     private boolean setSecurityLevel(String securityLevel) {
         if (mMediaDrm == null || mMediaCrypto != null) {
             return false;
         }
 
         String currentSecurityLevel = mMediaDrm.getPropertyString(SECURITY_LEVEL);
-        Log.e(TAG, "Security level: current " + currentSecurityLevel + ", new " + securityLevel);
+        Log.e(TAG, "Security level: current %s, new %s", currentSecurityLevel, securityLevel);
         if (securityLevel.equals(currentSecurityLevel)) {
             // No need to set the same security level again. This is not just
             // a shortcut! Setting the same security level actually causes an
             // exception in MediaDrm!
             return true;
         }
 
         try {
             mMediaDrm.setPropertyString(SECURITY_LEVEL, securityLevel);
             return true;
         } catch (java.lang.IllegalArgumentException e) {
-            Log.e(TAG, "Failed to set security level " + securityLevel, e);
+            Log.e(TAG, "Failed to set security level %s", securityLevel, e);
         } catch (java.lang.IllegalStateException e) {
-            Log.e(TAG, "Failed to set security level " + securityLevel, e);
+            Log.e(TAG, "Failed to set security level %s", securityLevel, e);
         }
 
-        Log.e(TAG, "Security level " + securityLevel + " not supported!");
+        Log.e(TAG, "Security level %s not supported!", securityLevel);
         return false;
     }
 
     /**
      * Set the server certificate.
      *
      * @param certificate Server certificate to be set.
      * @return whether the server certificate was successfully set.
      */
     @CalledByNative
@@ skipping 106 matching lines @@
                     sessionId, data, mime, MediaDrm.KEY_TYPE_STREAMING, optionalParameters);
         } catch (IllegalStateException e) {
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && e
                     instanceof android.media.MediaDrm.MediaDrmStateException) {
                 // See b/21307186 for details.
                 Log.e(TAG, "MediaDrmStateException fired during getKeyRequest().", e);
             }
         }
 
         String result = (request != null) ? "successed" : "failed";
-        Log.d(TAG, "getKeyRequest " + result + "!");
+        Log.d(TAG, "getKeyRequest %s!", result);
 
         return request;
     }
 
     /**
      * Save data to |mPendingCreateSessionDataQueue| so that we can resume the
      * createSession() call later.
      *
      * @param initData Data needed to generate the key request.
      * @param mime Mime type.
@@ skipping 103 matching lines @@
 
             MediaDrm.KeyRequest request = null;
             request = getKeyRequest(sessionId, initData, mime, optionalParameters);
             if (request == null) {
                 mMediaDrm.closeSession(sessionId);
                 onPromiseRejected(promiseId, "Generate request failed.");
                 return;
             }
 
             // Success!
-            Log.d(TAG, "createSession(): Session (" + bytesToHexString(sessionId) + ") created.");
+            Log.d(TAG, "createSession(): Session (%s) created.", bytesToHexString(sessionId));
             onPromiseResolvedWithSession(promiseId, sessionId);
             onSessionMessage(sessionId, request);
             mSessionIds.put(ByteBuffer.wrap(sessionId), mime);
         } catch (android.media.NotProvisionedException e) {
             Log.e(TAG, "Device not provisioned", e);
             if (newSessionOpened) {
                 mMediaDrm.closeSession(sessionId);
             }
             savePendingCreateSessionData(initData, mime, optionalParameters, promiseId);
             startProvisioning();
@@ skipping 40 matching lines @@
         try {
             // Some implementations don't have removeKeys, crbug/475632
             mMediaDrm.removeKeys(sessionId);
         } catch (Exception e) {
             Log.e(TAG, "removeKeys failed: ", e);
         }
         mMediaDrm.closeSession(sessionId);
         mSessionIds.remove(ByteBuffer.wrap(sessionId));
         onPromiseResolved(promiseId);
         onSessionClosed(sessionId);
-        Log.d(TAG, "Session " + bytesToHexString(sessionId) + " closed.");
+        Log.d(TAG, "Session %s closed", bytesToHexString(sessionId));
     }
 
     /**
      * Update a session with response.
      *
      * @param sessionId Reference ID of session to be updated.
      * @param response Response data from the server.
      * @param promiseId Promise ID of this call.
      */
     @CalledByNative
@@ skipping 13 matching lines @@
 
         try {
             try {
                 mMediaDrm.provideKeyResponse(sessionId, response);
             } catch (java.lang.IllegalStateException e) {
                 // This is not really an exception. Some error code are incorrectly
                 // reported as an exception.
                 // TODO(qinmin): remove this exception catch when b/10495563 is fixed.
                 Log.e(TAG, "Exception intentionally caught when calling provideKeyResponse()", e);
             }
-            Log.d(TAG, "Key successfully added for session " + bytesToHexString(sessionId));
+            Log.d(TAG, "Key successfully added for session %s", bytesToHexString(sessionId));
             onPromiseResolved(promiseId);
             onSessionKeysChange(sessionId, true, KEY_STATUS_USABLE);
             return;
         } catch (android.media.NotProvisionedException e) {
             // TODO(xhwang): Should we handle this?
             Log.e(TAG, "failed to provide key response", e);
         } catch (android.media.DeniedByServerException e) {
             Log.e(TAG, "failed to provide key response", e);
         }
         onPromiseRejected(promiseId, "Update session failed.");
@@ skipping 100 matching lines @@
             @Override
             public void run() {
                 if (isNativeMediaDrmBridgeValid()) {
                     nativeOnPromiseResolvedWithSession(mNativeMediaDrmBridge, promiseId, sessionId);
                 }
             }
         });
     }
 
     private void onPromiseRejected(final long promiseId, final String errorMessage) {
-        Log.e(TAG, "onPromiseRejected: " + errorMessage);
+        Log.e(TAG, "onPromiseRejected: %s", errorMessage);
         mHandler.post(new Runnable() {
             @Override
             public void run() {
                 if (isNativeMediaDrmBridgeValid()) {
                     nativeOnPromiseRejected(mNativeMediaDrmBridge, promiseId, errorMessage);
                 }
             }
         });
     }
 
@@ skipping 27 matching lines @@
             public void run() {
                 if (isNativeMediaDrmBridgeValid()) {
                     nativeOnSessionKeysChange(
                             mNativeMediaDrmBridge, sessionId, hasAdditionalUsableKey, keyStatus);
                 }
             }
         });
     }
 
     private void onLegacySessionError(final byte[] sessionId, final String errorMessage) {
-        Log.e(TAG, "onLegacySessionError: " + errorMessage);
+        Log.e(TAG, "onLegacySessionError: %s", errorMessage);
         mHandler.post(new Runnable() {
             @Override
             public void run() {
                 if (isNativeMediaDrmBridgeValid()) {
                     nativeOnLegacySessionError(mNativeMediaDrmBridge, sessionId, errorMessage);
                 }
             }
         });
     }
 
@@ skipping 10 matching lines @@
 
     private class MediaDrmListener implements MediaDrm.OnEventListener {
         @Override
         public void onEvent(
                 MediaDrm mediaDrm, byte[] sessionId, int event, int extra, byte[] data) {
             if (sessionId == null) {
                 Log.e(TAG, "MediaDrmListener: Null session.");
                 return;
             }
             if (!sessionExists(sessionId)) {
-                Log.e(TAG, "MediaDrmListener: Invalid session " + bytesToHexString(sessionId));
+                Log.e(TAG, "MediaDrmListener: Invalid session %s", bytesToHexString(sessionId));
                 return;
             }
             switch(event) {
                 case MediaDrm.EVENT_PROVISION_REQUIRED:
                     Log.d(TAG, "MediaDrm.EVENT_PROVISION_REQUIRED");
                     break;
                 case MediaDrm.EVENT_KEY_REQUIRED:
                     Log.d(TAG, "MediaDrm.EVENT_KEY_REQUIRED");
                     if (mProvisioningPending) {
                         return;
@@ skipping 38 matching lines @@
         private byte[] mResponseBody;
 
         public PostRequestTask(byte[] drmRequest) {
             mDrmRequest = drmRequest;
         }
 
         @Override
         protected Void doInBackground(String... urls) {
             mResponseBody = postRequest(urls[0], mDrmRequest);
             if (mResponseBody != null) {
-                Log.d(TAG, "response length=" + mResponseBody.length);
+                Log.d(TAG, "response length=%d", mResponseBody.length);
             }
             return null;
         }
 
         private byte[] postRequest(String url, byte[] drmRequest) {
             HttpURLConnection urlConnection = null;
             try {
                 URL request = new URL(url + "&signedRequest=" + new String(drmRequest));
                 urlConnection = (HttpURLConnection) request.openConnection();
                 urlConnection.setDoOutput(true);
@@ skipping 15 matching lines @@
                         while (true) {
                             read = bis.read(buffer);
                             if (read == -1) break;
                             bos.write(buffer, 0, read);
                         }
                     } finally {
                         bis.close();
                     }
                     return bos.toByteArray();
                 } else {
-                    Log.d(TAG, "Server returned HTTP error code " + responseCode);
+                    Log.d(TAG, "Server returned HTTP error code %d", responseCode);
                     return null;
                 }
             } catch (MalformedURLException e) {
                 e.printStackTrace();
             } catch (IOException e) {
                 e.printStackTrace();
             } catch (IllegalStateException e) {
                 e.printStackTrace();
             } finally {
                 if (urlConnection != null) urlConnection.disconnect();
@@ skipping 19 matching lines @@
             long nativeMediaDrmBridge, byte[] sessionId, byte[] message, String destinationUrl);
     private native void nativeOnSessionClosed(long nativeMediaDrmBridge, byte[] sessionId);
     private native void nativeOnSessionKeysChange(long nativeMediaDrmBridge, byte[] sessionId,
             boolean hasAdditionalUsableKey, int keyStatus);
     private native void nativeOnLegacySessionError(
             long nativeMediaDrmBridge, byte[] sessionId, String errorMessage);
 
     private native void nativeOnResetDeviceCredentialsCompleted(
             long nativeMediaDrmBridge, boolean success);
 }