Update MediaKeys interface for EME

content/renderer/media/webcontentdecryptionmodulesession_impl.cc

 // 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.
 
 #include "content/renderer/media/webcontentdecryptionmodulesession_impl.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/renderer/media/cdm_session_adapter.h"
 #include "media/base/cdm_promise.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 
 namespace content {
 
 const char kCreateSessionUMAName[] = "CreateSession";
 
 // For backwards compatibility with blink not using
 // WebContentDecryptionModuleResult, reserve an index for |outstanding_results_|
 // that will not be used when adding a WebContentDecryptionModuleResult.
 // TODO(jrummell): Remove once blink always uses
 // WebContentDecryptionModuleResult.
 const uint32 kReservedIndex = 0;
 
-static blink::WebContentDecryptionModuleException ConvertException(
-    media::MediaKeys::Exception exception_code) {
-  switch (exception_code) {
-    case media::MediaKeys::NOT_SUPPORTED_ERROR:
-      return blink::WebContentDecryptionModuleExceptionNotSupportedError;
-    case media::MediaKeys::INVALID_STATE_ERROR:
-      return blink::WebContentDecryptionModuleExceptionInvalidStateError;
-    case media::MediaKeys::INVALID_ACCESS_ERROR:
-      return blink::WebContentDecryptionModuleExceptionInvalidAccessError;
-    case media::MediaKeys::QUOTA_EXCEEDED_ERROR:
-      return blink::WebContentDecryptionModuleExceptionQuotaExceededError;
-    case media::MediaKeys::UNKNOWN_ERROR:
-      return blink::WebContentDecryptionModuleExceptionUnknownError;
-    case media::MediaKeys::CLIENT_ERROR:
-      return blink::WebContentDecryptionModuleExceptionClientError;
-    case media::MediaKeys::OUTPUT_ERROR:
-      return blink::WebContentDecryptionModuleExceptionOutputError;
-    default:
-      NOTREACHED();
-      return blink::WebContentDecryptionModuleExceptionUnknownError;
-  }
-}
-
 WebContentDecryptionModuleSessionImpl::WebContentDecryptionModuleSessionImpl(
     const scoped_refptr<CdmSessionAdapter>& adapter)
     : adapter_(adapter),
       is_closed_(false),
-      next_available_result_index_(1),
       weak_ptr_factory_(this) {
 }
 
 WebContentDecryptionModuleSessionImpl::
     ~WebContentDecryptionModuleSessionImpl() {
   if (!web_session_id_.empty())
-    adapter_->RemoveSession(web_session_id_);
-
-  // Release any WebContentDecryptionModuleResult objects that are left. Their
-  // index will have been passed down via a CdmPromise, but it uses a WeakPtr.
-  DLOG_IF(WARNING, outstanding_results_.size() > 0)
-      << "Clearing " << outstanding_results_.size() << " results";
-  for (ResultMap::iterator it = outstanding_results_.begin();
-       it != outstanding_results_.end();
-       ++it) {
-    it->second.completeWithError(
-        blink::WebContentDecryptionModuleExceptionInvalidStateError,
-        0,
-        "Outstanding request being cancelled.");
-  }
-  outstanding_results_.clear();
+    adapter_->UnregisterSession(web_session_id_);
 }
 
 void WebContentDecryptionModuleSessionImpl::setClientInterface(Client* client) {
   client_ = client;
 }
 
 blink::WebString WebContentDecryptionModuleSessionImpl::sessionId() const {
   return blink::WebString::fromUTF8(web_session_id_);
 }
 
@@ skipping 44 matching lines @@
   adapter_->UpdateSession(
       web_session_id_, response, response_length, promise.Pass());
 }
 
 void WebContentDecryptionModuleSessionImpl::release() {
   scoped_ptr<media::SimpleCdmPromise> promise(new media::SimpleCdmPromise(
       base::Bind(&WebContentDecryptionModuleSessionImpl::OnSessionClosed,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&WebContentDecryptionModuleSessionImpl::OnSessionError,
                  weak_ptr_factory_.GetWeakPtr())));
-  adapter_->ReleaseSession(web_session_id_, promise.Pass());
+  adapter_->RemoveSession(web_session_id_, promise.Pass());

[ddorwin, 2014/09/12 21:46:29]

CloseSession() is probably more appropriate, though I don't know what the Blink
conversion is.

[jrummell, 2014/09/15 18:22:39]

Blink doesn't call this. So it doesn't matter. Changed to close.

 }
 
 void WebContentDecryptionModuleSessionImpl::initializeNewSession(
     const blink::WebString& init_data_type,
     const uint8* init_data,
     size_t init_data_length,
     const blink::WebString& session_type,
     blink::WebContentDecryptionModuleResult result) {
-  uint32 result_index = AddResult(result);
+  uint32 result_index = outstanding_results_.AddResult(result);
 
   // TODO(ddorwin): Guard against this in supported types check and remove this.
   // Chromium only supports ASCII MIME types.
   if (!base::IsStringASCII(init_data_type)) {
     NOTREACHED();
     SessionError(result_index,

[ddorwin, 2014/09/11 23:31:11]

This is the first instance of the one with "On". IS this supposed to be
RejectPromise too?

[ddorwin, 2014/09/12 21:46:29]

OnPromiseRejected

[jrummell, 2014/09/15 18:22:40]

Done.

[jrummell, 2014/09/15 18:22:40]

Done.

                  media::MediaKeys::NOT_SUPPORTED_ERROR,
                  0,
                  "The initialization data type " + init_data_type.utf8() +
                      " is not supported by the key system.");
     return;
   }
 
   std::string init_data_type_as_ascii = base::UTF16ToASCII(init_data_type);
   DLOG_IF(WARNING, init_data_type_as_ascii.find('/') != std::string::npos)
       << "init_data_type '" << init_data_type_as_ascii
@@ skipping 13 matching lines @@
                                  init_data_length,
                                  media::MediaKeys::TEMPORARY_SESSION,
                                  promise.Pass());
 }
 
 void WebContentDecryptionModuleSessionImpl::update(
     const uint8* response,
     size_t response_length,
     blink::WebContentDecryptionModuleResult result) {
   DCHECK(response);
-  uint32 result_index = AddResult(result);
+  uint32 result_index = outstanding_results_.AddResult(result);
   scoped_ptr<media::SimpleCdmPromise> promise(new media::SimpleCdmPromise(
       base::Bind(
           &WebContentDecryptionModuleSessionImpl::SessionUpdatedOrReleased,
           weak_ptr_factory_.GetWeakPtr(),
           result_index),
       base::Bind(&WebContentDecryptionModuleSessionImpl::SessionError,
                  weak_ptr_factory_.GetWeakPtr(),
                  result_index)));
   adapter_->UpdateSession(
       web_session_id_, response, response_length, promise.Pass());
 }
 
