[Clank] Load/Remove persistent license

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 79 matching lines @@
     private ArrayDeque<PendingCreateSessionData> mPendingCreateSessionDataQueue;
 
     private boolean mResetDeviceCredentialsPending;
 
     // MediaDrmBridge is waiting for provisioning response from the server.
     private boolean mProvisioningPending;
 
     // Boolean to track if 'ORIGIN' is set in MediaDrm.
     private boolean mOriginSet = false;
 
+    // Delay the MediaDrm event handle if present.
+    private SessionEventDeferrer mSessionEventDeferrer = null;
+
+    // Block MediaDrm event for |mSessionId|.
+    private static class SessionEventDeferrer {

[xhwang, 2017/04/05 18:31:50]

Please add more comments why we need this.

[yucliu1, 2017/04/05 23:04:07]

Done.

+        private final SessionId mSessionId;
+        private final ArrayList<Runnable> mEventHandlers;
+
+        SessionEventDeferrer(SessionId sessionId) {
+            mSessionId = sessionId;
+            mEventHandlers = new ArrayList<>();
+        }
+
+        boolean shouldDefer(SessionId sessionId) {
+            return mSessionId.isEqual(sessionId);
+        }
+
+        void defer(Runnable handler) {
+            mEventHandlers.add(handler);
+        }
+
+        void fire() {
+            for (Runnable r : mEventHandlers) {
+                r.run();
+            }
+
+            mEventHandlers.clear();
+        }
+    }
+
     /**
      *  An equivalent of MediaDrm.KeyStatus, which is only available on M+.
      */
     @MainDex
     private static class KeyStatus {
         private final byte[] mKeyId;
         private final int mStatusCode;
 
         private KeyStatus(byte[] keyId, int statusCode) {
             mKeyId = keyId;
@@ skipping 456 matching lines @@
         assert mMediaCryptoSession != null;
         assert !mProvisioningPending;
 
         if (optionalParameters == null) {
             optionalParameters = new HashMap<String, String>();
         }
 
         MediaDrm.KeyRequest request = null;
 
         try {
-            request = mMediaDrm.getKeyRequest(
-                    sessionId.drmId(), data, mime, keyType, optionalParameters);
+            byte[] scopeId =
+                    keyType == MediaDrm.KEY_TYPE_RELEASE ? sessionId.keySetId() : sessionId.drmId();
+            assert scopeId != null;
+            request = mMediaDrm.getKeyRequest(scopeId, data, mime, keyType, 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 %s!", result);
@@ skipping 230 matching lines @@
         final SessionId sessionId = getSessionIdByEmeId(emeSessionId);
         if (sessionId == null) {
             assert false; // Should never happen.
             onPromiseRejected(promiseId,
                     "Invalid session in updateSession: " + SessionId.toHexString(emeSessionId));
             return;
         }
 
         try {
             SessionInfo sessionInfo = mSessionManager.get(sessionId);
-            byte[] keySetId = mMediaDrm.provideKeyResponse(sessionId.drmId(), response);
+            boolean isKeyRelease = sessionInfo.keyType() == MediaDrm.KEY_TYPE_RELEASE;
 
-            if (keySetId != null && keySetId.length > 0) {
-                assert sessionInfo.keyType() == MediaDrm.KEY_TYPE_OFFLINE;
-                mSessionManager.setKeySetId(sessionId, keySetId, new Callback<Boolean>() {
-                    @Override
-                    public void onResult(Boolean success) {
-                        onKeyUpdated(sessionId, promiseId, success);
-                    }
-                });
+            byte[] keySetId = null;
+            if (isKeyRelease) {
+                Log.d(TAG, "updateSession() for key release");
+                assert sessionId.keySetId() != null;
+                mMediaDrm.provideKeyResponse(sessionId.keySetId(), response);
+            } else {
+                keySetId = mMediaDrm.provideKeyResponse(sessionId.drmId(), response);
+            }
+
+            KeyUpdatedCallback cb = new KeyUpdatedCallback(sessionId, promiseId, isKeyRelease);
+
+            if (isKeyRelease) {
+                mSessionManager.clearPersistentSessionInfo(sessionId, cb);
+            } else if (sessionInfo.keyType() == MediaDrm.KEY_TYPE_OFFLINE && keySetId != null
+                    && keySetId.length > 0) {
+                mSessionManager.setKeySetId(sessionId, keySetId, cb);
             } else {
                 // This can be either temporary license update or server certificate update.
-                onKeyUpdated(sessionId, promiseId, true);
+                cb.onResult(true);
             }
 
             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);
         } catch (java.lang.IllegalStateException e) {
             Log.e(TAG, "failed to provide key response", e);
         }
         onPromiseRejected(promiseId, "Update session failed.");
         release();
     }
 
-    private void onKeyUpdated(SessionId sessionId, long promiseId, boolean success) {
-        if (!success) {
-            onPromiseRejected(promiseId, "failed to update key after response accepted");
+    /**
+     * Load persistent license from stroage.
+     */
+    @CalledByNative
+    private void loadSession(byte[] emeId, final long promiseId) {
+        Log.d(TAG, "loadSession()");
+        if (mProvisioningPending) {
+            onPersistentLicenseNoExist(promiseId);
             return;
         }
 
-        Log.d(TAG, "Key successfully added for session %s", sessionId.toHexString());
-        onPromiseResolved(promiseId);
+        mSessionManager.load(emeId, new Callback<SessionId>() {
+            @Override
+            public void onResult(SessionId sessionId) {
+                if (sessionId == null) {
+                    onPersistentLicenseNoExist(promiseId);
+                    return;
+                }
 
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
-            onSessionKeysChange(
-                    sessionId, getDummyKeysInfo(MediaDrm.KeyStatus.STATUS_USABLE).toArray(), true);
+                loadSessionWithLoadedStorage(sessionId, promiseId);
+            }
+        });
+    }
+
+    /**
+     * Load session back to memory with MediaDrm. Load persistent storage
+     * before calling this. It will fail if persistent storage isn't loaded.
+     */
+    private void loadSessionWithLoadedStorage(SessionId sessionId, final long promiseId) {
+        byte[] drmId = null;
+        try {
+            drmId = openSession();
+            if (drmId == null) {
+                onPromiseRejected(promiseId, "Failed to open session to load license");
+                return;
+            }
+
+            mSessionManager.setDrmId(sessionId, drmId);
+
+            // Defer event handlers until license is loaded.
+            assert mSessionEventDeferrer == null;
+            mSessionEventDeferrer = new SessionEventDeferrer(sessionId);
+
+            assert sessionId.keySetId() != null;
+            mMediaDrm.restoreKeys(sessionId.drmId(), sessionId.keySetId());
+
+            onPromiseResolvedWithSession(promiseId, sessionId);
+
+            mSessionEventDeferrer.fire();
+            mSessionEventDeferrer = null;
+
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+                onSessionKeysChange(sessionId,
+                        getDummyKeysInfo(MediaDrm.KeyStatus.STATUS_USABLE).toArray(), true, false);
+            }
+        } catch (android.media.NotProvisionedException e) {
+            onPersistentLicenseNoExist(promiseId);

[xhwang, 2017/04/05 18:31:50]

When can this happen? When user manually unprovisioned the device but didn't
clear the storage? Shall we also close the session and clear the storage in this
case?

For these unexpected cases, fail quickly is probably the best solution :)

[yucliu1, 2017/04/05 23:04:07]

Early return.

+        } catch (java.lang.IllegalStateException e) {
+            // license doesn't exist
+            if (sessionId.drmId() == null) {
+                // TODO(yucliu): Check if the license is released or doesn't exist.
+                onPersistentLicenseNoExist(promiseId);
+                return;
+            }
+
+            closeSessionNoException(sessionId);
+            mSessionManager.clearPersistentSessionInfo(sessionId, new Callback<Boolean>() {
+                @Override
+                public void onResult(Boolean success) {
+                    if (!success) {
+                        Log.w(TAG, "Failed to clear persistent storage for non-exist license");
+                    }
+
+                    onPersistentLicenseNoExist(promiseId);
+                }
+            });
         }
     }
 
+    private void onPersistentLicenseNoExist(long promiseId) {
+        onPromiseResolvedWithSession(promiseId, SessionId.createNoExistSessionId());
+    }
+
+    /**
+     * Remove session from device. This will mark the key as released and
+     * generate a key release request. The license is removed from the device
+     * when the session is updated with a license release response.
+     */
+    @CalledByNative
+    private void removeSession(byte[] emeId, long promiseId) {
+        Log.d(TAG, "removeSession()");
+        SessionId sessionId = getSessionIdByEmeId(emeId);
+
+        if (sessionId == null) {
+            onPromiseRejected(promiseId, "Session doesn't exist");
+            return;
+        }
+
+        SessionInfo sessionInfo = mSessionManager.get(sessionId);
+        if (sessionInfo.keyType() != MediaDrm.KEY_TYPE_OFFLINE) {
+            // TODO(yucliu): Support 'remove' of temporary session.
+            onPromiseRejected(promiseId, "Removing temporary session isn't implemented");
+            return;
+        }
+
+        assert sessionId.keySetId() != null;
+
+        mSessionManager.markKeyReleased(sessionId);
+
+        try {
+            // Get key release request.
+            MediaDrm.KeyRequest request = getKeyRequest(
+                    sessionId, null, sessionInfo.mimeType(), MediaDrm.KEY_TYPE_RELEASE, null);
+
+            if (request == null) {
+                onPromiseRejected(promiseId, "Fail to generate key release request");
+                return;
+            }
+
+            onPromiseResolved(promiseId);
+            onSessionMessage(sessionId, request);

[xhwang, 2017/04/05 18:31:50]

The spec says queue the message, then return the promise. This implementation is
okay since the order of JS events should be the same as expected. But might
worth a comment.

[yucliu1, 2017/04/05 23:04:07]

Switched sequence to match spec.

+        } catch (android.media.NotProvisionedException e) {
+            Log.e(TAG, "removeSession called on unprovisioned device");
+            onPromiseRejected(promiseId, "Unknown failure");
+        }
+    }
+
     /**
      * Return the security level of this DRM object.
      */
     @CalledByNative
     private String getSecurityLevel() {
         if (mMediaDrm == null || !isWidevine()) {
             Log.e(TAG, "getSecurityLevel(): MediaDrm is null or security level is not supported.");
             return null;
         }
         return mMediaDrm.getPropertyString("securityLevel");
@@ skipping 81 matching lines @@
             mMediaDrm.provideProvisionResponse(response);
             return true;
         } catch (android.media.DeniedByServerException e) {
             Log.e(TAG, "failed to provide provision response", e);
         } catch (java.lang.IllegalStateException e) {
             Log.e(TAG, "failed to provide provision response", e);
         }
         return false;
     }
 
+    /**
+     * Delay session event handler if |mSessionEventDeferrer| exists and
+     * matches |sessionId|. Otherwise run the handler immediately.
+     */
+    private void deferEventHandleIfNeeded(SessionId sessionId, Runnable handler) {
+        if (mSessionEventDeferrer != null && mSessionEventDeferrer.shouldDefer(sessionId)) {
+            mSessionEventDeferrer.defer(handler);
+            return;
+        }
+
+        handler.run();
+    }
+
     // Helper functions to make native calls.
 
     private void onMediaCryptoReady(MediaCrypto mediaCrypto) {
         if (isNativeMediaDrmBridgeValid()) {
             nativeOnMediaCryptoReady(mNativeMediaDrmBridge, mediaCrypto);
         }
     }
 
     private void onPromiseResolved(final long promiseId) {
         if (isNativeMediaDrmBridgeValid()) {
@@ skipping 33 matching lines @@
                 mNativeMediaDrmBridge, sessionId.emeId(), requestType, request.getData());
     }
 
     private void onSessionClosed(final SessionId sessionId) {
         if (isNativeMediaDrmBridgeValid()) {
             nativeOnSessionClosed(mNativeMediaDrmBridge, sessionId.emeId());
         }
     }
 
     private void onSessionKeysChange(final SessionId sessionId, final Object[] keysInfo,
-            final boolean hasAdditionalUsableKey) {
+            final boolean hasAdditionalUsableKey, final boolean isKeyRelease) {
         if (isNativeMediaDrmBridgeValid()) {
-            nativeOnSessionKeysChange(
-                    mNativeMediaDrmBridge, sessionId.emeId(), keysInfo, hasAdditionalUsableKey);
+            nativeOnSessionKeysChange(mNativeMediaDrmBridge, sessionId.emeId(), keysInfo,
+                    hasAdditionalUsableKey, isKeyRelease);
         }
     }
 
     private void onSessionExpirationUpdate(final SessionId sessionId, final long expirationTime) {
         if (isNativeMediaDrmBridgeValid()) {
             nativeOnSessionExpirationUpdate(
                     mNativeMediaDrmBridge, sessionId.emeId(), expirationTime);
         }
     }
 
@@ skipping 13 matching lines @@
                 return;
             }
             SessionId sessionId = getSessionIdByDrmId(drmSessionId);
 
             if (sessionId == null) {
                 Log.e(TAG, "EventListener: Invalid session %s",
                         SessionId.toHexString(drmSessionId));
                 return;
             }
 
+            SessionInfo sessionInfo = mSessionManager.get(sessionId);
             switch(event) {
                 case MediaDrm.EVENT_KEY_REQUIRED:
                     Log.d(TAG, "MediaDrm.EVENT_KEY_REQUIRED");
                     if (mProvisioningPending) {
                         return;
                     }
-                    SessionInfo sessionInfo = mSessionManager.get(sessionId);
                     MediaDrm.KeyRequest request = null;
                     try {
                         request = getKeyRequest(sessionId, data, sessionInfo.mimeType(),
                                 sessionInfo.keyType(), null);
                     } catch (android.media.NotProvisionedException e) {
                         Log.e(TAG, "Device not provisioned", e);
                         startProvisioning();
                         return;
                     }
                     if (request != null) {
                         onSessionMessage(sessionId, request);
                     } else {
                         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
                             onSessionKeysChange(sessionId,
                                     getDummyKeysInfo(MediaDrm.KeyStatus.STATUS_INTERNAL_ERROR)
                                             .toArray(),
-                                    false);
+                                    false, false);
                         }
                         Log.e(TAG, "EventListener: getKeyRequest failed.");
                         return;
                     }
                     break;
                 case MediaDrm.EVENT_KEY_EXPIRED:
                     Log.d(TAG, "MediaDrm.EVENT_KEY_EXPIRED");
                     if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
                         onSessionKeysChange(sessionId,
                                 getDummyKeysInfo(MediaDrm.KeyStatus.STATUS_EXPIRED).toArray(),
-                                false);
+                                false, sessionInfo.keyType() == MediaDrm.KEY_TYPE_RELEASE);
                     }
                     break;
                 case MediaDrm.EVENT_VENDOR_DEFINED:
                     Log.d(TAG, "MediaDrm.EVENT_VENDOR_DEFINED");
                     assert false;  // Should never happen.
                     break;
                 default:
                     Log.e(TAG, "Invalid DRM event " + event);
                     return;
             }
         }
     }
 
     @TargetApi(Build.VERSION_CODES.M)
     @MainDex
     private class KeyStatusChangeListener implements MediaDrm.OnKeyStatusChangeListener {
         private List<KeyStatus> getKeysInfo(List<MediaDrm.KeyStatus> keyInformation) {
             List<KeyStatus> keysInfo = new ArrayList<KeyStatus>();
             for (MediaDrm.KeyStatus keyStatus : keyInformation) {
                 keysInfo.add(new KeyStatus(keyStatus.getKeyId(), keyStatus.getStatusCode()));
             }
             return keysInfo;
         }
 
         @Override
         public void onKeyStatusChange(MediaDrm md, byte[] drmSessionId,
-                List<MediaDrm.KeyStatus> keyInformation, boolean hasNewUsableKey) {
-            SessionId sessionId = getSessionIdByDrmId(drmSessionId);
+                final List<MediaDrm.KeyStatus> keyInformation, final boolean hasNewUsableKey) {
+            final SessionId sessionId = getSessionIdByDrmId(drmSessionId);
 
             assert sessionId != null;
+            assert mSessionManager.get(sessionId) != null;
 
-            Log.d(TAG, "KeysStatusChange: " + sessionId.toHexString() + ", " + hasNewUsableKey);
+            final boolean isKeyRelease =
+                    mSessionManager.get(sessionId).keyType() == MediaDrm.KEY_TYPE_RELEASE;
 
-            onSessionKeysChange(sessionId, getKeysInfo(keyInformation).toArray(), hasNewUsableKey);
+            deferEventHandleIfNeeded(sessionId, new Runnable() {
+                @Override
+                public void run() {
+                    Log.d(TAG,
+                            "KeysStatusChange: " + sessionId.toHexString() + ", "
+                                    + hasNewUsableKey);
+                    onSessionKeysChange(sessionId, getKeysInfo(keyInformation).toArray(),
+                            hasNewUsableKey, isKeyRelease);
+                }
+            });
         }
     }
 
     @TargetApi(Build.VERSION_CODES.M)
     @MainDex
     private class ExpirationUpdateListener implements MediaDrm.OnExpirationUpdateListener {
         @Override
-        public void onExpirationUpdate(MediaDrm md, byte[] drmSessionId, long expirationTime) {
-            SessionId sessionId = getSessionIdByDrmId(drmSessionId);
+        public void onExpirationUpdate(
+                MediaDrm md, byte[] drmSessionId, final long expirationTime) {
+            final SessionId sessionId = getSessionIdByDrmId(drmSessionId);
 
             assert sessionId != null;
 
-            Log.d(TAG, "ExpirationUpdate: " + sessionId.toHexString() + ", " + expirationTime);
-            onSessionExpirationUpdate(sessionId, expirationTime);
+            deferEventHandleIfNeeded(sessionId, new Runnable() {
+                @Override
+                public void run() {
+                    Log.d(TAG,
+                            "ExpirationUpdate: " + sessionId.toHexString() + ", " + expirationTime);
+                    onSessionExpirationUpdate(sessionId, expirationTime);
+                }
+            });
         }
     }
 
+    @MainDex
+    private class KeyUpdatedCallback extends Callback<Boolean> {
+        private final SessionId mSessionId;
+        private final long mPromiseId;
+        private final boolean mIsKeyRelease;
+
+        KeyUpdatedCallback(SessionId sessionId, long promiseId, boolean isKeyRelease) {
+            mSessionId = sessionId;
+            mPromiseId = promiseId;
+            mIsKeyRelease = isKeyRelease;
+        }
+
+        @Override
+        public void onResult(Boolean success) {
+            if (!success) {
+                onPromiseRejected(mPromiseId, "failed to update key after response accepted");
+                return;
+            }
+
+            Log.d(TAG, "Key successfully %s for session %s", mIsKeyRelease ? "released" : "added",
+                    mSessionId.toHexString());
+            onPromiseResolved(mPromiseId);
+
+            if (!mIsKeyRelease && Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+                onSessionKeysChange(mSessionId,
+                        getDummyKeysInfo(MediaDrm.KeyStatus.STATUS_USABLE).toArray(), true,
+                        mIsKeyRelease);
+            }
+        }
+    }
+
     // Native functions. At the native side, must post the task immediately to
     // avoid reentrancy issues.
     private native void nativeOnMediaCryptoReady(
             long nativeMediaDrmBridge, MediaCrypto mediaCrypto);
 
     private native void nativeOnStartProvisioning(
             long nativeMediaDrmBridge, String defaultUrl, byte[] requestData);
 
     private native void nativeOnPromiseResolved(long nativeMediaDrmBridge, long promiseId);
     private native void nativeOnPromiseResolvedWithSession(
             long nativeMediaDrmBridge, long promiseId, byte[] emeSessionId);
     private native void nativeOnPromiseRejected(
             long nativeMediaDrmBridge, long promiseId, String errorMessage);
 
     private native void nativeOnSessionMessage(
             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);
+            Object[] keysInfo, boolean hasAdditionalUsableKey, boolean isKeyRelease);
     private native void nativeOnSessionExpirationUpdate(
             long nativeMediaDrmBridge, byte[] emeSessionId, long expirationTime);
 
     private native void nativeOnResetDeviceCredentialsCompleted(
             long nativeMediaDrmBridge, boolean success);
 }