Add support for cdm::ContentDecryptionModule_8, remove CDM_6

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/limits.h"
 #include "media/cdm/ppapi/cdm_file_io_impl.h"
 #include "media/cdm/ppapi/cdm_helpers.h"
 #include "media/cdm/ppapi/cdm_logging.h"
@@ skipping 214 matching lines @@
     case PP_SESSIONTYPE_PERSISTENT_LICENSE:
       return cdm::kPersistentLicense;
     case PP_SESSIONTYPE_PERSISTENT_RELEASE:
       return cdm::kPersistentKeyRelease;
   }
 
   PP_NOTREACHED();
   return cdm::kTemporary;
 }
 
+cdm::InitDataType InitDataTypeToCdmInitDataType(
+    const std::string& init_data_type) {
+  if (init_data_type == "cenc")
+    return cdm::kCenc;
+  if (init_data_type == "webm")
+    return cdm::kWebM;
+  if (init_data_type == "keyids")
+    return cdm::kKeyIds;
+
+  PP_NOTREACHED();
+  return cdm::kKeyIds;
+}
+
 PP_CdmExceptionCode CdmExceptionTypeToPpCdmExceptionType(cdm::Error error) {
   switch (error) {
     case cdm::kNotSupportedError:
       return PP_CDMEXCEPTIONCODE_NOTSUPPORTEDERROR;
     case cdm::kInvalidStateError:
       return PP_CDMEXCEPTIONCODE_INVALIDSTATEERROR;
     case cdm::kInvalidAccessError:
       return PP_CDMEXCEPTIONCODE_INVALIDACCESSERROR;
     case cdm::kQuotaExceededError:
       return PP_CDMEXCEPTIONCODE_QUOTAEXCEEDEDERROR;
@@ skipping 26 matching lines @@
 PP_CdmKeyStatus CdmKeyStatusToPpKeyStatus(cdm::KeyStatus status) {
   switch (status) {
     case cdm::kUsable:
       return PP_CDMKEYSTATUS_USABLE;
     case cdm::kInternalError:
       return PP_CDMKEYSTATUS_INVALID;
     case cdm::kExpired:
       return PP_CDMKEYSTATUS_EXPIRED;
     case cdm::kOutputNotAllowed:
       return PP_CDMKEYSTATUS_OUTPUTNOTALLOWED;
+    case cdm::kOutputDownscaled:
+      return PP_CDMKEYSTATUS_OUTPUTDOWNSCALED;
+    case cdm::kStatusPending:
+      return PP_CDMKEYSTATUS_STATUSPENDING;
   }
 
   PP_NOTREACHED();
   return PP_CDMKEYSTATUS_INVALID;
 }
 
 }  // namespace
 
 namespace media {
 
@@ skipping 42 matching lines @@
 // "Store this new error object internally with the MediaKeys instance being
 // created. This will be used to fire an error against any session created for
 // this instance." These errors will be reported during session creation
 // (CreateSession()) or session loading (LoadSession()).
 // TODO(xhwang): If necessary, we need to store the error here if we want to
 // support more specific error reporting (other than "Unknown").
 void CdmAdapter::Initialize(const std::string& key_system,
                             bool allow_distinctive_identifier,
                             bool allow_persistent_state) {
   PP_DCHECK(!key_system.empty());
+  // TODO(jrummell): Remove this check when CDM creation is asynchronous.
+  // http://crbug.com/469003
   PP_DCHECK(key_system_.empty() || (key_system_ == key_system && cdm_));
 
 #if defined(CHECK_DOCUMENT_URL)
   PP_URLComponents_Dev url_components = {};
   const pp::URLUtil_Dev* url_util = pp::URLUtil_Dev::Get();
   if (!url_util)
     return;
   pp::Var href = url_util->GetDocumentURL(pp::InstanceHandle(pp_instance()),
                                           &url_components);
   PP_DCHECK(href.is_string());
   std::string url = href.AsString();
   PP_DCHECK(!url.empty());
   std::string url_scheme =
       url.substr(url_components.scheme.begin, url_components.scheme.len);
   if (url_scheme != "file") {
     // Skip this check for file:// URLs as they don't have a host component.
     PP_DCHECK(url_components.host.begin);
     PP_DCHECK(0 < url_components.host.len);
   }
 #endif  // defined(CHECK_DOCUMENT_URL)
 
   if (!cdm_ && !CreateCdmInstance(key_system))
     return;
 
   PP_DCHECK(cdm_);
   key_system_ = key_system;
   allow_distinctive_identifier_ = allow_distinctive_identifier;
   allow_persistent_state_ = allow_persistent_state;
+  cdm_->Initialize(allow_distinctive_identifier, allow_persistent_state);
 }
 
 void CdmAdapter::SetServerCertificate(uint32_t promise_id,
                                       pp::VarArrayBuffer server_certificate) {
   const uint8_t* server_certificate_ptr =
       static_cast<const uint8_t*>(server_certificate.Map());
   const uint32_t server_certificate_size = server_certificate.ByteLength();
 
   if (!server_certificate_ptr ||
       server_certificate_size < media::limits::kMinCertificateLength ||
@@ skipping 11 matching lines @@
                   cdm::kInvalidStateError,
                   0,
                   "CDM has not been initialized.");
     return;
   }
 
   cdm_->SetServerCertificate(
       promise_id, server_certificate_ptr, server_certificate_size);
 }
 
+// TODO(jrummell): |init_data_type| should be an enum all the way through
+// Chromium. http://crbug.com/469228
 void CdmAdapter::CreateSessionAndGenerateRequest(
     uint32_t promise_id,
     PP_SessionType session_type,
     const std::string& init_data_type,
     pp::VarArrayBuffer init_data) {
   // Initialize() doesn't report an error, so CreateSession() can be called
   // even if Initialize() failed.
   // TODO(jrummell): Remove this code when prefixed EME gets removed.
   // TODO(jrummell): Verify that Initialize() failing does not resolve the
   // MediaKeys.create() promise.
   if (!cdm_) {
     RejectPromise(promise_id,
                   cdm::kInvalidStateError,
                   0,
                   "CDM has not been initialized.");
     return;
   }
 
   cdm_->CreateSessionAndGenerateRequest(
       promise_id, PpSessionTypeToCdmSessionType(session_type),
-      init_data_type.data(), init_data_type.size(),
+      InitDataTypeToCdmInitDataType(init_data_type),
       static_cast<const uint8_t*>(init_data.Map()), init_data.ByteLength());
 }
 
 void CdmAdapter::LoadSession(uint32_t promise_id,
                              PP_SessionType session_type,
                              const std::string& session_id) {
   // Initialize() doesn't report an error, so LoadSession() can be called
   // even if Initialize() failed.
   // TODO(jrummell): Remove this code when prefixed EME gets removed.
   // TODO(jrummell): Verify that Initialize() failing does not resolve the
@@ skipping 238 matching lines @@
   PostOnMain(callback_factory_.NewCallback(
       &CdmAdapter::SendPromiseResolvedWithSessionInternal, promise_id,
       std::string(session_id, session_id_size)));
 }
 
 void CdmAdapter::OnResolvePromise(uint32_t promise_id) {
   PostOnMain(callback_factory_.NewCallback(
       &CdmAdapter::SendPromiseResolvedInternal, promise_id));
 }
 
-// cdm::Host_6 only
-void CdmAdapter::OnResolveKeyIdsPromise(uint32_t promise_id,
-                                        const cdm::BinaryData* usable_key_ids,
-                                        uint32_t usable_key_ids_size) {
-  // This should never be called as GetUsableKeyIds() has been removed.
-  PP_NOTREACHED();
-}
-
 void CdmAdapter::OnRejectPromise(uint32_t promise_id,
                                  cdm::Error error,
                                  uint32_t system_code,
                                  const char* error_message,
                                  uint32_t error_message_size) {
   // UMA to investigate http://crbug.com/410630
   // TODO(xhwang): Remove after bug is fixed.
   if (system_code == 0x27) {
     pp::UMAPrivate uma_interface(this);
     uma_interface.HistogramCustomCounts("Media.EME.CdmFileIO.FileSizeKBOnError",
@@ skipping 10 matching lines @@
 void CdmAdapter::RejectPromise(uint32_t promise_id,
                                cdm::Error error,
                                uint32_t system_code,
                                const std::string& error_message) {
   PostOnMain(callback_factory_.NewCallback(
       &CdmAdapter::SendPromiseRejectedInternal,
       promise_id,
       SessionError(error, system_code, error_message)));
 }
 
-// cdm::Host_7 only.
 void CdmAdapter::OnSessionMessage(const char* session_id,
                                   uint32_t session_id_size,
                                   cdm::MessageType message_type,
                                   const char* message,
                                   uint32_t message_size,
                                   const char* legacy_destination_url,
                                   uint32_t legacy_destination_url_size) {
   // License requests should not specify |legacy_destination_url|.
   // |legacy_destination_url| is not passed to unprefixed EME applications,
   // so it can be removed when the prefixed API is removed.
   PP_DCHECK(legacy_destination_url_size == 0 ||
             message_type != cdm::MessageType::kLicenseRequest);
 
   PostOnMain(callback_factory_.NewCallback(
       &CdmAdapter::SendSessionMessageInternal,
       SessionMessage(
           std::string(session_id, session_id_size), message_type, message,
           message_size,
           std::string(legacy_destination_url, legacy_destination_url_size))));
 }
 
-// cdm::Host_6 only.
-void CdmAdapter::OnSessionMessage(const char* session_id,
-                                  uint32_t session_id_size,
-                                  const char* message,
-                                  uint32_t message_size,
-                                  const char* destination_url,
-                                  uint32_t destination_url_size) {
-  // |destination_url| is no longer passed to unprefixed EME applications,
-  // so it will be dropped. All messages will appear as license renewals
-  // if |destination_url| is provided, license request if not.
-  cdm::MessageType message_type = (destination_url_size > 0)
-                                      ? cdm::MessageType::kLicenseRenewal
-                                      : cdm::MessageType::kLicenseRequest;
-  PostOnMain(callback_factory_.NewCallback(
-      &CdmAdapter::SendSessionMessageInternal,
-      SessionMessage(std::string(session_id, session_id_size), message_type,
-                     message, message_size,
-                     std::string(destination_url, destination_url_size))));
-}
-
-// cdm::Host_7 only.
 void CdmAdapter::OnSessionKeysChange(const char* session_id,
                                      uint32_t session_id_size,
                                      bool has_additional_usable_key,
                                      const cdm::KeyInformation* keys_info,
                                      uint32_t keys_info_count) {
   std::vector<PP_KeyInformation> key_information;
   for (uint32_t i = 0; i < keys_info_count; ++i) {
     const auto& key_info = keys_info[i];
     PP_KeyInformation next_key = {};
 
@@ skipping 11 matching lines @@
     next_key.system_code = key_info.system_code;
     key_information.push_back(next_key);
   }
 
   PostOnMain(callback_factory_.NewCallback(
       &CdmAdapter::SendSessionKeysChangeInternal,
       std::string(session_id, session_id_size), has_additional_usable_key,
       key_information));
 }
 
-// cdm::Host_6 only.
-void CdmAdapter::OnSessionUsableKeysChange(const char* session_id,
-                                           uint32_t session_id_size,
-                                           bool has_additional_usable_key) {
-  PostOnMain(callback_factory_.NewCallback(
-      &CdmAdapter::SendSessionKeysChangeInternal,
-      std::string(session_id, session_id_size), has_additional_usable_key,
-      std::vector<PP_KeyInformation>()));
-}
-
 void CdmAdapter::OnExpirationChange(const char* session_id,
                                     uint32_t session_id_size,
                                     cdm::Time new_expiry_time) {
   PostOnMain(callback_factory_.NewCallback(
       &CdmAdapter::SendExpirationChangeInternal,
       std::string(session_id, session_id_size), new_expiry_time));
 }
 
 void CdmAdapter::OnSessionClosed(const char* session_id,
                                  uint32_t session_id_size) {
   PostOnMain(
       callback_factory_.NewCallback(&CdmAdapter::SendSessionClosedInternal,
                                     std::string(session_id, session_id_size)));
 }
 
-// cdm::Host_6 only.
-void CdmAdapter::OnSessionError(const char* session_id,
-                                uint32_t session_id_size,
-                                cdm::Error error,
-                                uint32_t system_code,
-                                const char* error_message,
-                                uint32_t error_message_size) {
+void CdmAdapter::OnLegacySessionError(const char* session_id,
+                                      uint32_t session_id_size,
+                                      cdm::Error error,
+                                      uint32_t system_code,
+                                      const char* error_message,
+                                      uint32_t error_message_size) {
   PostOnMain(callback_factory_.NewCallback(
       &CdmAdapter::SendSessionErrorInternal,
       std::string(session_id, session_id_size),
       SessionError(error, system_code,
                    std::string(error_message, error_message_size))));
 }
 
-// cdm::Host_7 only.
-void CdmAdapter::OnLegacySessionError(const char* session_id,
-                                      uint32_t session_id_size,
-                                      cdm::Error error,
-                                      uint32_t system_code,
-                                      const char* error_message,
-                                      uint32_t error_message_size) {
-  OnSessionError(session_id, session_id_size, error, system_code, error_message,
-                 error_message_size);
-}
-
 // 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::PromiseResolved(promise_id);
 }
 
 void CdmAdapter::SendPromiseResolvedWithSessionInternal(
     int32_t result,
@@ skipping 486 matching lines @@
       message_type(message_type),
       message(message, message + message_size),
       legacy_destination_url(legacy_destination_url) {
 }
 
 void* GetCdmHost(int host_interface_version, void* user_data) {
   if (!host_interface_version || !user_data)
     return NULL;
 
   static_assert(
-      cdm::ContentDecryptionModule::Host::kVersion == cdm::Host_7::kVersion,
+      cdm::ContentDecryptionModule::Host::kVersion == cdm::Host_8::kVersion,
       "update the 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_7::kVersion + 1) &&
+      !IsSupportedCdmHostVersion(cdm::Host_8::kVersion + 1) &&
       // Current version is supported.
+      IsSupportedCdmHostVersion(cdm::Host_8::kVersion) &&
+      // Include all previous supported versions (if any) here.
       IsSupportedCdmHostVersion(cdm::Host_7::kVersion) &&
-      // Include all previous supported versions (if any) here.
-      IsSupportedCdmHostVersion(cdm::Host_6::kVersion) &&
       // One older than the oldest supported version is not supported.
-      !IsSupportedCdmHostVersion(cdm::Host_6::kVersion - 1));
+      !IsSupportedCdmHostVersion(cdm::Host_7::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_8::kVersion:
+      return static_cast<cdm::Host_8*>(cdm_adapter);
     case cdm::Host_7::kVersion:
       return static_cast<cdm::Host_7*>(cdm_adapter);
-    case cdm::Host_6::kVersion:
-      return static_cast<cdm::Host_6*>(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