Add Promises for EME (Chromium side)

media/cdm/ppapi/cdm_adapter.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 "media/cdm/ppapi/cdm_adapter.h"
 
+#include "media/base/media_keys.h"
 #include "media/cdm/ppapi/cdm_file_io_impl.h"
 #include "media/cdm/ppapi/cdm_helpers.h"
 #include "media/cdm/ppapi/cdm_logging.h"
 #include "media/cdm/ppapi/supported_cdm_versions.h"
 #include "ppapi/c/ppb_console.h"
 
 #if defined(CHECK_DOCUMENT_URL)
 #include "ppapi/cpp/dev/url_util_dev.h"
 #include "ppapi/cpp/instance_handle.h"
 #endif  // defined(CHECK_DOCUMENT_URL)
@@ skipping 186 matching lines @@
     case PP_DECRYPTORSTREAMTYPE_AUDIO:
       return cdm::kStreamTypeAudio;
     case PP_DECRYPTORSTREAMTYPE_VIDEO:
       return cdm::kStreamTypeVideo;
   }
 
   PP_NOTREACHED();
   return cdm::kStreamTypeVideo;
 }
 
+cdm::SessionType PpSessionTypeToCdmSessionType(PP_SessionType session_type) {
+  switch (session_type) {
+    case PP_SESSIONTYPE_TEMPORARY:
+      return cdm::kTemporary;
+    case PP_SESSIONTYPE_PERSISTENT:
+      return cdm::kPersistent;
+    default:
+      PP_NOTREACHED();
+      return cdm::kTemporary;
+  }
+}
+
+PP_ExceptionCodeType CdmExceptionTypeToPpExceptionType(
+    cdm::MediaKeyException exception_code) {
+  switch (exception_code) {
+    case cdm::kIndexSizeError:
+      return PP_EXCEPTIONCODETYPE_INDEXSIZEERROR;
+    case cdm::kHierarchyRequestError:
+      return PP_EXCEPTIONCODETYPE_HIERARCHYREQUESTERROR;
+    case cdm::kWrongDocumentError:
+      return PP_EXCEPTIONCODETYPE_WRONGDOCUMENTERROR;
+    case cdm::kInvalidCharacterError:
+      return PP_EXCEPTIONCODETYPE_INVALIDCHARACTERERROR;
+    case cdm::kNoModificationAllowedError:
+      return PP_EXCEPTIONCODETYPE_NOMODIFICATIONALLOWEDERROR;
+    case cdm::kNotFoundError:
+      return PP_EXCEPTIONCODETYPE_NOTFOUNDERROR;
+    case cdm::kNotSupportedError:
+      return PP_EXCEPTIONCODETYPE_NOTSUPPORTEDERROR;
+    case cdm::kInvalidStateError:
+      return PP_EXCEPTIONCODETYPE_INVALIDSTATEERROR;
+    case cdm::kSyntaxError:
+      return PP_EXCEPTIONCODETYPE_SYNTAXERROR;
+    case cdm::kInvalidModificationError:
+      return PP_EXCEPTIONCODETYPE_INVALIDMODIFICATIONERROR;
+    case cdm::kNamespaceError:
+      return PP_EXCEPTIONCODETYPE_NAMESPACEERROR;
+    case cdm::kInvalidAccessError:
+      return PP_EXCEPTIONCODETYPE_INVALIDACCESSERROR;
+    case cdm::kSecurityError:
+      return PP_EXCEPTIONCODETYPE_SECURITYERROR;
+    case cdm::kNetworkError:
+      return PP_EXCEPTIONCODETYPE_NETWORKERROR;
+    case cdm::kAbortError:
+      return PP_EXCEPTIONCODETYPE_ABORTERROR;
+    case cdm::kUrlMismatchError:
+      return PP_EXCEPTIONCODETYPE_URLMISMATCHERROR;
+    case cdm::kQuotaExceededError:
+      return PP_EXCEPTIONCODETYPE_QUOTAEXCEEDEDERROR;
+    case cdm::kTimeoutError:
+      return PP_EXCEPTIONCODETYPE_TIMEOUTERROR;
+    case cdm::kInvalidNodeTypeError:
+      return PP_EXCEPTIONCODETYPE_INVALIDNODETYPEERROR;
+    case cdm::kDataCloneError:
+      return PP_EXCEPTIONCODETYPE_DATACLONEERROR;
+    case cdm::kEncodingError:
+      return PP_EXCEPTIONCODETYPE_ENCODINGERROR;
+    case cdm::kNotReadableError:
+      return PP_EXCEPTIONCODETYPE_NOTREADABLEERROR;
+    case cdm::kDataError:
+      return PP_EXCEPTIONCODETYPE_DATAERROR;
+    case cdm::kOperationError:
+      return PP_EXCEPTIONCODETYPE_OPERATIONERROR;
+    case cdm::kVersionError:
+      return PP_EXCEPTIONCODETYPE_VERSIONERROR;
+    case cdm::kMediaKeyErrorUnknownError:
+      return PP_EXCEPTIONCODETYPE_UNKNOWNERROR;
+    case cdm::kMediaKeyErrorClientError:
+      return PP_EXCEPTIONCODETYPE_CLIENTERROR;
+    case cdm::kMediaKeyErrorOutputError:
+      return PP_EXCEPTIONCODETYPE_OUTPUTERROR;
+    default:
+      NOTREACHED();
+      return PP_EXCEPTIONCODETYPE_SECURITYERROR;
+  }
+}
+
+/*
+PP_ExceptionCodeType MediaKeysExceptionTypeToPpExceptionType(

[jrummell, 2014/05/08 23:37:46]

Will remove this.

[jrummell, 2014/05/09 00:55:23]

Done.

+    media::MediaKeys::MediaKeysException exception_code) {
+  switch (exception_code) {
+    case media::MediaKeys::MEDIA_KEYS_EXCEPTION_INDEX_SIZE_ERROR:
+      return PP_EXCEPTIONCODETYPE_INDEXSIZEERROR;
+    case media::MediaKeys::MEDIA_KEYS_EXCEPTION_HIERARCHY_REQUEST_ERROR:
+      return PP_EXCEPTIONCODETYPE_HIERARCHYREQUESTERROR;
+    case media::MediaKeys::MEDIA_KEYS_EXCEPTION_WRONG_DOCUMENT_ERROR:
+      return PP_EXCEPTIONCODETYPE_WRONGDOCUMENTERROR;
+    case media::MediaKeys::MEDIA_KEYS_EXCEPTION_INVALID_CHARACTER_ERROR:
+      return PP_EXCEPTIONCODETYPE_INVALIDCHARACTERERROR;
+    case media::MediaKeys::MEDIA_KEYS_EXCEPTION_NO_MODIFICATION_ALLOWED_ERROR:
+      return PP_EXCEPTIONCODETYPE_NOMODIFICATIONALLOWEDERROR;
+    case media::MediaKeys::MEDIA_KEYS_EXCEPTION_NOT_FOUND_ERROR:
+      return PP_EXCEPTIONCODETYPE_NOTFOUNDERROR;
+    case media::MediaKeys::MEDIA_KEYS_EXCEPTION_NOT_SUPPORTED_ERROR:
+      return PP_EXCEPTIONCODETYPE_NOTSUPPORTEDERROR;
+    case media::MediaKeys::kInvalidStateError:
+      return PP_EXCEPTIONCODETYPE_INVALIDSTATEERROR;
+    case media::MediaKeys::kSyntaxError:
+      return PP_EXCEPTIONCODETYPE_SYNTAXERROR;
+    case media::MediaKeys::kInvalidModificationError:
+      return PP_EXCEPTIONCODETYPE_INVALIDMODIFICATIONERROR;
+    case media::MediaKeys::kNamespaceError:
+      return PP_EXCEPTIONCODETYPE_NAMESPACEERROR;
+    case media::MediaKeys::kInvalidAccessError:
+      return PP_EXCEPTIONCODETYPE_INVALIDACCESSERROR;
+    case media::MediaKeys::kSecurityError:
+      return PP_EXCEPTIONCODETYPE_SECURITYERROR;
+    case media::MediaKeys::kNetworkError:
+      return PP_EXCEPTIONCODETYPE_NETWORKERROR;
+    case media::MediaKeys::kAbortError:
+      return PP_EXCEPTIONCODETYPE_ABORTERROR;
+    case media::MediaKeys::kUrlMismatchError:
+      return PP_EXCEPTIONCODETYPE_URLMISMATCHERROR;
+    case media::MediaKeys::kQuotaExceededError:
+      return PP_EXCEPTIONCODETYPE_QUOTAEXCEEDEDERROR;
+    case media::MediaKeys::kTimeoutError:
+      return PP_EXCEPTIONCODETYPE_TIMEOUTERROR;
+    case media::MediaKeys::kInvalidNodeTypeError:
+      return PP_EXCEPTIONCODETYPE_INVALIDNODETYPEERROR;
+    case media::MediaKeys::kDataCloneError:
+      return PP_EXCEPTIONCODETYPE_DATACLONEERROR;
+    case media::MediaKeys::kEncodingError:
+      return PP_EXCEPTIONCODETYPE_ENCODINGERROR;
+    case media::MediaKeys::kNotReadableError:
+      return PP_EXCEPTIONCODETYPE_NOTREADABLEERROR;
+    case media::MediaKeys::kDataError:
+      return PP_EXCEPTIONCODETYPE_DATAERROR;
+    case media::MediaKeys::kOperationError:
+      return PP_EXCEPTIONCODETYPE_OPERATIONERROR;
+    case media::MediaKeys::kVersionError:
+      return PP_EXCEPTIONCODETYPE_VERSIONERROR;
+    case media::MediaKeys::kMediaKeyErrorUnknownError:
+      return PP_EXCEPTIONCODETYPE_UNKNOWNERROR;
+    case media::MediaKeys::kMediaKeyErrorClientError:
+      return PP_EXCEPTIONCODETYPE_CLIENTERROR;
+    case media::MediaKeys::kMediaKeyErrorOutputError:
+      return PP_EXCEPTIONCODETYPE_OUTPUTERROR;
+    default:
+      NOTREACHED();
+      return PP_EXCEPTIONCODETYPE_SECURITYERROR;
+  }
+}
+*/
 }  // namespace
 
 namespace media {
 
 CdmAdapter::CdmAdapter(PP_Instance instance, pp::Module* module)
     : pp::Instance(instance),
       pp::ContentDecryptor_Private(this),
 #if defined(OS_CHROMEOS)
       output_protection_(this),
       platform_verification_(this),
@@ skipping 57 matching lines @@
   }
 #endif  // defined(CHECK_DOCUMENT_URL)
 
   if (!cdm_ && !CreateCdmInstance(key_system))
     return;
 
   PP_DCHECK(cdm_);
   key_system_ = key_system;
 }
 
