Move CdmResultPromise to media/blink.

content/renderer/media/webcontentdecryptionmodulesession_impl.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/webcontentdecryptionmodulesession_impl.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
-#include "content/renderer/media/cdm_result_promise.h"
 #include "content/renderer/media/cdm_session_adapter.h"
 #include "media/base/cdm_promise.h"
+#include "media/base/media_keys.h"
+#include "media/blink/cdm_result_promise.h"
+#include "media/blink/new_session_cdm_result_promise.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 
 namespace content {
 
 const char kCreateSessionUMAName[] = "CreateSession";
 const char kLoadSessionUMAName[] = "LoadSession";
 
 WebContentDecryptionModuleSessionImpl::WebContentDecryptionModuleSessionImpl(
     const scoped_refptr<CdmSessionAdapter>& adapter)
     : adapter_(adapter),
@@ skipping 59 matching lines @@
   std::string init_data_type_as_ascii = base::UTF16ToASCII(init_data_type);
   DLOG_IF(WARNING, init_data_type_as_ascii.find('/') != std::string::npos)
       << "init_data_type '" << init_data_type_as_ascii
       << "' may be a MIME type";
 
   adapter_->InitializeNewSession(
       init_data_type_as_ascii,
       init_data,
       init_data_length,
       media::MediaKeys::TEMPORARY_SESSION,
-      scoped_ptr<media::NewSessionCdmPromise>(new NewSessionCdmResultPromise(
-          result,
-          adapter_->GetKeySystemUMAPrefix() + kCreateSessionUMAName,
-          base::Bind(
-              &WebContentDecryptionModuleSessionImpl::OnSessionInitialized,
-              base::Unretained(this)))));
+      scoped_ptr<media::NewSessionCdmPromise>(
+          new media::NewSessionCdmResultPromise(
+              result,
+              adapter_->GetKeySystemUMAPrefix() + kCreateSessionUMAName,
+              base::Bind(
+                  &WebContentDecryptionModuleSessionImpl::OnSessionInitialized,
+                  base::Unretained(this)))));
 }
 
 void WebContentDecryptionModuleSessionImpl::load(
     const blink::WebString& session_id,
     blink::WebContentDecryptionModuleResult result) {
   DCHECK(!session_id.isEmpty());
   DCHECK(web_session_id_.empty());
 
   adapter_->LoadSession(
       base::UTF16ToASCII(session_id),
-      scoped_ptr<media::NewSessionCdmPromise>(new NewSessionCdmResultPromise(
-          result,
-          adapter_->GetKeySystemUMAPrefix() + kLoadSessionUMAName,
-          base::Bind(
-              &WebContentDecryptionModuleSessionImpl::OnSessionInitialized,
-              base::Unretained(this)))));
+      scoped_ptr<media::NewSessionCdmPromise>(
+          new media::NewSessionCdmResultPromise(
+              result,
+              adapter_->GetKeySystemUMAPrefix() + kLoadSessionUMAName,
+              base::Bind(
+                  &WebContentDecryptionModuleSessionImpl::OnSessionInitialized,
+                  base::Unretained(this)))));
 }
 
 void WebContentDecryptionModuleSessionImpl::update(
     const uint8* response,
     size_t response_length,
     blink::WebContentDecryptionModuleResult result) {
   DCHECK(response);
   DCHECK(!web_session_id_.empty());
-  adapter_->UpdateSession(web_session_id_,
-                          response,
-                          response_length,
-                          scoped_ptr<media::SimpleCdmPromise>(
-                              new CdmResultPromise<>(result, std::string())));
+  adapter_->UpdateSession(
+      web_session_id_,
+      response,
+      response_length,
+      scoped_ptr<media::SimpleCdmPromise>(
+          new media::CdmResultPromise<>(result, std::string())));
 }
 
 void WebContentDecryptionModuleSessionImpl::close(
     blink::WebContentDecryptionModuleResult result) {
   DCHECK(!web_session_id_.empty());
-  adapter_->CloseSession(web_session_id_,
-                         scoped_ptr<media::SimpleCdmPromise>(
-                             new CdmResultPromise<>(result, std::string())));
+  adapter_->CloseSession(
+      web_session_id_,
+      scoped_ptr<media::SimpleCdmPromise>(
+          new media::CdmResultPromise<>(result, std::string())));
 }
 
 void WebContentDecryptionModuleSessionImpl::remove(
     blink::WebContentDecryptionModuleResult result) {
   DCHECK(!web_session_id_.empty());
-  adapter_->RemoveSession(web_session_id_,
-                          scoped_ptr<media::SimpleCdmPromise>(
-                              new CdmResultPromise<>(result, std::string())));
+  adapter_->RemoveSession(
+      web_session_id_,
+      scoped_ptr<media::SimpleCdmPromise>(
+          new media::CdmResultPromise<>(result, std::string())));
 }
 
 void WebContentDecryptionModuleSessionImpl::getUsableKeyIds(
     blink::WebContentDecryptionModuleResult result) {
   DCHECK(!web_session_id_.empty());
   adapter_->GetUsableKeyIds(
       web_session_id_,
       scoped_ptr<media::KeyIdsPromise>(
-          new CdmResultPromise<media::KeyIdsVector>(result, std::string())));
+          new media::CdmResultPromise<media::KeyIdsVector>(result,
+                                                           std::string())));
 }
 
 void WebContentDecryptionModuleSessionImpl::release(
     blink::WebContentDecryptionModuleResult result) {
   close(result);
 }
 
 void WebContentDecryptionModuleSessionImpl::OnSessionMessage(
     const std::vector<uint8>& message,
     const GURL& destination_url) {
@@ skipping 12 matching lines @@
   // TODO(jrummell): Update this once Blink client supports this.
   // The EME spec has expiration attribute as the time in milliseconds, so use
   // InMillisecondsF() to convert.
 }
 
 void WebContentDecryptionModuleSessionImpl::OnSessionReady() {
   client_->ready();
 }
 
 void WebContentDecryptionModuleSessionImpl::OnSessionClosed() {
-  if (!is_closed_) {
-    is_closed_ = true;
-    client_->close();
-  }
+  if (is_closed_)
+    return;
+
+  is_closed_ = true;
+  client_->close();
 }
 
 void WebContentDecryptionModuleSessionImpl::OnSessionError(
     media::MediaKeys::Exception exception_code,
     uint32 system_code,
     const std::string& error_message) {
   // Convert |exception_code| back to MediaKeyErrorCode if possible.
   // TODO(jrummell): Update this conversion when promises flow
   // back into blink:: (as blink:: will have its own error definition).
   switch (exception_code) {
@@ skipping 17 matching lines @@
 
   DCHECK(web_session_id_.empty()) << "Session ID may not be changed once set.";
   web_session_id_ = web_session_id;
   return adapter_->RegisterSession(web_session_id_,
                                    weak_ptr_factory_.GetWeakPtr())
              ? blink::WebContentDecryptionModuleResult::NewSession
              : blink::WebContentDecryptionModuleResult::SessionAlreadyExists;
 }
 
 }  // namespace content