media: Use native CDM enum types in media mojo interfaces

media/mojo/clients/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/clients/mojo_cdm.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 10 matching lines @@
 #include "media/mojo/interfaces/decryptor.mojom.h"
 #include "services/service_manager/public/cpp/connect.h"
 #include "services/service_manager/public/interfaces/interface_provider.mojom.h"
 #include "url/gurl.h"
 
 namespace media {
 
 template <typename PromiseType>
 static void RejectPromise(std::unique_ptr<PromiseType> promise,
                           mojom::CdmPromiseResultPtr result) {
-  promise->reject(static_cast<MediaKeys::Exception>(result->exception),
-                  result->system_code, result->error_message);
+  promise->reject(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,
     mojom::ContentDecryptionModulePtr remote_cdm,
     const media::SessionMessageCB& session_message_cb,
     const media::SessionClosedCB& session_closed_cb,
@@ skipping 103 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<mojom::ContentDecryptionModule::SessionType>(session_type),
-      static_cast<mojom::ContentDecryptionModule::InitDataType>(init_data_type),
-      init_data, base::Bind(&MojoCdm::OnNewSessionCdmPromiseResult,
-                            base::Unretained(this), base::Passed(&promise)));
+      session_type, init_data_type, init_data,
+      base::Bind(&MojoCdm::OnNewSessionCdmPromiseResult, 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<mojom::ContentDecryptionModule::SessionType>(session_type),
-      session_id, base::Bind(&MojoCdm::OnNewSessionCdmPromiseResult,
-                             base::Unretained(this), base::Passed(&promise)));
+      session_type, session_id,
+      base::Bind(&MojoCdm::OnNewSessionCdmPromiseResult, 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());
 
   remote_cdm_->UpdateSession(
       session_id, response,
@@ 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 std::string& session_id,
-                               mojom::CdmMessageType message_type,
+                               MessageType message_type,
                                const std::vector<uint8_t>& message) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  session_message_cb_.Run(
-      session_id, static_cast<MediaKeys::MessageType>(message_type), message);
+  session_message_cb_.Run(session_id, message_type, message);
 }
 
 void MojoCdm::OnSessionClosed(const std::string& session_id) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   session_closed_cb_.Run(session_id);
 }
 
 void MojoCdm::OnSessionKeysChange(
@@ skipping 80 matching lines @@
     std::unique_ptr<NewSessionCdmPromise> promise,
     mojom::CdmPromiseResultPtr result,
     const std::string& session_id) {
   if (result->success)
     promise->resolve(session_id);
   else
     RejectPromise(std::move(promise), std::move(result));
 }
 
 }  // namespace media