-void CdmAdapter::CreateSession(uint32_t session_id,
-                               const std::string& content_type,
-                               pp::VarArrayBuffer init_data) {
+void CdmAdapter::CreateSession(uint32_t promise_id,
+                               const std::string& init_data_type,
+                               pp::VarArrayBuffer init_data,
+                               PP_SessionType session_type) {
   // Initialize() doesn't report an error, so CreateSession() can be called
   // even if Initialize() failed.
   if (!cdm_) {
-    OnSessionError(session_id, cdm::kUnknownError, 0);
+    RejectPromise(promise_id,
+                  cdm::kInvalidStateError,
+                  0,
+                  "CDM has not been initialized.");
     return;
   }
 
-  cdm_->CreateSession(session_id,
-                      content_type.data(),
-                      content_type.size(),
+  cdm_->CreateSession(promise_id,
+                      init_data_type.data(),
+                      init_data_type.size(),
                       static_cast<const uint8_t*>(init_data.Map()),
-                      init_data.ByteLength());
+                      init_data.ByteLength(),
+                      PpSessionTypeToCdmSessionType(session_type));
 }
 
-void CdmAdapter::LoadSession(uint32_t session_id,
+void CdmAdapter::LoadSession(uint32_t promise_id,
                              const std::string& web_session_id) {
   // Initialize() doesn't report an error, so LoadSession() can be called
   // even if Initialize() failed.
   if (!cdm_) {
-    OnSessionError(session_id, cdm::kUnknownError, 0);
+    RejectPromise(promise_id,
+                  cdm::kInvalidStateError,
+                  0,
+                  "CDM has not been initialized.");
     return;
   }
 
-  cdm_->LoadSession(session_id, web_session_id.data(), web_session_id.size());
+  cdm_->LoadSession(promise_id, web_session_id.data(), web_session_id.size());
 }
 
-void CdmAdapter::UpdateSession(uint32_t session_id,
+void CdmAdapter::UpdateSession(uint32_t promise_id,
+                               const std::string& web_session_id,
                                pp::VarArrayBuffer response) {
   const uint8_t* response_ptr = static_cast<const uint8_t*>(response.Map());
   const uint32_t response_size = response.ByteLength();
 
+  PP_DCHECK(!web_session_id.empty());
+
   if (!response_ptr || response_size <= 0) {
-    OnSessionError(session_id, cdm::kUnknownError, 0);
+    RejectPromise(promise_id, cdm::kSyntaxError, 0, "response is empty.");
     return;
   }
-  cdm_->UpdateSession(session_id, response_ptr, response_size);
+
+  cdm_->UpdateSession(promise_id,
+                      web_session_id.data(),
+                      web_session_id.length(),
+                      response_ptr,
+                      response_size);
 }
 
-void CdmAdapter::ReleaseSession(uint32_t session_id) {
-  cdm_->ReleaseSession(session_id);
+void CdmAdapter::ReleaseSession(uint32_t promise_id,
+                                const std::string& web_session_id) {
+  cdm_->ReleaseSession(
+      promise_id, web_session_id.data(), web_session_id.length());
 }
 
 // Note: In the following decryption/decoding related functions, errors are NOT
 // reported via KeyError, but are reported via corresponding PPB calls.
 
 void CdmAdapter::Decrypt(pp::Buffer_Dev encrypted_buffer,
                          const PP_EncryptedBlockInfo& encrypted_block_info) {
   PP_DCHECK(!encrypted_buffer.is_null());
 
   // Release a buffer that the caller indicated it is finished with.
@@ skipping 180 matching lines @@
 
 void CdmAdapter::TimerExpired(int32_t result, void* context) {
   PP_DCHECK(result == PP_OK);
   cdm_->TimerExpired(context);
 }
 
 double CdmAdapter::GetCurrentWallTimeInSeconds() {
   return pp::Module::Get()->core()->GetTime();
 }
 
+// cdm::Host_5 methods
+
+void CdmAdapter::OnResolvePromise(uint32_t promise_id) {
+  PostOnMain(callback_factory_.NewCallback(
+      &CdmAdapter::SendPromiseResolvedInternal, promise_id));
+}
+
+void CdmAdapter::OnResolveNewSessionPromise(uint32_t promise_id,
+                                            const char* web_session_id,
+                                            uint32_t web_session_id_length) {
+  PostOnMain(callback_factory_.NewCallback(
+      &CdmAdapter::SendPromiseResolvedWithSessionInternal,
+      promise_id,
+      std::string(web_session_id, web_session_id_length)));
+}
+
+void CdmAdapter::OnRejectPromise(uint32_t promise_id,
+                                 cdm::MediaKeyException exception_code,
+                                 uint32_t system_code,
+                                 const char* error_message,
+                                 uint32_t error_message_length) {
+  RejectPromise(promise_id,
+                exception_code,
+                system_code,
+                std::string(error_message, error_message_length));
+}
+
+void CdmAdapter::RejectPromise(uint32_t promise_id,
+                               cdm::MediaKeyException exception_code,
+                               uint32_t system_code,
+                               const std::string& error_message) {
+  PostOnMain(callback_factory_.NewCallback(
+      &CdmAdapter::SendPromiseRejectedInternal,
+      promise_id,
+      SessionError(exception_code, system_code, error_message)));
+}
+
+void CdmAdapter::OnSessionMessage(const char* web_session_id,
+                                  uint32_t web_session_id_length,
+                                  const char* message,
+                                  uint32_t message_length,
+                                  const char* destination_url,
+                                  uint32_t destination_url_length) {
+  PostOnMain(callback_factory_.NewCallback(
+      &CdmAdapter::SendSessionMessageInternal,
+      std::string(web_session_id, web_session_id_length),
+      std::vector<uint8>(message, message + message_length),
+      std::string(destination_url, destination_url_length)));
+}
+
+void CdmAdapter::OnSessionReady(const char* web_session_id,
+                                uint32_t web_session_id_length) {
+  PostOnMain(callback_factory_.NewCallback(
+      &CdmAdapter::SendSessionReadyInternal,
+      std::string(web_session_id, web_session_id_length)));
+}
+
+void CdmAdapter::OnSessionClosed(const char* web_session_id,
+                                 uint32_t web_session_id_length) {
+  PostOnMain(callback_factory_.NewCallback(
+      &CdmAdapter::SendSessionClosedInternal,
+      std::string(web_session_id, web_session_id_length)));
+}
+
+void CdmAdapter::OnSessionError(const char* web_session_id,
+                                uint32_t web_session_id_length,
+                                cdm::MediaKeyException exception_code,
+                                uint32_t system_code,
+                                const char* error_message,
+                                uint32_t error_message_length) {
+  PostOnMain(callback_factory_.NewCallback(
+      &CdmAdapter::SendSessionErrorInternal,
+      std::string(web_session_id, web_session_id_length),
+      SessionError(exception_code,
+                   system_code,
+                   std::string(error_message, error_message_length))));
+}
+
+// cdm::Host_4 methods
+
 void CdmAdapter::OnSessionCreated(uint32_t session_id,
                                   const char* web_session_id,
                                   uint32_t web_session_id_length) {
-  PostOnMain(callback_factory_.NewCallback(
-      &CdmAdapter::SendSessionCreatedInternal,
-      session_id,
-      std::string(web_session_id, web_session_id_length)));
+  uint32_t promise_id = cdm_->LookupPromiseId(session_id);
+  cdm_->AssignWebSessionId(session_id, web_session_id, web_session_id_length);
+  OnResolveNewSessionPromise(promise_id, web_session_id, web_session_id_length);
 }
 
 void CdmAdapter::OnSessionMessage(uint32_t session_id,
                                   const char* message,
                                   uint32_t message_length,
                                   const char* destination_url,
                                   uint32_t destination_url_length) {
-  PostOnMain(callback_factory_.NewCallback(
-      &CdmAdapter::SendSessionMessageInternal,
-      session_id,
-      std::vector<uint8>(message, message + message_length),
-      std::string(destination_url, destination_url_length)));
+  std::string web_session_id = cdm_->LookupWebSessionId(session_id);
+  OnSessionMessage(web_session_id.data(),
+                   web_session_id.length(),
+                   message,
+                   message_length,
+                   destination_url,
+                   destination_url_length);
 }
 
 void CdmAdapter::OnSessionReady(uint32_t session_id) {
-  PostOnMain(callback_factory_.NewCallback(
-      &CdmAdapter::SendSessionReadyInternal, session_id));
+  uint32_t promise_id = cdm_->LookupPromiseId(session_id);
+  if (promise_id) {
+    OnResolvePromise(promise_id);
+  } else {
+    std::string web_session_id = cdm_->LookupWebSessionId(session_id);
+    OnSessionReady(web_session_id.data(), web_session_id.length());
+  }
 }
 
 void CdmAdapter::OnSessionClosed(uint32_t session_id) {
-  PostOnMain(callback_factory_.NewCallback(
-      &CdmAdapter::SendSessionClosedInternal, session_id));
+  uint32_t promise_id = cdm_->LookupPromiseId(session_id);
+  std::string web_session_id = cdm_->LookupWebSessionId(session_id);
+  cdm_->DropWebSessionId(web_session_id);
+  if (promise_id) {
+    OnResolvePromise(promise_id);
+  } else {
+    OnSessionClosed(web_session_id.data(), web_session_id.length());
+  }
 }
 
 void CdmAdapter::OnSessionError(uint32_t session_id,
                                 cdm::MediaKeyError error_code,
                                 uint32_t system_code) {
-  PostOnMain(callback_factory_.NewCallback(
-      &CdmAdapter::SendSessionErrorInternal,
-      session_id,
-      error_code,
-      system_code));
+  uint32_t promise_id = cdm_->LookupPromiseId(session_id);
+
+  // Existing cdm::MediaKeyError don't map to DOM error names. Convert them
+  // into non-standard names so that the prefixed API can extract them.
+  // TODO(jrummell): Remove this conversion and the inverse when CDM4 is gone.
+  cdm::MediaKeyException exception_code;
+  switch (error_code) {
+    case cdm::kClientError:
+      exception_code = cdm::kMediaKeyErrorClientError;
+      break;
+    case cdm::kOutputError:
+      exception_code = cdm::kMediaKeyErrorOutputError;
+      break;
+    case cdm::kUnknownError:
+    default:
+      exception_code = cdm::kMediaKeyErrorUnknownError;
+      break;
+  }
+
+  if (promise_id) {
+    RejectPromise(promise_id, exception_code, system_code, std::string());
+  } else {
+    std::string web_session_id = cdm_->LookupWebSessionId(session_id);
+    OnSessionError(web_session_id.data(),
+                   web_session_id.length(),
+                   exception_code,
+                   system_code,
+                   NULL,
+                   0);
+  }
 }
 
-void CdmAdapter::SendSessionCreatedInternal(int32_t result,
-                                            uint32_t session_id,
-                                            const std::string& web_session_id) {
+// Helpers to pass the event to Pepper.
+
+void CdmAdapter::SendPromiseResolvedInternal(int32_t result,
+                                             uint32_t promise_id) {
   PP_DCHECK(result == PP_OK);
-  pp::ContentDecryptor_Private::SessionCreated(session_id, web_session_id);
+  pp::ContentDecryptor_Private::PromiseResolved(promise_id);
 }
 
-void CdmAdapter::SendSessionMessageInternal(int32_t result,
-                                            uint32_t session_id,
-                                            const std::vector<uint8>& message,
-                                            const std::string& default_url) {
+void CdmAdapter::SendPromiseResolvedWithSessionInternal(
+    int32_t result,
+    uint32_t promise_id,
+    const std::string& web_session_id) {
+  PP_DCHECK(result == PP_OK);
+  pp::ContentDecryptor_Private::PromiseResolvedWithSession(promise_id,
+                                                           web_session_id);
+}
+
+void CdmAdapter::SendPromiseRejectedInternal(int32_t result,
+                                             uint32_t promise_id,
+                                             const SessionError& error) {
+  PP_DCHECK(result == PP_OK);
+  pp::ContentDecryptor_Private::PromiseRejected(
+      promise_id,
+      CdmExceptionTypeToPpExceptionType(error.exception_code),
+      error.system_code,
+      error.error_description);
+}
+
+void CdmAdapter::SendSessionMessageInternal(
+    int32_t result,
+    const std::string& web_session_id,
+    const std::vector<uint8>& message,
+    const std::string& destination_url) {
   PP_DCHECK(result == PP_OK);
 
   pp::VarArrayBuffer message_array_buffer(message.size());
   if (message.size() > 0) {
     memcpy(message_array_buffer.Map(), message.data(), message.size());
   }
 
   pp::ContentDecryptor_Private::SessionMessage(
-      session_id, message_array_buffer, default_url);
+      web_session_id, message_array_buffer, destination_url);
 }
 
-void CdmAdapter::SendSessionReadyInternal(int32_t result, uint32_t session_id) {
+void CdmAdapter::SendSessionReadyInternal(int32_t result,
+                                          const std::string& web_session_id) {
   PP_DCHECK(result == PP_OK);
-  pp::ContentDecryptor_Private::SessionReady(session_id);
+  pp::ContentDecryptor_Private::SessionReady(web_session_id);
 }
 
 void CdmAdapter::SendSessionClosedInternal(int32_t result,
-                                           uint32_t session_id) {
+                                           const std::string& web_session_id) {
   PP_DCHECK(result == PP_OK);
-  pp::ContentDecryptor_Private::SessionClosed(session_id);
+  pp::ContentDecryptor_Private::SessionClosed(web_session_id);
 }
 
 void CdmAdapter::SendSessionErrorInternal(int32_t result,
-                                          uint32_t session_id,
-                                          cdm::MediaKeyError error_code,
-                                          uint32_t system_code) {
+                                          const std::string& web_session_id,
+                                          const SessionError& error) {
   PP_DCHECK(result == PP_OK);
   pp::ContentDecryptor_Private::SessionError(
-      session_id, error_code, system_code);
+      web_session_id,
+      CdmExceptionTypeToPpExceptionType(error.exception_code),
+      error.system_code,
+      error.error_description);
 }
 
 void CdmAdapter::DeliverBlock(int32_t result,
                               const cdm::Status& status,
                               const LinkedDecryptedBlock& decrypted_block,
                               const PP_DecryptTrackingInfo& tracking_info) {
   PP_DCHECK(result == PP_OK);
   PP_DecryptedBlockInfo decrypted_block_info;
   decrypted_block_info.tracking_info = tracking_info;
   decrypted_block_info.tracking_info.timestamp = decrypted_block->Timestamp();
@@ skipping 268 matching lines @@
     cdm_->OnPlatformChallengeResponse(response);
     return;
   }
 
   pp::VarArrayBuffer signed_data_var(signed_data_output_);
   pp::VarArrayBuffer signed_data_signature_var(signed_data_signature_output_);
   std::string platform_key_certificate_string =
       platform_key_certificate_output_.AsString();
 
   cdm::PlatformChallengeResponse response = {
-    static_cast<uint8_t*>(signed_data_var.Map()),
-    signed_data_var.ByteLength(),
-
-    static_cast<uint8_t*>(signed_data_signature_var.Map()),
-    signed_data_signature_var.ByteLength(),
-
-    reinterpret_cast<const uint8_t*>(platform_key_certificate_string.c_str()),
-    static_cast<uint32_t>(platform_key_certificate_string.length())
-  };
+      static_cast<uint8_t*>(signed_data_var.Map()),
+      signed_data_var.ByteLength(),
+      static_cast<uint8_t*>(signed_data_signature_var.Map()),
+      signed_data_signature_var.ByteLength(),
+      reinterpret_cast<const uint8_t*>(platform_key_certificate_string.data()),
+      static_cast<uint32_t>(platform_key_certificate_string.length())};
   cdm_->OnPlatformChallengeResponse(response);
 
   signed_data_var.Unmap();
   signed_data_signature_var.Unmap();
 }
 
 void CdmAdapter::EnableProtectionDone(int32_t result) {
   // Does nothing since clients must call QueryOutputProtectionStatus() to
   // inspect the protection status on a regular basis.
   CDM_DLOG() << __FUNCTION__ << " : " << result;
 }
 
 void CdmAdapter::QueryOutputProtectionStatusDone(int32_t result) {
   PP_DCHECK(query_output_protection_in_progress_);
   query_output_protection_in_progress_ = false;
 
   // Return a protection status of none on error.
   if (result != PP_OK)
     output_link_mask_ = output_protection_mask_ = 0;
 
   cdm_->OnQueryOutputProtectionStatus(output_link_mask_,
                                       output_protection_mask_);
 }
 #endif
 
+CdmAdapter::SessionError::SessionError(cdm::MediaKeyException exception_code,
+                                       uint32_t system_code,
+                                       std::string error_description)
+    : exception_code(exception_code),
+      system_code(system_code),
+      error_description(error_description) {
+}
+
 void* GetCdmHost(int host_interface_version, void* user_data) {
   if (!host_interface_version || !user_data)
     return NULL;
 
   COMPILE_ASSERT(
-      cdm::ContentDecryptionModule::Host::kVersion == cdm::Host_4::kVersion,
+      cdm::ContentDecryptionModule::Host::kVersion == cdm::Host_5::kVersion,
       update_code_below);
 
   // Ensure IsSupportedCdmHostVersion matches implementation of this function.
   // Always update this DCHECK when updating this function.
   // If this check fails, update this function and DCHECK or update
   // IsSupportedCdmHostVersion.
 
   PP_DCHECK(
       // Future version is not supported.
-      !IsSupportedCdmHostVersion(cdm::Host_4::kVersion + 1) &&
+      !IsSupportedCdmHostVersion(cdm::Host_5::kVersion + 1) &&
       // Current version is supported.
+      IsSupportedCdmHostVersion(cdm::Host_5::kVersion) &&
+      // Include all previous supported versions (if any) here.
       IsSupportedCdmHostVersion(cdm::Host_4::kVersion) &&
-      // Include all previous supported versions (if any) here.
-      // No supported previous versions.
       // One older than the oldest supported version is not supported.
       !IsSupportedCdmHostVersion(cdm::Host_4::kVersion - 1));
   PP_DCHECK(IsSupportedCdmHostVersion(host_interface_version));
 
   CdmAdapter* cdm_adapter = static_cast<CdmAdapter*>(user_data);
   CDM_DLOG() << "Create CDM Host with version " << host_interface_version;
   switch (host_interface_version) {
     case cdm::Host_4::kVersion:
       return static_cast<cdm::Host_4*>(cdm_adapter);
+    case cdm::Host_5::kVersion:
+      return static_cast<cdm::Host_5*>(cdm_adapter);
     default:
       PP_NOTREACHED();
       return NULL;
   }
 }
 
 // This object is the global object representing this plugin library as long
 // as it is loaded.
 class CdmAdapterModule : public pp::Module {
  public:
@@ skipping 17 matching lines @@
 }  // namespace media
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new media::CdmAdapterModule();
 }
 
 }  // namespace pp