[Clank] Add JNI interface for media persistent license storage

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.SuppressLint;
 import android.annotation.TargetApi;
 import android.media.MediaCrypto;
 import android.media.MediaDrm;
@@ skipping 65 matching lines @@
 
     // A session only for the purpose of creating a MediaCrypto object. Created
     // after construction, or after the provisioning process is successfully
     // completed. No getKeyRequest() should be called on |mMediaCryptoSession|.
     private SessionId mMediaCryptoSession;
 
     // The map of all opened sessions (excluding mMediaCryptoSession) to their
     // associated meta data, e.g. mime types, key types.
     private MediaDrmSessionManager mSessionManager;
 
+    // The persistent storage to record origin provisioning informations.
+    private MediaDrmStorageBridge mStorage;
+
     // The queue of all pending createSession() data.
     private ArrayDeque<PendingCreateSessionData> mPendingCreateSessionDataQueue;
 
     private boolean mResetDeviceCredentialsPending;
 
     // MediaDrmBridge is waiting for provisioning response from the server.
     private boolean mProvisioningPending;
 
     /**
      *  An equivalent of MediaDrm.KeyStatus, which is only available on M+.
@@ skipping 93 matching lines @@
 
     private boolean isNativeMediaDrmBridgeValid() {
         return mNativeMediaDrmBridge != INVALID_NATIVE_MEDIA_DRM_BRIDGE;
     }
 
     private boolean isWidevine() {
         return mSchemeUUID.equals(WIDEVINE_UUID);
     }
 
     @TargetApi(Build.VERSION_CODES.M)
-    private MediaDrmBridge(UUID schemeUUID, long nativeMediaDrmBridge)
-            throws android.media.UnsupportedSchemeException {
+    private MediaDrmBridge(UUID schemeUUID, long nativeMediaDrmBridge,
+            long nativeMediaDrmStorageBridge) throws android.media.UnsupportedSchemeException {
         mSchemeUUID = schemeUUID;
         mMediaDrm = new MediaDrm(schemeUUID);
 
         mNativeMediaDrmBridge = nativeMediaDrmBridge;
         assert isNativeMediaDrmBridgeValid();
 
-        mSessionManager = new MediaDrmSessionManager();
+        mStorage = new MediaDrmStorageBridge(nativeMediaDrmStorageBridge);
+        mSessionManager = new MediaDrmSessionManager(mStorage);
+
         mPendingCreateSessionDataQueue = new ArrayDeque<PendingCreateSessionData>();
         mResetDeviceCredentialsPending = false;
         mProvisioningPending = false;
 
         mMediaDrm.setOnEventListener(new EventListener());
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
             mMediaDrm.setOnExpirationUpdateListener(new ExpirationUpdateListener(), null);
             mMediaDrm.setOnKeyStatusChangeListener(new KeyStatusChangeListener(), null);
         }
 
@@ skipping 105 matching lines @@
         return MediaDrm.isCryptoSchemeSupported(cryptoScheme, containerMimeType);
     }
 
     /**
      * Create a new MediaDrmBridge from the crypto scheme UUID.
      *
      * @param schemeUUID Crypto scheme UUID.
      * @param securityOrigin Security origin. Empty value means no need for origin isolated storage.
      * @param securityLevel Security level. If empty, the default one should be used.
      * @param nativeMediaDrmBridge Native object of this class.
+     * @param nativeMediaDrmStorageBridge Native object of persistent storage.
      */
     @CalledByNative
     private static MediaDrmBridge create(byte[] schemeUUID, String securityOrigin,
-            String securityLevel, long nativeMediaDrmBridge) {
+            String securityLevel, long nativeMediaDrmBridge, long nativeMediaDrmStorageBridge) {
         UUID cryptoScheme = getUUIDFromBytes(schemeUUID);
         if (cryptoScheme == null || !MediaDrm.isCryptoSchemeSupported(cryptoScheme)) {
             return null;
         }
 
         MediaDrmBridge mediaDrmBridge = null;
         try {
-            mediaDrmBridge = new MediaDrmBridge(cryptoScheme, nativeMediaDrmBridge);
+            mediaDrmBridge = new MediaDrmBridge(
+                    cryptoScheme, nativeMediaDrmBridge, nativeMediaDrmStorageBridge);
             Log.d(TAG, "MediaDrmBridge successfully created.");
         } catch (android.media.UnsupportedSchemeException e) {
             Log.e(TAG, "Unsupported DRM scheme", e);
             return null;
         } catch (java.lang.IllegalArgumentException e) {
             Log.e(TAG, "Failed to create MediaDrmBridge", e);
             return null;
         } catch (java.lang.IllegalStateException e) {
             Log.e(TAG, "Failed to create MediaDrmBridge", e);
             return null;
@@ skipping 151 matching lines @@
             try {
                 // Some implementations don't have removeKeys, crbug/475632
                 mMediaDrm.removeKeys(sessionId.drmId());
             } catch (Exception e) {
                 Log.e(TAG, "removeKeys failed: ", e);
             }
 
             closeSessionNoException(sessionId);
             onSessionClosed(sessionId);
         }
-        mSessionManager = new MediaDrmSessionManager();
+        mSessionManager = new MediaDrmSessionManager(mStorage);
 
         // Close mMediaCryptoSession if it's open or notify MediaCrypto
         // creation failure if it's never successfully opened.
         if (mMediaCryptoSession == null) {
             // MediaCrypto never notified. Notify a null one now.
             onMediaCryptoReady(null);
         } else {
             closeSessionNoException(mMediaCryptoSession);
             mMediaCryptoSession = null;
         }
@@ skipping 383 matching lines @@
         if (mResetDeviceCredentialsPending) {
             onResetDeviceCredentialsCompleted(success);
             mResetDeviceCredentialsPending = false;
         }
 
         if (!success || (mMediaCryptoSession == null && !createMediaCrypto())) {
             release();
             return;
         }
 
-        processPendingCreateSessionData();
+        if (!useOriginIsolatedStorage()) {
+            processPendingCreateSessionData();
+            return;
+        }
+
+        mStorage.onProvisioned(new Callback<Boolean>() {
+            @Override
+            public void onResult(Boolean initSuccess) {
+                if (!initSuccess) {
+                    Log.e(TAG, "Failed to initialize storage for origin");
+                    release();
+                    return;
+                }
+
+                processPendingCreateSessionData();
+            }
+        });
+    }
+
+    private boolean useOriginIsolatedStorage() {
+        assert mMediaDrm != null;
+
+        boolean isMOrHigher = Build.VERSION.SDK_INT >= Build.VERSION_CODES.M;
+        boolean isOriginSet = !isWidevine() || !mMediaDrm.getPropertyString(ORIGIN).isEmpty();

[xhwang, 2017/03/31 03:47:57]

Is it ever possible that getPropertyString(ORIGIN) returns a non-empty string
for non-widevine or on a pre-M device? Will it be sufficient if we just check
!mMediaDrm.getPropertyString(ORIGIN).isEmpty() ?

[yucliu1, 2017/03/31 05:38:17]

We should check origin only for M or higher device. Since we return true in
setOrigin for other key systems (line 388), we also need to return true here. I
have a question here, do we want to support other key system in this release? If
no, I'll change setOrigin and here to return false. What do you think?

[xhwang, 2017/03/31 06:25:50]

At least for now, per-origin provisioning is a requirement for persistent
license. So one option is you can store a boolean on line 396, then check it
here. I am not sure whether mMediaDrm.getPropertyString(ORIGIN).isEmpty() is
equivalent to that. For now, storing a boolean (e.g. mIsOriginSet) seems to be
the easiest.

[yucliu1, 2017/03/31 18:42:30]

Good point! And I think we want to disable the feature for non-widevine key
systems for now. I can do that in another patch, at cpp level.

+
+        return isMOrHigher && isOriginSet;
     }
 
     /**
      * Provides the provision response to MediaDrm.
      *
      * @returns false if the response is invalid or on error, true otherwise.
      */
     boolean provideProvisionResponse(byte[] response) {
         if (response == null || response.length == 0) {
             Log.e(TAG, "Invalid provision response.");
@@ skipping 205 matching lines @@
             long nativeMediaDrmBridge, byte[] emeSessionId, int requestType, byte[] message);
     private native void nativeOnSessionClosed(long nativeMediaDrmBridge, byte[] emeSessionId);
     private native void nativeOnSessionKeysChange(long nativeMediaDrmBridge, byte[] emeSessionId,
             Object[] keysInfo, boolean hasAdditionalUsableKey);
     private native void nativeOnSessionExpirationUpdate(
             long nativeMediaDrmBridge, byte[] emeSessionId, long expirationTime);
 
     private native void nativeOnResetDeviceCredentialsCompleted(
             long nativeMediaDrmBridge, boolean success);
 }