Refactor CdmPromise and related classes

content/renderer/media/crypto/proxy_decryptor.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 "content/renderer/media/crypto/proxy_decryptor.h"
 
 #include <cstring>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "content/renderer/media/crypto/content_decryption_module_factory.h"
-#include "media/base/cdm_promise.h"
+#include "media/base/cdm_callback_promise.h"
 #include "media/cdm/json_web_key.h"
 #include "media/cdm/key_system_names.h"
 
 #if defined(ENABLE_PEPPER_CDMS)
 #include "content/renderer/media/crypto/pepper_cdm_wrapper.h"
 #endif  // defined(ENABLE_PEPPER_CDMS)
 
 #if defined(ENABLE_BROWSER_CDMS)
 #include "content/renderer/media/crypto/renderer_cdm_manager.h"
 #endif  // defined(ENABLE_BROWSER_CDMS)
@@ skipping 80 matching lines @@
   SessionCreationType session_creation_type = TemporarySession;
   if (HasHeader(init_data, init_data_length, kPrefixedApiLoadSessionHeader)) {
     session_creation_type = LoadSession;
   } else if (HasHeader(init_data,
                        init_data_length,
                        kPrefixedApiPersistentSessionHeader)) {
     session_creation_type = PersistentSession;
   }
 
   scoped_ptr<media::NewSessionCdmPromise> promise(
-      new media::NewSessionCdmPromise(
+      new media::CdmCallbackPromise<std::string>(
           base::Bind(&ProxyDecryptor::SetSessionId,
                      weak_ptr_factory_.GetWeakPtr(),
                      session_creation_type),
           base::Bind(&ProxyDecryptor::OnSessionError,
                      weak_ptr_factory_.GetWeakPtr(),
                      std::string())));  // No session id until created.
 
   if (session_creation_type == LoadSession) {
     media_keys_->LoadSession(
         std::string(reinterpret_cast<const char*>(
@@ skipping 30 matching lines @@
       session_id = it->first;
     } else {
       OnSessionError(std::string(),
                      media::MediaKeys::NOT_SUPPORTED_ERROR,
                      0,
                      "SessionId not specified.");
       return;
     }
   }
 
-  scoped_ptr<media::SimpleCdmPromise> promise(
-      new media::SimpleCdmPromise(base::Bind(&ProxyDecryptor::OnSessionReady,
-                                             weak_ptr_factory_.GetWeakPtr(),
-                                             web_session_id),
-                                  base::Bind(&ProxyDecryptor::OnSessionError,
-                                             weak_ptr_factory_.GetWeakPtr(),
-                                             web_session_id)));
+  scoped_ptr<media::SimpleCdmPromise> promise(new media::CdmCallbackPromise<>(
+      base::Bind(&ProxyDecryptor::OnSessionReady,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 web_session_id),
+      base::Bind(&ProxyDecryptor::OnSessionError,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 web_session_id)));
 
   // EME WD spec only supports a single array passed to the CDM. For
   // Clear Key using v0.1b, both arrays are used (|init_data| is key_id).
   // Since the EME WD spec supports the key as a JSON Web Key,
   // convert the 2 arrays to a JWK and pass it as the single array.
   if (is_clear_key_) {
     // Decryptor doesn't support empty key ID (see http://crbug.com/123265).
     // So ensure a non-empty value is passed.
     if (!init_data) {
       static const uint8 kDummyInitData[1] = {0};
@@ skipping 10 matching lines @@
                                promise.Pass());
     return;
   }
 
   media_keys_->UpdateSession(session_id, key, key_length, promise.Pass());
 }
 
 void ProxyDecryptor::CancelKeyRequest(const std::string& web_session_id) {
   DVLOG(1) << "CancelKeyRequest()";
 
-  scoped_ptr<media::SimpleCdmPromise> promise(
-      new media::SimpleCdmPromise(base::Bind(&ProxyDecryptor::OnSessionClosed,
-                                             weak_ptr_factory_.GetWeakPtr(),
-                                             web_session_id),
-                                  base::Bind(&ProxyDecryptor::OnSessionError,
-                                             weak_ptr_factory_.GetWeakPtr(),
-                                             web_session_id)));
+  scoped_ptr<media::SimpleCdmPromise> promise(new media::CdmCallbackPromise<>(
+      base::Bind(&ProxyDecryptor::OnSessionClosed,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 web_session_id),
+      base::Bind(&ProxyDecryptor::OnSessionError,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 web_session_id)));
   media_keys_->RemoveSession(web_session_id, promise.Pass());
 }
 
 scoped_ptr<media::MediaKeys> ProxyDecryptor::CreateMediaKeys(
     const std::string& key_system,
     const GURL& security_origin) {
   return ContentDecryptionModuleFactory::Create(
       key_system,
       security_origin,
 #if defined(ENABLE_PEPPER_CDMS)
@@ skipping 104 matching lines @@
   bool is_persistent =
       session_type == PersistentSession || session_type == LoadSession;
   active_sessions_.insert(std::make_pair(web_session_id, is_persistent));
 
   // For LoadSession(), generate the SessionReady event.
   if (session_type == LoadSession)
     OnSessionReady(web_session_id);
 }
 
 }  // namespace content