+void WebContentDecryptionModuleSessionImpl::close(
+    blink::WebContentDecryptionModuleResult result) {
+  uint32 result_index = outstanding_results_.AddResult(result);

[ddorwin, 2014/09/12 21:46:30]

This is a lot of boilerplate code. It'd be nice to clean up at some point.
For example, what if the Result Helper returned a Promise in exchange for the
result?

[jrummell, 2014/09/15 18:22:39]

Would work well for most of these calls. However, OnSessionInitialized() would
be a problem since we need to register this class with cdm_adapter once we know
the session_id.

+  scoped_ptr<media::SimpleCdmPromise> promise(new media::SimpleCdmPromise(

[ddorwin, 2014/09/12 21:46:29]

Related to above, can we eliminate outstanding_results_ by storing a reference
to/copy of blink::WebContentDecryptionModuleResult in CdmSession? The rest of
Chromium wouldn't need to know about this type.

Since we have an object on both sides, I'm not sure why we need to switch to an
ID. We use IDs when there are no objects on one side (Pepper, media_keys.h).

[jrummell, 2014/09/15 18:22:40]

(I assume you mean CdmPromise.) Have a separate CL out to allow for easier
overloading of the CdmPromise classes. Will have to update this after that
lands. Moved most of this code into webcontentdecryptionmoduleresult_helper.cc
to make this change isolated.

[ddorwin, 2014/09/17 23:54:33]

Okay, I think we'll need to wait for that before completing this review. This is
already a big improvement, though.

+      base::Bind(
+          &WebContentDecryptionModuleSessionImpl::SessionUpdatedOrReleased,
+          weak_ptr_factory_.GetWeakPtr(),
+          result_index),
+      base::Bind(&WebContentDecryptionModuleSessionImpl::SessionError,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 result_index)));
+  adapter_->CloseSession(web_session_id_, promise.Pass());
+}
+
+void WebContentDecryptionModuleSessionImpl::remove(
+    blink::WebContentDecryptionModuleResult result) {
+  uint32 result_index = outstanding_results_.AddResult(result);
+  scoped_ptr<media::SimpleCdmPromise> promise(new media::SimpleCdmPromise(
+      base::Bind(
+          &WebContentDecryptionModuleSessionImpl::SessionUpdatedOrReleased,
+          weak_ptr_factory_.GetWeakPtr(),
+          result_index),
+      base::Bind(&WebContentDecryptionModuleSessionImpl::SessionError,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 result_index)));
+  adapter_->RemoveSession(web_session_id_, promise.Pass());
+}
+
+void WebContentDecryptionModuleSessionImpl::getUsableKeyIds(
+    blink::WebContentDecryptionModuleResult result) {
+  uint32 result_index = outstanding_results_.AddResult(result);
+  scoped_ptr<media::KeyIdsPromise> promise(new media::KeyIdsPromise(
+      base::Bind(&WebContentDecryptionModuleSessionImpl::KeyIdsAvailable,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 result_index),
+      base::Bind(&WebContentDecryptionModuleSessionImpl::SessionError,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 result_index)));
+  adapter_->GetUsableKeyIds(web_session_id_, promise.Pass());
+}
+
 void WebContentDecryptionModuleSessionImpl::release(
     blink::WebContentDecryptionModuleResult result) {
-  uint32 result_index = AddResult(result);
+  uint32 result_index = outstanding_results_.AddResult(result);
   scoped_ptr<media::SimpleCdmPromise> promise(new media::SimpleCdmPromise(
       base::Bind(
           &WebContentDecryptionModuleSessionImpl::SessionUpdatedOrReleased,
           weak_ptr_factory_.GetWeakPtr(),
           result_index),
       base::Bind(&WebContentDecryptionModuleSessionImpl::SessionError,
                  weak_ptr_factory_.GetWeakPtr(),
                  result_index)));
-  adapter_->ReleaseSession(web_session_id_, promise.Pass());
+  adapter_->RemoveSession(web_session_id_, promise.Pass());

[ddorwin, 2014/09/12 21:46:30]

ditto

[jrummell, 2014/09/15 18:22:40]

This one is called. Changed to close().

 }
 
 void WebContentDecryptionModuleSessionImpl::OnSessionMessage(
     const std::vector<uint8>& message,
     const GURL& destination_url) {
   DCHECK(client_) << "Client not set before message event";
   client_->message(
       message.empty() ? NULL : &message[0], message.size(), destination_url);
 }
 
