Update MediaKeySession to keep related code blocks together

third_party/WebKit/Source/modules/encryptedmedia/MediaKeySession.cpp

 /*
  * Copyright (C) 2013 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 134 matching lines @@
 }
 
 // A class holding a pending action.
 class MediaKeySession::PendingAction
     : public GarbageCollectedFinalized<MediaKeySession::PendingAction> {
  public:
   enum Type { GenerateRequest, Load, Update, Close, Remove };
 
   Type getType() const { return m_type; }
 
-  const Persistent<ContentDecryptionModuleResult> result() const {
-    return m_result;
-  }
+  ContentDecryptionModuleResult* result() const { return m_result; }
 
   DOMArrayBuffer* data() const {
     DCHECK(m_type == GenerateRequest || m_type == Update);
     return m_data;
   }
 
   WebEncryptedMediaInitDataType initDataType() const {
     DCHECK_EQ(GenerateRequest, m_type);
     return m_initDataType;
   }
@@ skipping 339 matching lines @@
       DOMArrayBuffer::create(initData.data(), initData.byteLength());
 
   // 8. Let session type be this object's session type.
   //    (Done in constructor.)
 
   // 9. Let promise be a new promise.
   NewSessionResultPromise* result =
       new NewSessionResultPromise(scriptState, this);
   ScriptPromise promise = result->promise();
 
-  // 10. Run the following steps asynchronously (documented in
-  //     actionTimerFired())
+  // 10. Run the following steps asynchronously (done in generateRequestTask())
   m_pendingActions.append(PendingAction::CreatePendingGenerateRequest(
       result, initDataType, initDataBuffer));
   DCHECK(!m_actionTimer.isActive());
   m_actionTimer.startOneShot(0, BLINK_FROM_HERE);
 
   // 11. Return promise.
   return promise;
 }
 
+void MediaKeySession::generateRequestTask(
+    ContentDecryptionModuleResult* result,
+    WebEncryptedMediaInitDataType initDataType,
+    DOMArrayBuffer* initDataBuffer) {
+  // NOTE: Continue step 10 of MediaKeySession::generateRequest().
+  DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << __func__ << "(" << this << ")";
+
+  // initializeNewSession() in Chromium will execute steps 10.1 to 10.9.
+  m_session->initializeNewSession(
+      initDataType, static_cast<unsigned char*>(initDataBuffer->data()),
+      initDataBuffer->byteLength(), m_sessionType, result->result());
+
+  // Remaining steps (10.10) executed in finishGenerateRequest(),
+  // called when |result| is resolved.
+}
+
+void MediaKeySession::finishGenerateRequest() {
+  // NOTE: Continue step 10.10 of MediaKeySession::generateRequest().
+  DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << __func__ << "(" << this << ")";
+
+  // 10.10.1 If any of the preceding steps failed, reject promise with a
+  //         new DOMException whose name is the appropriate error name.
+  //         (Done by CDM calling result.completeWithError() as appropriate.)
+  // 10.10.2 Set the sessionId attribute to session id.
+  DCHECK(!sessionId().isEmpty());
+
+  // 10.10.3 Let this object's callable be true.
+  m_isCallable = true;
+
+  // 10.10.4 Run the Queue a "message" Event algorithm on the session,
+  //         providing message type and message.
+  //         (Done by the CDM.)
+  // 10.10.5 Resolve promise.
+  //         (Done by NewSessionResultPromise.)
+}
+
 ScriptPromise MediaKeySession::load(ScriptState* scriptState,
                                     const String& sessionId) {
   DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << __func__ << "(" << this << ") "
                                      << sessionId;
 
   // From https://w3c.github.io/encrypted-media/#load:
   // Loads the data stored for the specified session into this object. When
   // this method is invoked, the user agent must run the following steps:
 
   // 1. If this object is closed, return a promise rejected with an
@@ skipping 29 matching lines @@
   }
 
   // 6. Let origin be the origin of this object's Document.
   //    (Available as getExecutionContext()->getSecurityOrigin() anytime.)
 
   // 7. Let promise be a new promise.
   LoadSessionResultPromise* result =
       new LoadSessionResultPromise(scriptState, this);
   ScriptPromise promise = result->promise();
 
-  // 8. Run the following steps asynchronously (documented in
-  //    actionTimerFired())
+  // 8. Run the following steps asynchronously (done in loadTask())
   m_pendingActions.append(
       PendingAction::CreatePendingLoadRequest(result, sessionId));
   DCHECK(!m_actionTimer.isActive());
   m_actionTimer.startOneShot(0, BLINK_FROM_HERE);
 
   // 9. Return promise.
   return promise;
 }
 
+void MediaKeySession::loadTask(ContentDecryptionModuleResult* result,
+                               const String& sessionId) {
+  // NOTE: Continue step 8 of MediaKeySession::load().
+  DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << __func__ << "(" << this << ")";
+
+  // 8.1 Let sanitized session ID be a validated and/or sanitized
+  //     version of sessionId. The user agent should thoroughly
+  //     validate the sessionId value before passing it to the CDM.
+  //     At a minimum, this should include checking that the length
+  //     and value (e.g. alphanumeric) are reasonable.
+  // 8.2 If the preceding step failed, or if sanitized session ID
+  //     is empty, reject promise with a newly created TypeError.
+  if (!isValidSessionId(sessionId)) {
+    result->completeWithError(WebContentDecryptionModuleExceptionTypeError, 0,
+                              "Invalid sessionId");
+    return;
+  }
+
+  // 8.3 If there is an unclosed session in the object's Document
+  //     whose sessionId attribute is sanitized session ID, reject
+  //     promise with a new DOMException whose name is
+  //     QuotaExceededError. In other words, do not create a session
+  //     if a non-closed session, regardless of type, already exists
+  //     for this sanitized session ID in this browsing context.
+  //     (Done in the CDM.)
+
+  // 8.4 Let expiration time be NaN.
+  //     (Done in the constructor.)
+  DCHECK(std::isnan(m_expiration));
+
+  // load() in Chromium will execute steps 8.5 through 8.8.
+  m_session->load(sessionId, result->result());
+
+  // Remaining step (8.9) executed in finishLoad(), called when |result|
+  // is resolved.
+}
+
+void MediaKeySession::finishLoad() {
+  // NOTE: Continue step 8.9 of MediaKeySession::load().
+  DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << __func__ << "(" << this << ")";
+
+  // 8.9.1 If any of the preceding steps failed, reject promise with a new
+  //       DOMException whose name is the appropriate error name.
+  //       (Done by CDM calling result.completeWithError() as appropriate.)
+
+  // 8.9.2 Set the sessionId attribute to sanitized session ID.
+  DCHECK(!sessionId().isEmpty());
+
+  // 8.9.3 Let this object's callable be true.
+  m_isCallable = true;
+
+  // 8.9.4 If the loaded session contains information about any keys (there
+  //       are known keys), run the update key statuses algorithm on the
+  //       session, providing each key's key ID along with the appropriate
+  //       MediaKeyStatus. Should additional processing be necessary to
+  //       determine with certainty the status of a key, use the non-"usable"
+  //       MediaKeyStatus value that corresponds to the reason for the
+  //       additional processing. Once the additional processing for one or
+  //       more keys has completed, run the update key statuses algorithm
+  //       again if any of the statuses has changed.
+  //       (Done by the CDM.)
+
+  // 8.9.5 Run the Update Expiration algorithm on the session,
+  //       providing expiration time.
+  //       (Done by the CDM.)
+
+  // 8.9.6 If message is not null, run the queue a "message" event algorithm
+  //       on the session, providing message type and message.
+  //       (Done by the CDM.)
+
+  // 8.9.7 Resolve promise with true.
+  //       (Done by LoadSessionResultPromise.)
+}
+
 ScriptPromise MediaKeySession::update(ScriptState* scriptState,
                                       const DOMArrayPiece& response) {
   DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << __func__ << "(" << this << ")";
 
   // From https://w3c.github.io/encrypted-media/#update:
   // Provides messages, including licenses, to the CDM. When this method is
   // invoked, the user agent must run the following steps:
 
   // 1. If this object is closed, return a promise rejected with an
   //    InvalidStateError.
@@ skipping 15 matching lines @@
   }
 
   // 4. Let response copy be a copy of the contents of the response parameter.
   DOMArrayBuffer* responseCopy =
       DOMArrayBuffer::create(response.data(), response.byteLength());
 
   // 5. Let promise be a new promise.
   SimpleResultPromise* result = new SimpleResultPromise(scriptState, this);
   ScriptPromise promise = result->promise();
 
-  // 6. Run the following steps asynchronously (documented in
-  //    actionTimerFired())
+  // 6. Run the following steps asynchronously (done in updateTask())
   m_pendingActions.append(
       PendingAction::CreatePendingUpdate(result, responseCopy));
   if (!m_actionTimer.isActive())
     m_actionTimer.startOneShot(0, BLINK_FROM_HERE);
 
   // 7. Return promise.
   return promise;
 }
 
+void MediaKeySession::updateTask(ContentDecryptionModuleResult* result,
+                                 DOMArrayBuffer* sanitizedResponse) {
+  // NOTE: Continue step 6 of MediaKeySession::update().
+  DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << __func__ << "(" << this << ")";
+
+  // update() in Chromium will execute steps 6.1 through 6.8.
+  m_session->update(static_cast<unsigned char*>(sanitizedResponse->data()),
+                    sanitizedResponse->byteLength(), result->result());
+
+  // Last step (6.8.2 Resolve promise) will be done when |result| is resolved.
+}
+
 ScriptPromise MediaKeySession::close(ScriptState* scriptState) {
   DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << __func__ << "(" << this << ")";
 
   // From https://w3c.github.io/encrypted-media/#close:
   // Indicates that the application no longer needs the session and the CDM
-  // should release any resources associated with this object and close it.
+  // should release any resources associated with the session and close it.
+  // Persisted data should not be released or cleared.
   // When this method is invoked, the user agent must run the following steps:
 
-  // 1. If this object's callable value is false, return a promise rejected
-  //    with a new DOMException whose name is "InvalidStateError".
+  // 1. Let session be the associated MediaKeySession object.
+  // 2. If session is closed, return a resolved promise.
+  if (m_isClosed)
+    return ScriptPromise::cast(scriptState, ScriptValue());
+
+  // 3. If session's callable value is false, return a promise rejected with
+  //    an InvalidStateError.
   if (!m_isCallable)
     return CreateRejectedPromiseNotCallable(scriptState);
 
-  // 2. If the Session Close algorithm has been run on this object,
-  //    return a resolved promise.
-  if (m_isClosed)
-    return ScriptPromise::cast(scriptState, ScriptValue());
-
-  // 3. Let promise be a new promise.
+  // 4. Let promise be a new promise.
   SimpleResultPromise* result = new SimpleResultPromise(scriptState, this);
   ScriptPromise promise = result->promise();
 
-  // 4. Run the following steps asynchronously (documented in
-  //    actionTimerFired()).
+  // 4. Run the following steps in parallel (done in closeTask()).
   m_pendingActions.append(PendingAction::CreatePendingClose(result));
   if (!m_actionTimer.isActive())
     m_actionTimer.startOneShot(0, BLINK_FROM_HERE);
 
   // 5. Return promise.
   return promise;
 }
 
+void MediaKeySession::closeTask(ContentDecryptionModuleResult* result) {
+  // NOTE: Continue step 4 of MediaKeySession::close().
+  DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << __func__ << "(" << this << ")";
+
+  // close() in Chromium will execute steps 5.1 through 5.3.
+  m_session->close(result->result());
+
+  // Last step (5.3.2 Resolve promise) will be done when |result| is resolved.
+}
+
 ScriptPromise MediaKeySession::remove(ScriptState* scriptState) {
   DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << __func__ << "(" << this << ")";
 
   // From https://w3c.github.io/encrypted-media/#remove:
   // Removes stored session data associated with this object. When this
   // method is invoked, the user agent must run the following steps:
 
   // 1. If this object is closed, return a promise rejected with an
   //    InvalidStateError.
   if (m_isClosed)
@@ skipping 11 matching lines @@
     return ScriptPromise::reject(
         scriptState,
         V8ThrowException::createTypeError(
             scriptState->isolate(), "The session type is not persistent."));
   }
 
   // 4. Let promise be a new promise.
   SimpleResultPromise* result = new SimpleResultPromise(scriptState, this);
   ScriptPromise promise = result->promise();
 
-  // 5. Run the following steps asynchronously (documented in
-  //    actionTimerFired()).
+  // 5. Run the following steps asynchronously (done in removeTask()).
   m_pendingActions.append(PendingAction::CreatePendingRemove(result));
   if (!m_actionTimer.isActive())
     m_actionTimer.startOneShot(0, BLINK_FROM_HERE);
 
   // 6. Return promise.
   return promise;
 }
 
+void MediaKeySession::removeTask(ContentDecryptionModuleResult* result) {
+  // NOTE: Continue step 5 of MediaKeySession::remove().
+  DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << __func__ << "(" << this << ")";
+
+  // remove() in Chromium will execute steps 5.1 through 5.3.
+  m_session->remove(result->result());
+
+  // Last step (5.3.6 Resolve promise) will be done when |result| is resolved.
+}
+
 void MediaKeySession::actionTimerFired(TimerBase*) {
   DCHECK(m_pendingActions.size());
 
   // Resolving promises now run synchronously and may result in additional
   // actions getting added to the queue. As a result, swap the queue to
   // a local copy to avoid problems if this happens.
   HeapDeque<Member<PendingAction>> pendingActions;
   pendingActions.swap(m_pendingActions);
 
   while (!pendingActions.isEmpty()) {
     PendingAction* action = pendingActions.takeFirst();
 
     switch (action->getType()) {
       case PendingAction::GenerateRequest:
-        // NOTE: Continue step 10 of MediaKeySession::generateRequest().
-        DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << __func__ << "(" << this
-                                           << ") GenerateRequest";
-
-        // initializeNewSession() in Chromium will execute steps 10.1 to 10.9.
-        m_session->initializeNewSession(
-            action->initDataType(),
-            static_cast<unsigned char*>(action->data()->data()),
-            action->data()->byteLength(), m_sessionType,
-            action->result()->result());
-
-        // Remaining steps (from 10.10) executed in finishGenerateRequest(),
-        // called when |result| is resolved.
+        generateRequestTask(action->result(), action->initDataType(),
+                            action->data());
         break;
 
       case PendingAction::Load:
-        // NOTE: Continue step 8 of MediaKeySession::load().
-        DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << __func__ << "(" << this
-                                           << ") Load";
-
-        // 8.1 Let sanitized session ID be a validated and/or sanitized
-        //     version of sessionId. The user agent should thoroughly
-        //     validate the sessionId value before passing it to the CDM.
-        //     At a minimum, this should include checking that the length
-        //     and value (e.g. alphanumeric) are reasonable.
-        // 8.2 If the preceding step failed, or if sanitized session ID
-        //     is empty, reject promise with a newly created TypeError.
-        if (!isValidSessionId(action->sessionId())) {
-          action->result()->completeWithError(
-              WebContentDecryptionModuleExceptionTypeError, 0,
-              "Invalid sessionId");
-          return;
-        }
-
-        // 8.3 If there is an unclosed session in the object's Document
-        //     whose sessionId attribute is sanitized session ID, reject
-        //     promise with a new DOMException whose name is
-        //     QuotaExceededError. In other words, do not create a session
-        //     if a non-closed session, regardless of type, already exists
-        //     for this sanitized session ID in this browsing context.
-        //     (Done in the CDM.)
-
-        // 8.4 Let expiration time be NaN.
-        //     (Done in the constructor.)
-        DCHECK(std::isnan(m_expiration));
-
-        // load() in Chromium will execute steps 8.5 through 8.8.
-        m_session->load(action->sessionId(), action->result()->result());
-
-        // Remaining steps (from 8.9) executed in finishLoad(), called
-        // when |result| is resolved.
+        loadTask(action->result(), action->sessionId());
         break;
 
       case PendingAction::Update:
-        // NOTE: Continue step 5 of MediaKeySession::update().
-        DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << __func__ << "(" << this
-                                           << ") Update";
-
-        // update() in Chromium will execute steps 5.1 through 5.8.
-        m_session->update(static_cast<unsigned char*>(action->data()->data()),
-                          action->data()->byteLength(),
-                          action->result()->result());
-
-        // Last step (5.9 Resolve promise) will be done when |result| is
-        // resolved.
+        updateTask(action->result(), action->data());
         break;
 
       case PendingAction::Close:
-        // NOTE: Continue step 4 of MediaKeySession::close().
-        DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << __func__ << "(" << this
-                                           << ") Close";
-
-        // close() in Chromium will execute steps 4.1 through 4.2.
-        m_session->close(action->result()->result());
-
-        // Last step (4.3 Resolve promise) will be done when |result| is
-        // resolved.
+        closeTask(action->result());
         break;
 
       case PendingAction::Remove:
-        // NOTE: Continue step 5 of MediaKeySession::remove().
-        DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << __func__ << "(" << this
-                                           << ") Remove";
-
-        // remove() in Chromium will execute steps 5.1 through 5.3.
-        m_session->remove(action->result()->result());
-
-        // Last step (5.3.3 Resolve promise) will be done when |result| is
-        // resolved.
+        removeTask(action->result());
         break;
     }
   }
 }
 
-void MediaKeySession::finishGenerateRequest() {
-  // 9.8 If any of the preceding steps failed, reject promise with a
-  //     new DOMException whose name is the appropriate error name.
-  //     (Done by CDM calling result.completeWithError() as appropriate.)
-
-  // 9.9 Set the sessionId attribute to session id.
-  DCHECK(!sessionId().isEmpty());
-
-  // 9.10 Let this object's callable be true.
-  m_isCallable = true;
-
-  // 9.11 Run the queue a "message" event algorithm on the session,
-  //      providing "license-request" and message.
-  //     (Done by the CDM.)
-
-  // 9.12 Resolve promise.
-  //      (Done by NewSessionResultPromise.)
-}
-
-void MediaKeySession::finishLoad() {
-  // 8.9 If any of the preceding steps failed, reject promise with a new
-  //     DOMException whose name is the appropriate error name.
-  //     (Done by CDM calling result.completeWithError() as appropriate.)
-
-  // 8.10 Set the sessionId attribute to sanitized session ID.
-  DCHECK(!sessionId().isEmpty());
-
-  // 8.11 Let this object's callable be true.
-  m_isCallable = true;
-
-  // 8.12 If the loaded session contains information about any keys (there
-  //      are known keys), run the update key statuses algorithm on the
-  //      session, providing each key's key ID along with the appropriate
-  //      MediaKeyStatus. Should additional processing be necessary to
-  //      determine with certainty the status of a key, use the non-"usable"
-  //      MediaKeyStatus value that corresponds to the reason for the
-  //      additional processing. Once the additional processing for one or
-  //      more keys has completed, run the update key statuses algorithm
-  //      again if any of the statuses has changed.
-  //      (Done by the CDM.)
-
-  // 8.13 Run the Update Expiration algorithm on the session,
-  //      providing expiration time.
-  //      (Done by the CDM.)
-
-  // 8.14 If message is not null, run the queue a "message" event algorithm
-  //      on the session, providing message type and message.
-  //      (Done by the CDM.)
-
-  // 8.15 Resolve promise with true.
-  //      (Done by LoadSessionResultPromise.)
-}
-
 // Queue a task to fire a simple event named keymessage at the new object.
 void MediaKeySession::message(MessageType messageType,
                               const unsigned char* message,
                               size_t messageLength) {
   DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << __func__ << "(" << this << ")";
 
   // Verify that 'message' not fired before session initialization is complete.
   DCHECK(m_isCallable);
 
   // From https://w3c.github.io/encrypted-media/#queue-message:
@@ skipping 155 matching lines @@
   visitor->trace(m_asyncEventQueue);
   visitor->trace(m_pendingActions);
   visitor->trace(m_mediaKeys);
   visitor->trace(m_keyStatusesMap);
   visitor->trace(m_closedPromise);
   EventTargetWithInlineData::trace(visitor);
   ActiveDOMObject::trace(visitor);
 }
 
 }  // namespace blink