Move MediaKeys::Exception to CdmPromise::Exception

media/remoting/rpc/proto_utils.cc

 // Copyright 2016 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/remoting/rpc/proto_utils.h"
 
 #include <algorithm>
 
 #include "base/big_endian.h"
 #include "base/logging.h"
@@ skipping 398 matching lines @@
                               CdmPromiseResult* result) {
   if (!promise_message.has_success())
     return false;
 
   bool success = promise_message.success();
   if (success) {
     *result = CdmPromiseResult::SuccessResult();
     return true;
   }
 
-  ::media::MediaKeys::Exception exception = ::media::MediaKeys::UNKNOWN_ERROR;
+  ::media::CdmPromise::Exception exception = ::media::CdmPromise::UNKNOWN_ERROR;
   uint32_t system_code = 0;
   std::string error_message;
 
-  exception = ToMediaMediaKeysException(promise_message.exception()).value();
+  exception = ToCdmPromiseException(promise_message.exception()).value();
   system_code = promise_message.system_code();
   error_message = promise_message.error_message();
   *result = CdmPromiseResult(exception, system_code, error_message);
   return true;
 }
 
 bool ConvertProtoToCdmPromiseWithCdmIdSessionId(const pb::RpcMessage& message,
                                                 CdmPromiseResult* result,
                                                 int* cdm_id,
                                                 std::string* session_id) {
   if (!message.has_cdm_promise_rpc())
     return false;
 
   const auto& promise_message = message.cdm_promise_rpc();
   if (!ConvertProtoToCdmPromise(promise_message, result))
     return false;
 
   if (cdm_id)
     *cdm_id = promise_message.cdm_id();
   if (session_id)
     *session_id = promise_message.session_id();
 
   return true;
 }
 
 //==============================================================================
 CdmPromiseResult::CdmPromiseResult()
-    : CdmPromiseResult(::media::MediaKeys::UNKNOWN_ERROR, 0, "") {}
+    : CdmPromiseResult(::media::CdmPromise::UNKNOWN_ERROR, 0, "") {}
 
-CdmPromiseResult::CdmPromiseResult(::media::MediaKeys::Exception exception,
+CdmPromiseResult::CdmPromiseResult(::media::CdmPromise::Exception exception,
                                    uint32_t system_code,
                                    std::string error_message)
     : success_(false),
       exception_(exception),
       system_code_(system_code),
       error_message_(error_message) {}
 
 CdmPromiseResult::CdmPromiseResult(const CdmPromiseResult& other) = default;
 
 CdmPromiseResult::~CdmPromiseResult() = default;
 
 CdmPromiseResult CdmPromiseResult::SuccessResult() {
-  CdmPromiseResult result(static_cast<::media::MediaKeys::Exception>(0), 0, "");
+  CdmPromiseResult result(static_cast<::media::CdmPromise::Exception>(0), 0,
+                          "");
   result.success_ = true;
   return result;
 }
 
 }  // namespace remoting
 }  // namespace media