media: Support unprefixed EME API on Android.

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.media.MediaCrypto;
 import android.media.MediaDrm;
 import android.os.AsyncTask;
 import android.os.Handler;
 import android.util.Log;
 
 import org.apache.http.HttpResponse;
 import org.apache.http.client.ClientProtocolException;
 import org.apache.http.client.HttpClient;
 import org.apache.http.client.methods.HttpPost;
 import org.apache.http.impl.client.DefaultHttpClient;
 import org.apache.http.util.EntityUtils;
 import org.chromium.base.CalledByNative;
 import org.chromium.base.JNINamespace;
 
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.util.ArrayDeque;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.UUID;
 
 /**
  * A wrapper of the android MediaDrm class. Each MediaDrmBridge manages multiple
  * sessions for a single MediaSourcePlayer.
  */
 @JNINamespace("media")
 public class MediaDrmBridge {
     // Implementation Notes:
@@ skipping 17 matching lines @@
     //   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 SECURITY_LEVEL = "securityLevel";
     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();
+
+    // KeyStatus for CDM key information. MUST keep this value in sync with
+    // CdmKeyInformation::KeyStatus.

[dcheng, 2015/01/17 00:08:16]

As I recall, there's some way to automatically generate java bindings from C++
enums. Maybe a cleanup for the future?

[xhwang, 2015/01/17 01:20:40]

+qinmin: If there's a way to do this, I'll be happy to clean this file up in a
separate CL.

+    private static final int KEY_STATUS_USABLE = 0;
+    private static final int KEY_STATUS_INTERNAL_ERROR = 1;
+    private static final int KEY_STATUS_EXPIRED = 2;
+    private static final int KEY_STATUS_OUTPUT_NOT_ALLOWED = 3;
 
     private MediaDrm mMediaDrm;
     private long mNativeMediaDrmBridge;
     private UUID mSchemeUUID;
     private Handler mHandler;
 
     // A session only for the purpose of creating a MediaCrypto object.
     // This session is opened when createSession() is called for the first
     // time. All following createSession() calls will create a new session and
     // use it to call getKeyRequest(). No getKeyRequest() should ever be called
     // on |mMediaCryptoSession|.
-    private ByteBuffer mMediaCryptoSession;
+    private byte[] mMediaCryptoSession;
     private MediaCrypto mMediaCrypto;
 
-    // The map of all opened sessions to their session reference IDs.
-    private HashMap<ByteBuffer, Integer> mSessionIds;
-    // The map of all opened sessions to their mime types.
-    private HashMap<ByteBuffer, String> mSessionMimeTypes;
+    // The map of all opened sessions (excluding mMediaCryptoSession) to their mime types.
+    private HashMap<ByteBuffer, String> mSessionIds;
 
     // The queue of all pending createSession() data.
     private ArrayDeque<PendingCreateSessionData> mPendingCreateSessionDataQueue;
 
     private boolean mResetDeviceCredentialsPending;
 
     // MediaDrmBridge is waiting for provisioning response from the server.
     //
     // Notes about NotProvisionedException: This exception can be thrown in a
     // lot of cases. To streamline implementation, we do not catch it in private
     // non-native methods and only catch it in public APIs.
     private boolean mProvisioningPending;
 
     /**
      *  This class contains data needed to call createSession().
      */
     private static class PendingCreateSessionData {
-        private final int mSessionId;
         private final byte[] mInitData;
         private final String mMimeType;
+        private final long mPromiseId;
 
-        private PendingCreateSessionData(int sessionId, byte[] initData, String mimeType) {
-            mSessionId = sessionId;
+        private PendingCreateSessionData(byte[] initData, String mimeType, long promiseId) {
             mInitData = initData;
             mMimeType = mimeType;
-        }
-
-        private int sessionId() {
-            return mSessionId;
+            mPromiseId = promiseId;
         }
 
         private byte[] initData() {
             return mInitData;
         }
 
         private String mimeType() {
             return mMimeType;
         }
+
+        private long promiseId() {
+            return mPromiseId;
+        }
     }
 
     private static UUID getUUIDFromBytes(byte[] data) {
         if (data.length != 16) {
             return null;
         }
         long mostSigBits = 0;
         long leastSigBits = 0;
         for (int i = 0; i < 8; i++) {
             mostSigBits = (mostSigBits << 8) | (data[i] & 0xff);
         }
         for (int i = 8; i < 16; i++) {
             leastSigBits = (leastSigBits << 8) | (data[i] & 0xff);
         }
         return new UUID(mostSigBits, leastSigBits);
     }
 
     /**
-     *  Gets session associated with the sessionId.
-     *
-     *  @return session if sessionId maps a valid opened session. Returns null
-     *  otherwise.
+     *  Convert byte array to hex string for logging.
+     *  This is modified from BytesToHexString() in url/url_canon_unittest.cc.
      */
-    private ByteBuffer getSession(int sessionId) {
-        for (ByteBuffer session : mSessionIds.keySet()) {
-            if (mSessionIds.get(session) == sessionId) {
-                return session;
-            }
+    private static String bytesToHexString(byte[] bytes) {
+        StringBuffer hexString = new StringBuffer();
+        for (int i = 0; i < bytes.length; ++i) {
+            hexString.append(HEX_CHAR_LOOKUP[bytes[i] >>> 4]);
+            hexString.append(HEX_CHAR_LOOKUP[bytes[i] & 0xf]);
         }
-        return null;
+        return hexString.toString();
     }
 
     private MediaDrmBridge(UUID schemeUUID, long nativeMediaDrmBridge)
             throws android.media.UnsupportedSchemeException {
         mSchemeUUID = schemeUUID;
         mMediaDrm = new MediaDrm(schemeUUID);
         mNativeMediaDrmBridge = nativeMediaDrmBridge;
         mHandler = new Handler();
-        mSessionIds = new HashMap<ByteBuffer, Integer>();
-        mSessionMimeTypes = new HashMap<ByteBuffer, String>();
+        mSessionIds = new HashMap<ByteBuffer, String>();
         mPendingCreateSessionDataQueue = new ArrayDeque<PendingCreateSessionData>();
         mResetDeviceCredentialsPending = false;
         mProvisioningPending = false;
 
         mMediaDrm.setOnEventListener(new MediaDrmListener());
         mMediaDrm.setPropertyString(PRIVACY_MODE, ENABLE);
         mMediaDrm.setPropertyString(SESSION_SHARING, ENABLE);
 
         // We could open a MediaCrypto session here to support faster start of
         // clear lead (no need to wait for createSession()). But on
@@ skipping 14 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: " + mMediaCryptoSession);
+        Log.d(TAG, "MediaCrypto Session created: " + bytesToHexString(mMediaCryptoSession));
 
         // Create MediaCrypto object.
         try {
             if (MediaCrypto.isCryptoSchemeSupported(mSchemeUUID)) {
-                final byte[] mediaCryptoSession = mMediaCryptoSession.array();
-                mMediaCrypto = new MediaCrypto(mSchemeUUID, mediaCryptoSession);
+                mMediaCrypto = new MediaCrypto(mSchemeUUID, mMediaCryptoSession);
                 Log.d(TAG, "MediaCrypto successfully created!");
-                mSessionIds.put(mMediaCryptoSession, INVALID_SESSION_ID);
                 // Notify the native code that MediaCrypto is ready.
                 nativeOnMediaCryptoReady(mNativeMediaDrmBridge);
                 return true;
             } else {
                 Log.e(TAG, "Cannot create MediaCrypto for unsupported scheme.");
             }
         } catch (android.media.MediaCryptoException e) {
             Log.e(TAG, "Cannot create MediaCrypto", e);
         }
 
         release();
         return false;
     }
 
     /**
-     * Open a new session..
+     * Open a new session.
      *
-     * @return the session opened. Returns null if unexpected error happened.
+     * @return ID of the session opened. Returns null if unexpected error happened.
      */
-    private ByteBuffer openSession() throws android.media.NotProvisionedException {
+    private byte[] openSession() throws android.media.NotProvisionedException {
         assert mMediaDrm != null;
         try {
-            byte[] session = mMediaDrm.openSession();
-            // ByteBuffer.wrap() is backed by the byte[]. Make a clone here in
-            // case the underlying byte[] is modified.
-            return ByteBuffer.wrap(session.clone());
+            byte[] sessionId = mMediaDrm.openSession();
+            // Make a clone here in case the underlying byte[] is modified.
+            return sessionId.clone();
         } catch (java.lang.RuntimeException e) {  // TODO(xhwang): Drop this?
             Log.e(TAG, "Cannot open a new session", e);
             release();
             return null;
         } catch (android.media.NotProvisionedException e) {
             // Throw NotProvisionedException so that we can startProvisioning().
             throw e;
         } catch (android.media.MediaDrmException e) {
             // Other MediaDrmExceptions (e.g. ResourceBusyException) are not
             // recoverable.
             Log.e(TAG, "Cannot open a new session", e);
             release();
             return null;
         }
     }
 
     /**
-     * Close a session.
-     *
-     * @param session to be closed.
-     */
-    private void closeSession(ByteBuffer session) {
-        assert mMediaDrm != null;
-        mMediaDrm.closeSession(session.array());
-    }
-
-    /**
      * Check whether the crypto scheme is supported for the given container.
      * If |containerMimeType| is an empty string, we just return whether
      * the crypto scheme is supported.
      *
      * @return true if the container and the crypto scheme is supported, or
      * false otherwise.
      */
     @CalledByNative
     private static boolean isCryptoSchemeSupported(byte[] schemeUUID, String containerMimeType) {
         UUID cryptoScheme = getUUIDFromBytes(schemeUUID);
 
         if (containerMimeType.isEmpty()) {
             return MediaDrm.isCryptoSchemeSupported(cryptoScheme);
         }
 
         return MediaDrm.isCryptoSchemeSupported(cryptoScheme, containerMimeType);
     }
 
     /**
      * Create a new MediaDrmBridge from the crypto scheme UUID.
      *
      * @param schemeUUID Crypto scheme UUID.
-     * @param securityLevel Security level to be used.
      * @param nativeMediaDrmBridge Native object of this class.
      */
     @CalledByNative
     private static MediaDrmBridge create(byte[] schemeUUID, long nativeMediaDrmBridge) {
         UUID cryptoScheme = getUUIDFromBytes(schemeUUID);
         if (cryptoScheme == null || !MediaDrm.isCryptoSchemeSupported(cryptoScheme)) {
             return null;
         }
 
         MediaDrmBridge mediaDrmBridge = null;
         try {
             mediaDrmBridge = new MediaDrmBridge(cryptoScheme, nativeMediaDrmBridge);
             Log.d(TAG, "MediaDrmBridge successfully created.");
         } catch (android.media.UnsupportedSchemeException e) {
             Log.e(TAG, "Unsupported DRM scheme", e);
         } catch (java.lang.IllegalArgumentException e) {
             Log.e(TAG, "Failed to create MediaDrmBridge", e);
         } catch (java.lang.IllegalStateException e) {
             Log.e(TAG, "Failed to create MediaDrmBridge", e);
         }
 
         return mediaDrmBridge;
     }
 
     /**
      * Set the security level that the MediaDrm object uses.
      * This function should be called right after we construct MediaDrmBridge
      * and before we make any other calls.
+     *
+     * @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);
         if (securityLevel.equals(currentSecurityLevel)) {
@@ skipping 36 matching lines @@
     }
 
     /**
      * Release the MediaDrmBridge object.
      */
     @CalledByNative
     private void release() {
         // Do not reset mHandler and mNativeMediaDrmBridge so that we can still
         // post KeyError back to native code.
 
+        for (PendingCreateSessionData data : mPendingCreateSessionDataQueue) {
+            onPromiseRejected(data.promiseId(), "Create session aborted.");
+        }
         mPendingCreateSessionDataQueue.clear();
         mPendingCreateSessionDataQueue = null;
 
-        for (ByteBuffer session : mSessionIds.keySet()) {
-            closeSession(session);
+        for (ByteBuffer sessionId : mSessionIds.keySet()) {
+            mMediaDrm.closeSession(sessionId.array());
         }
         mSessionIds.clear();
         mSessionIds = null;
-        mSessionMimeTypes.clear();
-        mSessionMimeTypes = null;
 
         // This session was closed in the "for" loop above.
         mMediaCryptoSession = null;
 
         if (mMediaCrypto != null) {
             mMediaCrypto.release();
             mMediaCrypto = null;
         }
 
         if (mMediaDrm != null) {
             mMediaDrm.release();
             mMediaDrm = null;
         }
     }
 
     /**
      * Get a key request.
      *
-     * @param session Session on which we need to get the key request.
+     * @param sessionId ID of session on which we need to get the key request.
      * @param data Data needed to get the key request.
      * @param mime Mime type to get the key request.
      *
      * @return the key request.
      */
-    private MediaDrm.KeyRequest getKeyRequest(ByteBuffer session, byte[] data, String mime)
+    private MediaDrm.KeyRequest getKeyRequest(byte[] sessionId, byte[] data, String mime)
             throws android.media.NotProvisionedException {
         assert mMediaDrm != null;
         assert mMediaCrypto != null;
         assert !mProvisioningPending;
 
         HashMap<String, String> optionalParameters = new HashMap<String, String>();
         MediaDrm.KeyRequest request = mMediaDrm.getKeyRequest(
-                session.array(), data, mime, MediaDrm.KEY_TYPE_STREAMING, optionalParameters);
+                sessionId, data, mime, MediaDrm.KEY_TYPE_STREAMING, optionalParameters);
         String result = (request != null) ? "successed" : "failed";
         Log.d(TAG, "getKeyRequest " + 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.
+     * @param promiseId Promise ID for the createSession() call.
      */
-    private void savePendingCreateSessionData(int sessionId, byte[] initData, String mime) {
+    private void savePendingCreateSessionData(byte[] initData, String mime, long promiseId) {
         Log.d(TAG, "savePendingCreateSessionData()");
         mPendingCreateSessionDataQueue.offer(
-                new PendingCreateSessionData(sessionId, initData, mime));
+                new PendingCreateSessionData(initData, mime, promiseId));
     }
 
     /**
      * Process all pending createSession() calls synchronously.
      */
     private void processPendingCreateSessionData() {
         Log.d(TAG, "processPendingCreateSessionData()");
         assert mMediaDrm != null;
 
         // Check mMediaDrm != null because error may happen in createSession().
         // Check !mProvisioningPending because NotProvisionedException may be
         // thrown in createSession().
         while (mMediaDrm != null && !mProvisioningPending
                 && !mPendingCreateSessionDataQueue.isEmpty()) {
             PendingCreateSessionData pendingData = mPendingCreateSessionDataQueue.poll();
-            int sessionId = pendingData.sessionId();
             byte[] initData = pendingData.initData();
             String mime = pendingData.mimeType();
-            createSession(sessionId, initData, mime);
+            long promiseId = pendingData.promiseId();
+            createSession(initData, mime, promiseId);
         }
     }
 
     /**
      * Process pending operations asynchrnously.
      */
     private void resumePendingOperations() {
         mHandler.post(new Runnable(){
             @Override
             public void run() {
                 processPendingCreateSessionData();
             }
         });
     }
 
     /**
-     * Create a session with |sessionId|, |initData| and |mime|.
+     * Create a session, and generate a request with |initData| and |mime|.
      *
-     * @param sessionId ID for the session to be created.
      * @param initData Data needed to generate the key request.
      * @param mime Mime type.
+     * @param promiseId Promise ID for this call.
      */
     @CalledByNative
-    private void createSession(int sessionId, byte[] initData, String mime) {
+    private void createSession(byte[] initData, String mime, long promiseId) {
         Log.d(TAG, "createSession()");
         if (mMediaDrm == null) {
             Log.e(TAG, "createSession() called when MediaDrm is null.");
             return;
         }
 
         if (mProvisioningPending) {
             assert mMediaCrypto == null;
-            savePendingCreateSessionData(sessionId, initData, mime);
+            savePendingCreateSessionData(initData, mime, promiseId);
             return;
         }
 
         boolean newSessionOpened = false;
-        ByteBuffer session = null;
+        byte[] sessionId = null;
         try {
             // Create MediaCrypto if necessary.
             if (mMediaCrypto == null && !createMediaCrypto()) {
-                onSessionError(sessionId);
+                onPromiseRejected(promiseId, "MediaCrypto creation failed.");
                 return;
             }
+            assert mMediaCryptoSession != null;
             assert mMediaCrypto != null;
-            assert mSessionIds.containsKey(mMediaCryptoSession);
 
-            session = openSession();
-            if (session == null) {
-                Log.e(TAG, "Cannot open session in createSession().");
-                onSessionError(sessionId);
+            sessionId = openSession();
+            if (sessionId == null) {
+                onPromiseRejected(promiseId, "Open session failed.");
                 return;
             }
             newSessionOpened = true;
-            assert !mSessionIds.containsKey(session);
+            assert !sessionExists(sessionId);
 
             MediaDrm.KeyRequest request = null;
-            request = getKeyRequest(session, initData, mime);
+            request = getKeyRequest(sessionId, initData, mime);
             if (request == null) {
-                if (newSessionOpened) {
-                    closeSession(session);
-                }
-                onSessionError(sessionId);
+                mMediaDrm.closeSession(sessionId);
+                onPromiseRejected(promiseId, "Generate request failed.");
                 return;
             }
 
-            onSessionCreated(sessionId, getWebSessionId(session));
+            // Success!
+            Log.d(TAG, "createSession(): Session (" + bytesToHexString(sessionId) + ") created.");
+            onPromiseResolvedWithSession(promiseId, sessionId);
             onSessionMessage(sessionId, request);
-            if (newSessionOpened) {
-                Log.d(TAG, "createSession(): Session " + getWebSessionId(session)
-                        + " (" + sessionId + ") created.");
-            }
-
-            mSessionIds.put(session, sessionId);
-            mSessionMimeTypes.put(session, mime);
+            mSessionIds.put(ByteBuffer.wrap(sessionId), mime);
         } catch (android.media.NotProvisionedException e) {
             Log.e(TAG, "Device not provisioned", e);
             if (newSessionOpened) {
-                closeSession(session);
+                mMediaDrm.closeSession(sessionId);
             }
-            savePendingCreateSessionData(sessionId, initData, mime);
+            savePendingCreateSessionData(initData, mime, promiseId);
             startProvisioning();
         }
     }
 
     /**
-     * Returns whether |sessionId| is a valid key session, excluding the media
+     * Check whether |sessionId| is an existing session ID, excluding the media
      * crypto session.
      *
      * @param sessionId Crypto session Id.
+     * @return true if |sessionId| exists, false otherwise.
      */
-    private boolean sessionExists(ByteBuffer session) {
+    private boolean sessionExists(byte[] sessionId) {
         if (mMediaCryptoSession == null) {
             assert mSessionIds.isEmpty();
             Log.e(TAG, "Session doesn't exist because media crypto session is not created.");
             return false;
         }
-        assert mSessionIds.containsKey(mMediaCryptoSession);
-        return !session.equals(mMediaCryptoSession) && mSessionIds.containsKey(session);
+        return !Arrays.equals(sessionId, mMediaCryptoSession)
+                && mSessionIds.containsKey(ByteBuffer.wrap(sessionId));
     }
 
     /**
-     * Cancel a key request for a session Id.
+     * Close a session that was previously created by createSession().
      *
-     * @param sessionId Reference ID of session to be released.
+     * @param sessionId ID of session to be closed.
+     * @param promiseId Promise ID of this call.
      */
     @CalledByNative
-    private void releaseSession(int sessionId) {
-        Log.d(TAG, "releaseSession(): " + sessionId);
+    private void closeSession(byte[] sessionId, long promiseId) {
+        Log.d(TAG, "closeSession()");
         if (mMediaDrm == null) {
-            Log.e(TAG, "releaseSession() called when MediaDrm is null.");
+            onPromiseRejected(promiseId, "closeSession() called when MediaDrm is null.");
             return;
         }
 
-        ByteBuffer session = getSession(sessionId);
-        if (session == null) {
-            Log.e(TAG, "Invalid sessionId in releaseSession.");
-            onSessionError(sessionId);
+        if (!sessionExists(sessionId)) {
+            onPromiseRejected(promiseId,
+                    "Invalid sessionId in closeSession(): " + bytesToHexString(sessionId));
             return;
         }
 
-        mMediaDrm.removeKeys(session.array());
-
-        Log.d(TAG, "Session " + sessionId + "closed.");
-        closeSession(session);
-        mSessionIds.remove(session);
-        onSessionClosed(sessionId);
+        mMediaDrm.removeKeys(sessionId);
+        mMediaDrm.closeSession(sessionId);
+        mSessionIds.remove(ByteBuffer.wrap(sessionId));
+        onPromiseResolved(promiseId);
+        Log.d(TAG, "Session " + bytesToHexString(sessionId) + "closed.");
     }
 
     /**
-     * Add a key for a session Id.
+     * Update a session with response.
      *
      * @param sessionId Reference ID of session to be updated.
-     * @param key Response data from the server.
+     * @param response Response data from the server.
+     * @param promiseId Promise ID of this call.
      */
     @CalledByNative
-    private void updateSession(int sessionId, byte[] key) {
-        Log.d(TAG, "updateSession(): " + sessionId);
+    private void updateSession(byte[] sessionId, byte[] response, long promiseId) {
+        Log.d(TAG, "updateSession()");
         if (mMediaDrm == null) {
-            Log.e(TAG, "updateSession() called when MediaDrm is null.");
+            onPromiseRejected(promiseId, "closeSession() called when MediaDrm is null.");
             return;
         }
 
-        // TODO(xhwang): We should be able to DCHECK this when WD EME is implemented.
-        ByteBuffer session = getSession(sessionId);
-        if (!sessionExists(session)) {
-            Log.e(TAG, "Invalid session in updateSession.");
-            onSessionError(sessionId);
+        // TODO(xhwang): DCHECK this when prefixed EME is deprecated.
+        if (!sessionExists(sessionId)) {
+            onPromiseRejected(
+                    promiseId, "Invalid session in updateSession: " + bytesToHexString(sessionId));
             return;
         }
 
         try {
             try {
-                mMediaDrm.provideKeyResponse(session.array(), key);
+                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);
             }
-            onSessionReady(sessionId);
-            Log.d(TAG, "Key successfully added for session " + sessionId);
+            Log.d(TAG, "Key successfully added for session " + 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);
         }
-        onSessionError(sessionId);
+        onPromiseRejected(promiseId, "Update session failed.");
         release();
     }
 
     /**
      * Return the security level of this DRM object.
      */
     @CalledByNative
     private String getSecurityLevel() {
         if (mMediaDrm == null) {
             Log.e(TAG, "getSecurityLevel() called when MediaDrm is null.");
@@ skipping 34 matching lines @@
             mResetDeviceCredentialsPending = false;
         }
 
         if (success) {
             resumePendingOperations();
         }
     }
 
     /**
      * Provide the provisioning 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.");
             return false;
         }
 
         try {
             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;
     }
 
-    private void onSessionCreated(final int sessionId, final String webSessionId) {
+    // Helper functions to post native calls to prevent reentrancy.
+
+    private void onPromiseResolved(final long promiseId) {
         mHandler.post(new Runnable(){
             @Override
             public void run() {
-                nativeOnSessionCreated(mNativeMediaDrmBridge, sessionId, webSessionId);
+                nativeOnPromiseResolved(mNativeMediaDrmBridge, promiseId);
             }
         });
     }
 
-    private void onSessionMessage(final int sessionId, final MediaDrm.KeyRequest request) {
+    private void onPromiseResolvedWithSession(final long promiseId, final byte[] sessionId) {
         mHandler.post(new Runnable(){
             @Override
             public void run() {
-                nativeOnSessionMessage(mNativeMediaDrmBridge, sessionId,
-                        request.getData(), request.getDefaultUrl());
+                nativeOnPromiseResolvedWithSession(mNativeMediaDrmBridge, promiseId, sessionId);
             }
         });
     }
 
-    private void onSessionReady(final int sessionId) {
+    private void onPromiseRejected(final long promiseId, final String errorMessage) {
+        Log.e(TAG, "onPromiseRejected: " + errorMessage);
         mHandler.post(new Runnable() {
             @Override
             public void run() {
-                nativeOnSessionReady(mNativeMediaDrmBridge, sessionId);
+                nativeOnPromiseRejected(mNativeMediaDrmBridge, promiseId, errorMessage);
             }
         });
     }
 
-    private void onSessionClosed(final int sessionId) {
+    private void onSessionMessage(final byte[] sessionId, final MediaDrm.KeyRequest request) {
         mHandler.post(new Runnable() {
             @Override
             public void run() {
+                nativeOnSessionMessage(mNativeMediaDrmBridge, sessionId, request.getData(),
+                        request.getDefaultUrl());
+            }
+        });
+    }
+
+    private void onSessionClosed(final byte[] sessionId) {
+        mHandler.post(new Runnable() {
+            @Override
+            public void run() {
                 nativeOnSessionClosed(mNativeMediaDrmBridge, sessionId);
             }
         });
     }
 
-    private void onSessionError(final int sessionId) {
-        // TODO(qinmin): pass the error code to native.
+    private void onSessionKeysChange(
+            final byte[] sessionId, final boolean hasAdditionalUsableKey, final int keyStatus) {
         mHandler.post(new Runnable() {
             @Override
             public void run() {
-                nativeOnSessionError(mNativeMediaDrmBridge, sessionId);
+                nativeOnSessionKeysChange(
+                        mNativeMediaDrmBridge, sessionId, hasAdditionalUsableKey, keyStatus);
             }
         });
     }
 
-    private String getWebSessionId(ByteBuffer session) {
-        String webSessionId = null;
-        try {
-            webSessionId = new String(session.array(), "UTF-8");
-        } catch (java.io.UnsupportedEncodingException e) {
-            Log.e(TAG, "getWebSessionId failed", e);
-        } catch (java.lang.NullPointerException e) {
-            Log.e(TAG, "getWebSessionId failed", e);
-        }
-        return webSessionId;
+    private void onLegacySessionError(final byte[] sessionId, final String errorMessage) {
+        Log.e(TAG, "onLegacySessionError: " + errorMessage);
+        mHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                nativeOnLegacySessionError(mNativeMediaDrmBridge, sessionId, errorMessage);
+            }
+        });
     }
 
     private class MediaDrmListener implements MediaDrm.OnEventListener {
         @Override
         public void onEvent(
-                MediaDrm mediaDrm, byte[] sessionArray, int event, int extra, byte[] data) {
-            if (sessionArray == null) {
+                MediaDrm mediaDrm, byte[] sessionId, int event, int extra, byte[] data) {
+            if (sessionId == null) {
                 Log.e(TAG, "MediaDrmListener: Null session.");
                 return;
             }
-            ByteBuffer session = ByteBuffer.wrap(sessionArray);
-            if (!sessionExists(session)) {
-                Log.e(TAG, "MediaDrmListener: Invalid session.");
-                return;
-            }
-            Integer sessionId = mSessionIds.get(session);
-            if (sessionId == null || sessionId == INVALID_SESSION_ID) {
-                Log.e(TAG, "MediaDrmListener: Invalid session ID.");
+            if (!sessionExists(sessionId)) {
+                Log.e(TAG, "MediaDrmListener: Invalid session " + 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;
                     }
-                    String mime = mSessionMimeTypes.get(session);
+                    String mime = mSessionIds.get(ByteBuffer.wrap(sessionId));
                     MediaDrm.KeyRequest request = null;
                     try {
-                        request = getKeyRequest(session, data, mime);
+                        request = getKeyRequest(sessionId, data, mime);
                     } catch (android.media.NotProvisionedException e) {
                         Log.e(TAG, "Device not provisioned", e);
                         startProvisioning();
                         return;
                     }
                     if (request != null) {
                         onSessionMessage(sessionId, request);
                     } else {
-                        onSessionError(sessionId);
+                        onLegacySessionError(sessionId,
+                                "MediaDrm EVENT_KEY_REQUIRED: Failed to generate request.");
+                        onSessionKeysChange(sessionId, false, KEY_STATUS_INTERNAL_ERROR);
                     }
                     break;
                 case MediaDrm.EVENT_KEY_EXPIRED:
                     Log.d(TAG, "MediaDrm.EVENT_KEY_EXPIRED");
-                    onSessionError(sessionId);
+                    onLegacySessionError(sessionId, "MediaDrm EVENT_KEY_EXPIRED.");
+                    onSessionKeysChange(sessionId, false, KEY_STATUS_EXPIRED);
                     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;
             }
         }
@@ skipping 59 matching lines @@
         ByteBuffer uuidBuffer = ByteBuffer.allocateDirect(16);
         // MSB (byte) should be positioned at the first element.
         uuidBuffer.order(ByteOrder.BIG_ENDIAN);
         uuidBuffer.putLong(uuid.getMostSignificantBits());
         uuidBuffer.putLong(uuid.getLeastSignificantBits());
         nativeAddKeySystemUuidMapping(keySystem, uuidBuffer);
     }
 
     private native void nativeOnMediaCryptoReady(long nativeMediaDrmBridge);
 
-    private native void nativeOnSessionCreated(long nativeMediaDrmBridge, int sessionId,
-                                               String webSessionId);
+    private native void nativeOnPromiseResolved(long nativeMediaDrmBridge, long promiseId);
+    private native void nativeOnPromiseResolvedWithSession(
+            long nativeMediaDrmBridge, long promiseId, byte[] sessionId);
+    private native void nativeOnPromiseRejected(
+            long nativeMediaDrmBridge, long promiseId, String errorMessage);
 
-    private native void nativeOnSessionMessage(long nativeMediaDrmBridge, int sessionId,
-                                               byte[] message, String destinationUrl);
-
-    private native void nativeOnSessionReady(long nativeMediaDrmBridge, int sessionId);
-
-    private native void nativeOnSessionClosed(long nativeMediaDrmBridge, int sessionId);
-
-    private native void nativeOnSessionError(long nativeMediaDrmBridge, int sessionId);
+    private native void nativeOnSessionMessage(
+            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);
 
     private static native void nativeAddKeySystemUuidMapping(String keySystem, ByteBuffer uuid);
 }