Refactor CdmPromise and related classes

media/cdm/ppapi/external_clear_key/clear_key_cdm.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/external_clear_key/clear_key_cdm.h"
 
 #include <algorithm>
 #include <cstring>
 #include <sstream>
 #include <string>
@@ skipping 230 matching lines @@
 
 void ClearKeyCdm::CreateSession(uint32 promise_id,
                                 const char* init_data_type,
                                 uint32 init_data_type_size,
                                 const uint8* init_data,
                                 uint32 init_data_size,
                                 cdm::SessionType session_type) {
   DVLOG(1) << __FUNCTION__;
 
   scoped_ptr<media::NewSessionCdmPromise> promise(
-      new media::NewSessionCdmPromise(base::Bind(&ClearKeyCdm::OnSessionCreated,
-                                                 base::Unretained(this),
-                                                 promise_id),
-                                      base::Bind(&ClearKeyCdm::OnPromiseFailed,
-                                                 base::Unretained(this),
-                                                 promise_id)));
+      new media::CdmCallbackPromise<std::string>(
+          base::Bind(&ClearKeyCdm::OnSessionCreated,
+                     base::Unretained(this),
+                     promise_id),
+          base::Bind(&ClearKeyCdm::OnPromiseFailed,
+                     base::Unretained(this),
+                     promise_id)));
   decryptor_.CreateSession(std::string(init_data_type, init_data_type_size),
                            init_data,
                            init_data_size,
                            ConvertSessionType(session_type),
                            promise.Pass());
 
   if (key_system_ == kExternalClearKeyFileIOTestKeySystem)
     StartFileIOTest();
 }
 
