Add support for 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/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"
@@ skipping 367 matching lines @@
 
   cdm_->UpdateSession(promise_id,
                       web_session_id.data(),
                       web_session_id.length(),
                       response_ptr,
                       response_size);
 }
 
 void CdmAdapter::ReleaseSession(uint32_t promise_id,
                                 const std::string& web_session_id) {
-  cdm_->ReleaseSession(
+  cdm_->CloseSession(
       promise_id, web_session_id.data(), web_session_id.length());
 }
 
+void CdmAdapter::RemoveSession(uint32_t promise_id,
+                               const std::string& web_session_id) {
+  if (!cdm_->RemoveSession(
+          promise_id, web_session_id.data(), web_session_id.length())) {
+    // CDM_4 and CDM_5 don't support this method, so reject the promise.
+    RejectPromise(promise_id, cdm::kNotSupportedError, 0, "Not implemented.");
+  }
+}
+
+void CdmAdapter::GetUsableKeyIds(uint32_t promise_id,
+                                 const std::string& web_session_id) {
+  if (!cdm_->GetUsableKeyIds(
+          promise_id, web_session_id.data(), web_session_id.length())) {
+    // CDM_4 and CDM_5 don't support this method, so reject the promise.
+    RejectPromise(promise_id, cdm::kNotSupportedError, 0, "Not implemented.");
+  }
+}
+
 // 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.
   allocator_.Release(encrypted_block_info.tracking_info.buffer_id);
 
@@ skipping 258 matching lines @@
     std::string web_session_id = cdm_->LookupWebSessionId(session_id);
     OnSessionError(web_session_id.data(),
                    web_session_id.length(),
                    error,
                    system_code,
                    NULL,
                    0);
   }
 }
 
-// cdm::Host_5 methods
+// cdm::Host_5 and cdm::Host_6 methods
 
 cdm::Time CdmAdapter::GetCurrentTime() {
+  return GetCurrentWallTime();
+}
+
+cdm::Time CdmAdapter::GetCurrentWallTime() {
   return pp::Module::Get()->core()->GetTime();
 }
 
 void CdmAdapter::OnResolvePromise(uint32_t promise_id) {
   PostOnMain(callback_factory_.NewCallback(
       &CdmAdapter::SendPromiseResolvedInternal, promise_id));
+
+  // CDM_5 doesn't support OnSessionKeysChange(), so simulate one if requested.
+  // Passing "true" which may result in false positives for retrying.
+  std::string session_id;
+  if (cdm_->SessionUsableKeysEventNeeded(promise_id, &session_id))
+    OnSessionKeysChange(session_id.data(), session_id.length(), true);
 }
 
 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)));