+void WebContentDecryptionModuleSessionImpl::OnSessionKeysChange(
+    bool has_additional_usable_key) {
+  // TODO(jrummell): Update this once Blink client supports this.
+}
+
+void WebContentDecryptionModuleSessionImpl::OnSessionExpirationChange(
+    double new_expiry_time) {
+  // TODO(jrummell): Update this once Blink client supports this.
+}
+
 void WebContentDecryptionModuleSessionImpl::OnSessionReady() {
   client_->ready();
 }
 
 void WebContentDecryptionModuleSessionImpl::OnSessionClosed() {
   if (!is_closed_) {
     is_closed_ = true;
     client_->close();
   }
 }
@@ skipping 10 matching lines @@
       client_->error(Client::MediaKeyErrorCodeClient, system_code);
       break;
     default:
       // This will include all other CDM4 errors and any error generated
       // by CDM5 or later.
       client_->error(Client::MediaKeyErrorCodeUnknown, system_code);
       break;
   }
 }
 
 void WebContentDecryptionModuleSessionImpl::SessionCreated(

[ddorwin, 2014/09/12 21:46:29]

This will need to be renamed. It's OnSessionInitialized or something.

[jrummell, 2014/09/15 18:22:40]

Done.

     uint32 result_index,
     const std::string& web_session_id) {
   blink::WebContentDecryptionModuleResult::SessionStatus status;
 
   // CDM will return NULL if the session to be loaded can't be found.
   if (web_session_id.empty()) {
     status = blink::WebContentDecryptionModuleResult::SessionNotFound;

[ddorwin, 2014/09/12 21:46:30]

We should know that we called load() and check that here.
!web_session_id_.empty() ???
  ^ If so, this and line 276 can be collapsed into a single check at 272.

[jrummell, 2014/09/15 18:22:40]

load() hasn't been implemented here yet -- coming soon.

   } else {
     DCHECK(web_session_id_.empty())
         << "Session ID may not be changed once set.";
     web_session_id_ = web_session_id;
     status =
         adapter_->RegisterSession(web_session_id_,
                                   weak_ptr_factory_.GetWeakPtr())
             ? blink::WebContentDecryptionModuleResult::NewSession
             : blink::WebContentDecryptionModuleResult::SessionAlreadyExists;
   }
 
-  ResultMap::iterator it = outstanding_results_.find(result_index);
-  if (it != outstanding_results_.end()) {
-    blink::WebContentDecryptionModuleResult& result = it->second;
-    result.completeWithSession(status);
-    outstanding_results_.erase(result_index);
-  }
+  outstanding_results_.CompleteWithSession(result_index, status);
 }
 
 void WebContentDecryptionModuleSessionImpl::SessionUpdatedOrReleased(

[ddorwin, 2014/09/12 21:46:30]

This function needs a new name. OnPromiseResolved?

[jrummell, 2014/09/15 18:22:39]

Done.

     uint32 result_index) {
-  ResultMap::iterator it = outstanding_results_.find(result_index);
-  DCHECK(it != outstanding_results_.end());
-  blink::WebContentDecryptionModuleResult& result = it->second;
-  result.complete();
-  outstanding_results_.erase(it);
+  outstanding_results_.Complete(result_index);
+}
+
+void WebContentDecryptionModuleSessionImpl::KeyIdsAvailable(
+    uint32 result_index,
+    const media::KeyIdsVector& key_ids) {
+  outstanding_results_.CompleteWithKeyIds(result_index, key_ids);
 }
 
 void WebContentDecryptionModuleSessionImpl::SessionError(
     uint32 result_index,
     media::MediaKeys::Exception exception_code,
     uint32 system_code,
     const std::string& error_message) {
-  ResultMap::iterator it = outstanding_results_.find(result_index);
-  DCHECK(it != outstanding_results_.end());
-  blink::WebContentDecryptionModuleResult& result = it->second;
-  result.completeWithError(ConvertException(exception_code),
-                           system_code,
-                           blink::WebString::fromUTF8(error_message));
-  outstanding_results_.erase(it);
-}
-
-uint32 WebContentDecryptionModuleSessionImpl::AddResult(
-    blink::WebContentDecryptionModuleResult result) {
-  uint32 result_index = next_available_result_index_++;
-  DCHECK(result_index != kReservedIndex);
-  outstanding_results_.insert(std::make_pair(result_index, result));
-  return result_index;
+  outstanding_results_.CompleteWithError(
+      result_index, exception_code, system_code, error_message);
 }
 
 }  // namespace content