media: Rename MediaKeys to ContentDecryptionModule

media/cdm/cdm_adapter_unittest.cc

 // Copyright 2015 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/cdm/cdm_adapter.h"
 
 #include <stdint.h>
 #include <memory>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "media/base/cdm_callback_promise.h"
 #include "media/base/cdm_key_information.h"
-#include "media/base/media_keys.h"
+#include "media/base/content_decryption_module.h"
 #include "media/base/mock_filters.h"
 #include "media/cdm/cdm_file_io.h"
 #include "media/cdm/external_clear_key_test_helper.h"
 #include "media/cdm/simple_cdm_allocator.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
@@ skipping 83 matching lines @@
   void CreateSessionAndExpect(EmeInitDataType data_type,
                               const std::vector<uint8_t>& key_id,
                               ExpectedResult expected_result) {
     DCHECK(!key_id.empty());
 
     if (expected_result == SUCCESS) {
       EXPECT_CALL(cdm_client_, OnSessionMessage(IsNotEmpty(), _, _));
     }
 
     adapter_->CreateSessionAndGenerateRequest(
-        MediaKeys::TEMPORARY_SESSION, data_type, key_id,
+        ContentDecryptionModule::TEMPORARY_SESSION, data_type, key_id,
         CreateSessionPromise(expected_result));
     RunUntilIdle();
   }
 
   // Loads the session specified by |session_id|. |expected_result| tests
   // that LoadSession() succeeds or generates an error.
   void LoadSessionAndExpect(const std::string& session_id,
                             ExpectedResult expected_result) {
     DCHECK(!session_id.empty());
     ASSERT_EQ(expected_result, FAILURE) << "LoadSession not supported.";
 
-    adapter_->LoadSession(MediaKeys::TEMPORARY_SESSION, session_id,
-                          CreateSessionPromise(expected_result));
+    adapter_->LoadSession(ContentDecryptionModule::TEMPORARY_SESSION,
+                          session_id, CreateSessionPromise(expected_result));
     RunUntilIdle();
   }
 
   // Updates the session specified by |session_id| with |key|. |expected_result|
   // tests that the update succeeds or generates an error. |new_key_expected|
   // is the expected parameter when the SessionKeysChange event happens.
   void UpdateSessionAndExpect(std::string session_id,
                               const std::string& key,
                               ExpectedResult expected_result,
                               bool new_key_expected) {
@@ skipping 11 matching lines @@
                             CreatePromise(expected_result));
     RunUntilIdle();
   }
 
   base::FilePath ExternalClearKeyLibrary() { return helper_.LibraryPath(); }
 
   std::string SessionId() { return session_id_; }
 
  private:
   void OnCdmCreated(ExpectedResult expected_result,
-                    const scoped_refptr<MediaKeys>& cdm,
+                    const scoped_refptr<ContentDecryptionModule>& cdm,
                     const std::string& error_message) {
     if (cdm) {
       EXPECT_EQ(expected_result, SUCCESS) << "CDM should not have loaded.";
       adapter_ = cdm;
     } else {
       EXPECT_EQ(expected_result, FAILURE) << error_message;
     }
   }
 
   // Create a promise. |expected_result| is used to indicate how the promise
@@ skipping 45 matching lines @@
                void(CdmPromise::Exception exception_code,
                     uint32_t system_code,
                     const std::string& error_message));
 
   StrictMock<MockCdmClient> cdm_client_;
 
   // Helper class to load/unload External Clear Key Library.
   ExternalClearKeyTestHelper helper_;
 
   // Keep track of the loaded CDM.
-  scoped_refptr<MediaKeys> adapter_;
+  scoped_refptr<ContentDecryptionModule> adapter_;
 
   // |session_id_| is the latest result of calling CreateSession().
   std::string session_id_;
 
   base::MessageLoop message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(CdmAdapterTest);
 };
 
 TEST_F(CdmAdapterTest, Initialize) {
@@ skipping 61 matching lines @@
 TEST_F(CdmAdapterTest, UpdateSessionWithBadData) {
   InitializeAndExpect(ExternalClearKeyLibrary(), SUCCESS);
 
   std::vector<uint8_t> key_id(kKeyId, kKeyId + arraysize(kKeyId));
   CreateSessionAndExpect(EmeInitDataType::WEBM, key_id, SUCCESS);
 
   UpdateSessionAndExpect(SessionId(), "random data", FAILURE, true);
 }
 
 }  // namespace media