@@ skipping 11 matching lines @@
     std::string message("Incorrect session id specified for LoadSession().");
     host_->OnRejectPromise(promise_id,
                            cdm::kInvalidAccessError,
                            0,
                            message.data(),
                            message.length());
     return;
   }
 
   scoped_ptr<media::NewSessionCdmPromise> promise(
-      new media::NewSessionCdmPromise(base::Bind(&ClearKeyCdm::OnSessionLoaded,
-                                                 base::Unretained(this),
-                                                 promise_id),
-                                      base::Bind(&ClearKeyCdm::OnPromiseFailed,
-                                                 base::Unretained(this),
-                                                 promise_id)));
+      new media::CdmCallbackPromise<std::string>(
+          base::Bind(&ClearKeyCdm::OnSessionLoaded,
+                     base::Unretained(this),
+                     promise_id),
+          base::Bind(&ClearKeyCdm::OnPromiseFailed,
+                     base::Unretained(this),
+                     promise_id)));
   decryptor_.CreateSession(std::string(kLoadableSessionContentType),
                            NULL,
                            0,
                            MediaKeys::TEMPORARY_SESSION,
                            promise.Pass());
 }
 
 void ClearKeyCdm::UpdateSession(uint32 promise_id,
                                 const char* web_session_id,
                                 uint32_t web_session_id_length,
                                 const uint8* response,
                                 uint32 response_size) {
   DVLOG(1) << __FUNCTION__;
   std::string web_session_str(web_session_id, web_session_id_length);
 
-  scoped_ptr<media::SimpleCdmPromise> promise(new media::SimpleCdmPromise(
-      base::Bind(&ClearKeyCdm::OnSessionUpdated,
-                 base::Unretained(this),
-                 promise_id,
-                 web_session_str),
-      base::Bind(
-          &ClearKeyCdm::OnPromiseFailed, base::Unretained(this), promise_id)));
+  scoped_ptr<media::SimpleCdmPromise> promise(
+      new media::CdmCallbackPromise<void>(
+          base::Bind(&ClearKeyCdm::OnSessionUpdated,
+                     base::Unretained(this),
+                     promise_id,
+                     web_session_str),
+          base::Bind(&ClearKeyCdm::OnPromiseFailed,
+                     base::Unretained(this),
+                     promise_id)));
   decryptor_.UpdateSession(
       web_session_str, response, response_size, promise.Pass());
 
   if (!heartbeat_timer_set_) {
     ScheduleNextHeartBeat();
     heartbeat_timer_set_ = true;
   }
 }
 
 void ClearKeyCdm::CloseSession(uint32 promise_id,
                                const char* web_session_id,
                                uint32_t web_session_id_length) {
   DVLOG(1) << __FUNCTION__;
   std::string web_session_str(web_session_id, web_session_id_length);
 
-  scoped_ptr<media::SimpleCdmPromise> promise(new media::SimpleCdmPromise(
+  scoped_ptr<media::SimpleCdmPromise>
+  promise(new media::CdmCallbackPromise<void>(
       base::Bind(
           &ClearKeyCdm::OnPromiseResolved, base::Unretained(this), promise_id),
       base::Bind(
           &ClearKeyCdm::OnPromiseFailed, base::Unretained(this), promise_id)));
   decryptor_.CloseSession(web_session_str, promise.Pass());
 }
 
 void ClearKeyCdm::RemoveSession(uint32 promise_id,
                                 const char* web_session_id,
                                 uint32_t web_session_id_length) {
   DVLOG(1) << __FUNCTION__;
   // RemoveSession only allowed for persistent sessions.
   bool is_persistent_session =
       std::string(kLoadableWebSessionId) ==
       std::string(web_session_id, web_session_id_length);
   if (is_persistent_session) {
     std::string web_session_str(web_session_id, web_session_id_length);
 
     scoped_ptr<media::SimpleCdmPromise> promise(
-        new media::SimpleCdmPromise(base::Bind(&ClearKeyCdm::OnPromiseResolved,
-                                               base::Unretained(this),
-                                               promise_id),
-                                    base::Bind(&ClearKeyCdm::OnPromiseFailed,
-                                               base::Unretained(this),
-                                               promise_id)));
+        new media::CdmCallbackPromise<void>(
+            base::Bind(&ClearKeyCdm::OnPromiseResolved,
+                       base::Unretained(this),
+                       promise_id),
+            base::Bind(&ClearKeyCdm::OnPromiseFailed,
+                       base::Unretained(this),
+                       promise_id)));
     decryptor_.RemoveSession(web_session_str, promise.Pass());
   } else {
     // TODO(jrummell): This should be a DCHECK once blink does the proper
     // checks.
     std::string message("Not supported for non-persistent sessions.");
     host_->OnRejectPromise(promise_id,
                            cdm::kInvalidAccessError,
                            0,
                            message.data(),
                            message.length());
   }
 }
 
 void ClearKeyCdm::SetServerCertificate(uint32 promise_id,
                                        const uint8_t* server_certificate_data,
                                        uint32_t server_certificate_data_size) {
   // ClearKey doesn't use a server certificate.
   host_->OnResolvePromise(promise_id);
 }
 
 void ClearKeyCdm::GetUsableKeyIds(uint32_t promise_id,
                                   const char* web_session_id,
                                   uint32_t web_session_id_length) {
   std::string web_session_str(web_session_id, web_session_id_length);
-  scoped_ptr<media::KeyIdsPromise> promise(new media::KeyIdsPromise(
-      base::Bind(&ClearKeyCdm::OnUsableKeyIdsObtained,
-                 base::Unretained(this),
-                 promise_id),
-      base::Bind(
-          &ClearKeyCdm::OnPromiseFailed, base::Unretained(this), promise_id)));
+  scoped_ptr<media::KeyIdsPromise> promise(
+      new media::CdmCallbackPromise<KeyIdsVector>(
+          base::Bind(&ClearKeyCdm::OnUsableKeyIdsObtained,
+                     base::Unretained(this),
+                     promise_id),
+          base::Bind(&ClearKeyCdm::OnPromiseFailed,
+                     base::Unretained(this),
+                     promise_id)));
   decryptor_.GetUsableKeyIds(web_session_str, promise.Pass());
 }
 
 void ClearKeyCdm::TimerExpired(void* context) {
   if (context == &session_id_for_emulated_loadsession_) {
     LoadLoadableSession();
     return;
   }
 
   DCHECK(heartbeat_timer_set_);
@@ skipping 256 matching lines @@
   NOTIMPLEMENTED();
 };
 
 void ClearKeyCdm::LoadLoadableSession() {
   std::string jwk_set = GenerateJWKSet(kLoadableSessionKey,
                                        sizeof(kLoadableSessionKey),
                                        kLoadableSessionKeyId,
                                        sizeof(kLoadableSessionKeyId) - 1);
   // TODO(xhwang): This triggers OnSessionUpdated(). For prefixed EME support,
   // this is okay. Check WD EME support.
-  scoped_ptr<media::SimpleCdmPromise> promise(new media::SimpleCdmPromise(
-      base::Bind(&ClearKeyCdm::OnSessionUpdated,
-                 base::Unretained(this),
-                 promise_id_for_emulated_loadsession_,
-                 session_id_for_emulated_loadsession_),
-      base::Bind(&ClearKeyCdm::OnPromiseFailed,
-                 base::Unretained(this),
-                 promise_id_for_emulated_loadsession_)));
+  scoped_ptr<media::SimpleCdmPromise> promise(
+      new media::CdmCallbackPromise<void>(
+          base::Bind(&ClearKeyCdm::OnSessionUpdated,
+                     base::Unretained(this),
+                     promise_id_for_emulated_loadsession_,
+                     session_id_for_emulated_loadsession_),
+          base::Bind(&ClearKeyCdm::OnPromiseFailed,
+                     base::Unretained(this),
+                     promise_id_for_emulated_loadsession_)));
   decryptor_.UpdateSession(session_id_for_emulated_loadsession_,
                            reinterpret_cast<const uint8*>(jwk_set.data()),
                            jwk_set.size(),
                            promise.Pass());
 }
 
 void ClearKeyCdm::OnSessionMessage(const std::string& web_session_id,
                                    const std::vector<uint8>& message,
                                    const GURL& destination_url) {
   DVLOG(1) << "OnSessionMessage: " << message.size();
@@ skipping 167 matching lines @@
   host_->OnSessionMessage(last_session_id_.data(),
                           last_session_id_.length(),
                           message.data(),
                           message.length(),
                           NULL,
                           0);
   file_io_test_runner_.reset();
 }
 
 }  // namespace media