+
+  // CDM_5 doesn't support OnSessionKeysChange(), so simulate one if requested.
+  // Passing "true" which may result in false positives for retrying.
+  std::string session_id;
+  if (cdm_->SessionUsableKeysEventNeeded(promise_id, &session_id))
+    OnSessionKeysChange(web_session_id, web_session_id_length, true);
+}
+
+void CdmAdapter::OnResolveKeyIdsPromise(uint32_t promise_id,
+                                        const cdm::BinaryData* usable_key_ids,
+                                        uint32_t usable_key_ids_length) {
+  std::vector<std::vector<uint8> > key_ids;
+  for (uint32_t i = 0; i < usable_key_ids_length; ++i) {
+    key_ids.push_back(
+        std::vector<uint8>(usable_key_ids[i].data,
+                           usable_key_ids[i].data + usable_key_ids[i].length));
+  }
+  PostOnMain(callback_factory_.NewCallback(
+      &CdmAdapter::SendPromiseResolvedWithUsableKeyIdsInternal,
+      promise_id,
+      key_ids));
 }
 
 void CdmAdapter::OnRejectPromise(uint32_t promise_id,
                                  cdm::Error error,
                                  uint32_t system_code,
                                  const char* error_message,
                                  uint32_t error_message_length) {
   RejectPromise(promise_id,
                 error,
                 system_code,
@@ skipping 19 matching lines @@
   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::OnSessionKeysChange(const char* web_session_id,
                                      uint32_t web_session_id_length,
                                      bool has_additional_usable_key) {
-  // TODO(jrummell): Implement this event in subsequent CL
-  // (http://crbug.com/370251).
-  PP_NOTREACHED();
+  OnSessionUsableKeysChange(
+      web_session_id, web_session_id_length, has_additional_usable_key);
+}
+
+void CdmAdapter::OnSessionUsableKeysChange(const char* web_session_id,
+                                           uint32_t web_session_id_length,
+                                           bool has_additional_usable_key) {
+  PostOnMain(callback_factory_.NewCallback(
+      &CdmAdapter::SendSessionUsableKeysChangeInternal,
+      std::string(web_session_id, web_session_id_length),
+      has_additional_usable_key));
 }
 
 void CdmAdapter::OnExpirationChange(const char* web_session_id,
                                     uint32_t web_session_id_length,
                                     cdm::Time new_expiry_time) {
-  // TODO(jrummell): Implement this event in subsequent CL
-  // (http://crbug.com/370251).
-  PP_NOTREACHED();
+  PostOnMain(callback_factory_.NewCallback(
+      &CdmAdapter::SendExpirationChangeInternal,
+      std::string(web_session_id, web_session_id_length),
+      new_expiry_time));
 }
 
 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,
@@ skipping 27 matching lines @@
 
 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::SendPromiseResolvedWithUsableKeyIdsInternal(
+    int32_t result,
+    uint32_t promise_id,
+    std::vector<std::vector<uint8> > key_ids) {
+  PP_DCHECK(result == PP_OK);
+  // TODO(jrummell): Implement this event in subsequent CL.
+  // (http://crbug.com/358271).
+}
+
 void CdmAdapter::SendPromiseRejectedInternal(int32_t result,
                                              uint32_t promise_id,
                                              const SessionError& error) {
   PP_DCHECK(result == PP_OK);
   pp::ContentDecryptor_Private::PromiseRejected(
       promise_id,
       CdmExceptionTypeToPpCdmExceptionType(error.error),
       error.system_code,
       error.error_description);
 }
@@ skipping 30 matching lines @@
                                           const std::string& web_session_id,
                                           const SessionError& error) {
   PP_DCHECK(result == PP_OK);
   pp::ContentDecryptor_Private::SessionError(
       web_session_id,
       CdmExceptionTypeToPpCdmExceptionType(error.error),
       error.system_code,
       error.error_description);
 }
 
+void CdmAdapter::SendSessionUsableKeysChangeInternal(
+    int32_t result,
+    const std::string& web_session_id,
+    bool has_additional_usable_key) {
+  PP_DCHECK(result == PP_OK);
+  // TODO(jrummell): Implement this event in subsequent CL.
+  // (http://crbug.com/358271).
+}
+
+void CdmAdapter::SendExpirationChangeInternal(int32_t result,
+                                              const std::string& web_session_id,
+                                              cdm::Time new_expiry_time) {
+  PP_DCHECK(result == PP_OK);
+  // TODO(jrummell): Implement this event in subsequent CL.
+  // (http://crbug.com/358271).
+}
+
 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();
   decrypted_block_info.tracking_info.buffer_id = 0;
   decrypted_block_info.data_size = 0;
@@ skipping 362 matching lines @@
     : error(error),
       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_5::kVersion,
+      cdm::ContentDecryptionModule::Host::kVersion == cdm::Host_6::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_5::kVersion + 1) &&
+      !IsSupportedCdmHostVersion(cdm::Host_6::kVersion + 1) &&
       // Current version is supported.
+      IsSupportedCdmHostVersion(cdm::Host_6::kVersion) &&
+      // Include all previous supported versions (if any) here.
       IsSupportedCdmHostVersion(cdm::Host_5::kVersion) &&
-      // Include all previous supported versions (if any) here.
       IsSupportedCdmHostVersion(cdm::Host_4::kVersion) &&
       // 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);
+    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