Rename media::interfaces to media::mojom.

media/mojo/services/mojo_cdm.cc

 // Copyright 2014 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/mojo/services/mojo_cdm.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "media/base/cdm_context.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/cdm_promise.h"
 #include "media/mojo/common/media_type_converters.h"
 #include "media/mojo/interfaces/decryptor.mojom.h"
 #include "media/mojo/services/mojo_decryptor.h"
 #include "services/shell/public/cpp/connect.h"
 #include "services/shell/public/interfaces/interface_provider.mojom.h"
 #include "url/gurl.h"
 
 namespace media {
 
 template <typename PromiseType>
 static void RejectPromise(std::unique_ptr<PromiseType> promise,
-                          interfaces::CdmPromiseResultPtr result) {
+                          mojom::CdmPromiseResultPtr result) {
   promise->reject(static_cast<MediaKeys::Exception>(result->exception),
                   result->system_code, result->error_message);
 }
 
 // static
 void MojoCdm::Create(
     const std::string& key_system,
     const GURL& security_origin,
     const media::CdmConfig& cdm_config,
-    interfaces::ContentDecryptionModulePtr remote_cdm,
+    mojom::ContentDecryptionModulePtr remote_cdm,
     const media::SessionMessageCB& session_message_cb,
     const media::SessionClosedCB& session_closed_cb,
     const media::LegacySessionErrorCB& legacy_session_error_cb,
     const media::SessionKeysChangeCB& session_keys_change_cb,
     const media::SessionExpirationUpdateCB& session_expiration_update_cb,
     const media::CdmCreatedCB& cdm_created_cb) {
   scoped_refptr<MojoCdm> mojo_cdm(
       new MojoCdm(std::move(remote_cdm), session_message_cb, session_closed_cb,
                   legacy_session_error_cb, session_keys_change_cb,
                   session_expiration_update_cb));
 
   // |mojo_cdm| ownership is passed to the promise.
   std::unique_ptr<CdmInitializedPromise> promise(
       new CdmInitializedPromise(cdm_created_cb, mojo_cdm));
 
   mojo_cdm->InitializeCdm(key_system, security_origin, cdm_config,
                           std::move(promise));
 }
 
-MojoCdm::MojoCdm(interfaces::ContentDecryptionModulePtr remote_cdm,
+MojoCdm::MojoCdm(mojom::ContentDecryptionModulePtr remote_cdm,
                  const SessionMessageCB& session_message_cb,
                  const SessionClosedCB& session_closed_cb,
                  const LegacySessionErrorCB& legacy_session_error_cb,
                  const SessionKeysChangeCB& session_keys_change_cb,
                  const SessionExpirationUpdateCB& session_expiration_update_cb)
     : remote_cdm_(std::move(remote_cdm)),
       binding_(this),
       cdm_id_(CdmContext::kInvalidCdmId),
       session_message_cb_(session_message_cb),
       session_closed_cb_(session_closed_cb),
@@ skipping 44 matching lines @@
     return;
   }
 
   // Otherwise, set an error handler to catch the connection error.
   remote_cdm_.set_connection_error_handler(
       base::Bind(&MojoCdm::OnConnectionError, base::Unretained(this)));
 
   pending_init_promise_ = std::move(promise);
 
   remote_cdm_->Initialize(
-      key_system, security_origin.spec(),
-      interfaces::CdmConfig::From(cdm_config),
+      key_system, security_origin.spec(), mojom::CdmConfig::From(cdm_config),
       base::Bind(&MojoCdm::OnCdmInitialized, base::Unretained(this)));
 }
 
 void MojoCdm::OnConnectionError() {
   LOG(ERROR) << "Remote CDM connection error.";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // We only handle initial connection error.
   if (!pending_init_promise_)
     return;
@@ skipping 16 matching lines @@
 
 void MojoCdm::CreateSessionAndGenerateRequest(
     SessionType session_type,
     EmeInitDataType init_data_type,
     const std::vector<uint8_t>& init_data,
     std::unique_ptr<NewSessionCdmPromise> promise) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   remote_cdm_->CreateSessionAndGenerateRequest(
-      static_cast<interfaces::ContentDecryptionModule::SessionType>(
-          session_type),
-      static_cast<interfaces::ContentDecryptionModule::InitDataType>(
-          init_data_type),
+      static_cast<mojom::ContentDecryptionModule::SessionType>(session_type),
+      static_cast<mojom::ContentDecryptionModule::InitDataType>(init_data_type),
       mojo::Array<uint8_t>::From(init_data),
       base::Bind(&MojoCdm::OnPromiseResult<std::string>, base::Unretained(this),
                  base::Passed(&promise)));
 }
 
 void MojoCdm::LoadSession(SessionType session_type,
                           const std::string& session_id,
                           std::unique_ptr<NewSessionCdmPromise> promise) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   remote_cdm_->LoadSession(
-      static_cast<interfaces::ContentDecryptionModule::SessionType>(
-          session_type),
+      static_cast<mojom::ContentDecryptionModule::SessionType>(session_type),
       session_id, base::Bind(&MojoCdm::OnPromiseResult<std::string>,
                              base::Unretained(this), base::Passed(&promise)));
 }
 
 void MojoCdm::UpdateSession(const std::string& session_id,
                             const std::vector<uint8_t>& response,
                             std::unique_ptr<SimpleCdmPromise> promise) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 46 matching lines @@
 }
 
 int MojoCdm::GetCdmId() const {
   base::AutoLock auto_lock(lock_);
   // Can be called on a different thread.
   DCHECK_NE(CdmContext::kInvalidCdmId, cdm_id_);
   return cdm_id_;
 }
 
 void MojoCdm::OnSessionMessage(const mojo::String& session_id,
-                               interfaces::CdmMessageType message_type,
+                               mojom::CdmMessageType message_type,
                                mojo::Array<uint8_t> message,
                                const mojo::String& legacy_destination_url) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   GURL verified_gurl = GURL(legacy_destination_url.get());
   if (!verified_gurl.is_valid() && !verified_gurl.is_empty()) {
     DLOG(WARNING) << "SessionMessage destination_url is invalid : "
                   << verified_gurl.possibly_invalid_spec();
     verified_gurl = GURL::EmptyGURL();  // Replace invalid destination_url.
   }
 
   session_message_cb_.Run(session_id,
                           static_cast<MediaKeys::MessageType>(message_type),
                           message.storage(), verified_gurl);
 }
 
 void MojoCdm::OnSessionClosed(const mojo::String& session_id) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   session_closed_cb_.Run(session_id);
 }
 
 void MojoCdm::OnLegacySessionError(const mojo::String& session_id,
-                                   interfaces::CdmException exception,
+                                   mojom::CdmException exception,
                                    uint32_t system_code,
                                    const mojo::String& error_message) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   legacy_session_error_cb_.Run(session_id,
                                static_cast<MediaKeys::Exception>(exception),
                                system_code, error_message);
 }
 
 void MojoCdm::OnSessionKeysChange(
     const mojo::String& session_id,
     bool has_additional_usable_key,
-    mojo::Array<interfaces::CdmKeyInformationPtr> keys_info) {
+    mojo::Array<mojom::CdmKeyInformationPtr> keys_info) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // TODO(jrummell): Handling resume playback should be done in the media
   // player, not in the Decryptors. http://crbug.com/413413.
   if (has_additional_usable_key) {
     base::AutoLock auto_lock(lock_);
     if (decryptor_) {
       DCHECK(decryptor_task_runner_);
       decryptor_task_runner_->PostTask(
@@ skipping 14 matching lines @@
 
 void MojoCdm::OnSessionExpirationUpdate(const mojo::String& session_id,
                                         double new_expiry_time_sec) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   session_expiration_update_cb_.Run(
       session_id, base::Time::FromDoubleT(new_expiry_time_sec));
 }
 
-void MojoCdm::OnCdmInitialized(interfaces::CdmPromiseResultPtr result,
+void MojoCdm::OnCdmInitialized(mojom::CdmPromiseResultPtr result,
                                int cdm_id,
-                               interfaces::DecryptorPtr decryptor) {
+                               mojom::DecryptorPtr decryptor) {
   DVLOG(2) << __FUNCTION__ << " cdm_id: " << cdm_id;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(pending_init_promise_);
 
   if (!result->success) {
     RejectPromise(std::move(pending_init_promise_), std::move(result));
     return;
   }
 
   {
@@ skipping 11 matching lines @@
   base::AutoLock auto_lock(lock_);
 
   DCHECK(decryptor_task_runner_);
   DCHECK(decryptor_task_runner_->BelongsToCurrentThread());
   DCHECK(decryptor_);
 
   decryptor_->OnKeyAdded();
 }
 
 }  // namespace media