media: Use native CDM enum types in media mojo interfaces

media/mojo/services/mojo_cdm_service.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_service.h"
 
 #include <map>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 109 matching lines @@
 
 void MojoCdmService::SetServerCertificate(
     const std::vector<uint8_t>& certificate_data,
     const SetServerCertificateCallback& callback) {
   DVLOG(2) << __FUNCTION__;
   cdm_->SetServerCertificate(certificate_data,
                              base::MakeUnique<SimpleMojoCdmPromise>(callback));
 }
 
 void MojoCdmService::CreateSessionAndGenerateRequest(
-    mojom::ContentDecryptionModule::SessionType session_type,
-    mojom::ContentDecryptionModule::InitDataType init_data_type,
+    SessionType session_type,
+    EmeInitDataType init_data_type,
     const std::vector<uint8_t>& init_data,
     const CreateSessionAndGenerateRequestCallback& callback) {
   DVLOG(2) << __FUNCTION__;
   cdm_->CreateSessionAndGenerateRequest(
-      static_cast<MediaKeys::SessionType>(session_type),
-      static_cast<EmeInitDataType>(init_data_type), init_data,
+      session_type, init_data_type, init_data,
       base::MakeUnique<NewSessionMojoCdmPromise>(callback));
 }
 
-void MojoCdmService::LoadSession(
-    mojom::ContentDecryptionModule::SessionType session_type,
-    const std::string& session_id,
-    const LoadSessionCallback& callback) {
+void MojoCdmService::LoadSession(SessionType session_type,
+                                 const std::string& session_id,
+                                 const LoadSessionCallback& callback) {
   DVLOG(2) << __FUNCTION__;
-  cdm_->LoadSession(static_cast<MediaKeys::SessionType>(session_type),
-                    session_id,
+  cdm_->LoadSession(session_type, session_id,
                     base::MakeUnique<NewSessionMojoCdmPromise>(callback));
 }
 
 void MojoCdmService::UpdateSession(const std::string& session_id,
                                    const std::vector<uint8_t>& response,
                                    const UpdateSessionCallback& callback) {
   DVLOG(2) << __FUNCTION__;
   cdm_->UpdateSession(
       session_id, response,
       std::unique_ptr<SimpleCdmPromise>(new SimpleMojoCdmPromise(callback)));
@@ skipping 19 matching lines @@
 
 void MojoCdmService::OnCdmCreated(const InitializeCallback& callback,
                                   const scoped_refptr<MediaKeys>& cdm,
                                   const std::string& error_message) {
   mojom::CdmPromiseResultPtr cdm_promise_result(mojom::CdmPromiseResult::New());
 
   // TODO(xhwang): This should not happen when KeySystemInfo is properly
   // populated. See http://crbug.com/469366
   if (!cdm || !context_) {
     cdm_promise_result->success = false;
-    cdm_promise_result->exception = mojom::CdmException::NOT_SUPPORTED_ERROR;
+    cdm_promise_result->exception = MediaKeys::Exception::NOT_SUPPORTED_ERROR;
     cdm_promise_result->system_code = 0;
     cdm_promise_result->error_message = error_message;
     callback.Run(std::move(cdm_promise_result), 0, nullptr);
     return;
   }
 
   cdm_ = cdm;
   cdm_id_ = next_cdm_id_++;
 
   context_->RegisterCdm(cdm_id_, this);
@@ skipping 14 matching lines @@
   DVLOG(1) << __FUNCTION__ << ": CDM successfully created with ID " << cdm_id_;
   cdm_promise_result->success = true;
   callback.Run(std::move(cdm_promise_result), cdm_id_,
                std::move(decryptor_service));
 }
 
 void MojoCdmService::OnSessionMessage(const std::string& session_id,
                                       MediaKeys::MessageType message_type,
                                       const std::vector<uint8_t>& message) {
   DVLOG(2) << __FUNCTION__ << "(" << message_type << ")";
-  client_->OnSessionMessage(
-      session_id, static_cast<mojom::CdmMessageType>(message_type), message);
+  client_->OnSessionMessage(session_id, message_type, message);
 }
 
 void MojoCdmService::OnSessionKeysChange(const std::string& session_id,
                                          bool has_additional_usable_key,
                                          CdmKeysInfo keys_info) {
   DVLOG(2) << __FUNCTION__
            << " has_additional_usable_key=" << has_additional_usable_key;
 
   std::vector<mojom::CdmKeyInformationPtr> keys_data;
   for (auto* key : keys_info)
@@ skipping 17 matching lines @@
 
 void MojoCdmService::OnDecryptorConnectionError() {
   DVLOG(2) << __FUNCTION__;
 
   // MojoDecryptorService has lost connectivity to it's client, so it can be
   // freed.
   decryptor_.reset();
 }
 
 }  // namespace media