Remove CDM_5

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 369 matching lines @@
                       web_session_id.data(),
                       web_session_id.length(),
                       response_ptr,
                       response_size);
 }
 
 void CdmAdapter::CloseSession(uint32_t promise_id,
                               const std::string& web_session_id) {
   if (!cdm_->CloseSession(
           promise_id, web_session_id.data(), web_session_id.length())) {
-    // CDM_4 and CDM_5 don't support this method, so reject the promise.
+    // CDM_4 doesn't support this method, so reject the promise.
     RejectPromise(promise_id, cdm::kNotSupportedError, 0, "Not implemented.");
   }
 }
 
 void CdmAdapter::ReleaseSession(uint32_t promise_id,
                                 const std::string& web_session_id) {
   cdm_->RemoveSession(
       promise_id, web_session_id.data(), web_session_id.length());
 }
 
 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.
+    // CDM_4 doesn'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());
@@ skipping 181 matching lines @@
 }
 
 void CdmAdapter::TimerExpired(int32_t result, void* context) {
   PP_DCHECK(result == PP_OK);
   cdm_->TimerExpired(context);
 }
 
 // cdm::Host_4 methods
 
 double CdmAdapter::GetCurrentWallTimeInSeconds() {
-  return GetCurrentTime();
+  return GetCurrentWallTime();
 }
 
 void CdmAdapter::OnSessionCreated(uint32_t session_id,
                                   const char* web_session_id,
                                   uint32_t 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);
 }
 
@@ skipping 10 matching lines @@
                    destination_url,
                    destination_url_length);
 }
 
 void CdmAdapter::OnSessionReady(uint32_t 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());
+    PostOnMain(callback_factory_.NewCallback(
+        &CdmAdapter::SendSessionReadyInternal, web_session_id));
   }
 }
 
 void CdmAdapter::OnSessionClosed(uint32_t 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 {
@@ skipping 29 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 and cdm::Host_6 methods
-
-cdm::Time CdmAdapter::GetCurrentTime() {
-  return GetCurrentWallTime();
-}
+// cdm::Host_6 methods
 
 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::OnResolvePromise(uint32_t promise_id) {
+  PostOnMain(callback_factory_.NewCallback(
+      &CdmAdapter::SendPromiseResolvedInternal, promise_id));
 }
 
 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));
@@ skipping 31 matching lines @@
                                   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::OnSessionKeysChange(const char* web_session_id,
-                                     uint32_t web_session_id_length,
-                                     bool has_additional_usable_key) {
-  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) {
   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,
                                  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::Error error,
@@ skipping 490 matching lines @@
   // 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_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) &&
+      // Host_5 is not supported.
       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.
@@ skipping 19 matching lines @@
 }  // namespace media
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new media::CdmAdapterModule();
 }
 
 }  // namespace pp