media: Rename MediaKeys to ContentDecryptionModule

media/blink/cdm_session_adapter.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/blink/cdm_session_adapter.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 73 matching lines @@
 }
 
 void CdmSessionAdapter::UnregisterSession(const std::string& session_id) {
   DCHECK(base::ContainsKey(sessions_, session_id));
   sessions_.erase(session_id);
 }
 
 void CdmSessionAdapter::InitializeNewSession(
     EmeInitDataType init_data_type,
     const std::vector<uint8_t>& init_data,
-    MediaKeys::SessionType session_type,
+    ContentDecryptionModule::SessionType session_type,
     std::unique_ptr<NewSessionCdmPromise> promise) {
   cdm_->CreateSessionAndGenerateRequest(session_type, init_data_type, init_data,
                                         std::move(promise));
 }
 
 void CdmSessionAdapter::LoadSession(
-    MediaKeys::SessionType session_type,
+    ContentDecryptionModule::SessionType session_type,
     const std::string& session_id,
     std::unique_ptr<NewSessionCdmPromise> promise) {
   cdm_->LoadSession(session_type, session_id, std::move(promise));
 }
 
 void CdmSessionAdapter::UpdateSession(
     const std::string& session_id,
     const std::vector<uint8_t>& response,
     std::unique_ptr<SimpleCdmPromise> promise) {
   cdm_->UpdateSession(session_id, response, std::move(promise));
 }
 
 void CdmSessionAdapter::CloseSession(
     const std::string& session_id,
     std::unique_ptr<SimpleCdmPromise> promise) {
   cdm_->CloseSession(session_id, std::move(promise));
 }
 
 void CdmSessionAdapter::RemoveSession(
     const std::string& session_id,
     std::unique_ptr<SimpleCdmPromise> promise) {
   cdm_->RemoveSession(session_id, std::move(promise));
 }
 
-scoped_refptr<MediaKeys> CdmSessionAdapter::GetCdm() {
+scoped_refptr<ContentDecryptionModule> CdmSessionAdapter::GetCdm() {
   return cdm_;
 }
 
 const std::string& CdmSessionAdapter::GetKeySystem() const {
   return key_system_;
 }
 
 const std::string& CdmSessionAdapter::GetKeySystemUMAPrefix() const {
   DCHECK(!key_system_uma_prefix_.empty());
   return key_system_uma_prefix_;
 }
 
-void CdmSessionAdapter::OnCdmCreated(const std::string& key_system,
-                                     base::TimeTicks start_time,
-                                     const scoped_refptr<MediaKeys>& cdm,
-                                     const std::string& error_message) {
+void CdmSessionAdapter::OnCdmCreated(
+    const std::string& key_system,
+    base::TimeTicks start_time,
+    const scoped_refptr<ContentDecryptionModule>& cdm,
+    const std::string& error_message) {
   DVLOG(2) << __func__ << ": "
            << (cdm ? "success" : "failure (" + error_message + ")");
   DCHECK(!cdm_);
 
   TRACE_EVENT_ASYNC_END2("media", "CdmSessionAdapter::CreateCdm", trace_id_,
                          "success", (cdm ? "true" : "false"), "error_message",
                          error_message);
 
   if (!cdm) {
     cdm_created_result_->completeWithError(
@@ skipping 10 matching lines @@
   // Only report time for successful CDM creation.
   ReportTimeToCreateCdmUMA(base::TimeTicks::Now() - start_time);
 
   cdm_ = cdm;
 
   cdm_created_result_->completeWithContentDecryptionModule(
       new WebContentDecryptionModuleImpl(this));
   cdm_created_result_.reset();
 }
 
-void CdmSessionAdapter::OnSessionMessage(const std::string& session_id,
-                                         MediaKeys::MessageType message_type,
-                                         const std::vector<uint8_t>& message) {
+void CdmSessionAdapter::OnSessionMessage(
+    const std::string& session_id,
+    ContentDecryptionModule::MessageType message_type,
+    const std::vector<uint8_t>& message) {
   WebContentDecryptionModuleSessionImpl* session = GetSession(session_id);
   DLOG_IF(WARNING, !session) << __func__ << " for unknown session "
                              << session_id;
   if (session)
     session->OnSessionMessage(message_type, message);
 }
 
 void CdmSessionAdapter::OnSessionKeysChange(const std::string& session_id,
                                             bool has_additional_usable_key,
                                             CdmKeysInfo keys_info) {
@@ skipping 35 matching lines @@
   // Note: This leaks memory, which is expected behavior.
   base::HistogramBase* histogram = base::Histogram::FactoryTimeGet(
       GetKeySystemUMAPrefix() + kTimeToCreateCdmUMAName,
       base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromSeconds(10),
       50, base::HistogramBase::kUmaTargetedHistogramFlag);
 
   histogram->AddTime(time);
 }
 
 }  // namespace media