Replace scoped_ptr with std::unique_ptr in //media.

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/memory/scoped_ptr.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/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"
 
@@ skipping 53 matching lines @@
 
   CdmAdapterTest() {}
   ~CdmAdapterTest() override {}
 
  protected:
   // Initializes the adapter. |expected_result| tests that the call succeeds
   // or generates an error.
   void InitializeAndExpect(base::FilePath library_path,
                            ExpectedResult expected_result) {
     CdmConfig cdm_config;  // default settings of false are sufficient.
-    scoped_ptr<CdmAllocator> allocator(new SimpleCdmAllocator());
+    std::unique_ptr<CdmAllocator> allocator(new SimpleCdmAllocator());
     CdmAdapter::Create(
         helper_.KeySystemName(), library_path, cdm_config, std::move(allocator),
         base::Bind(&CdmAdapterTest::CreateCdmFileIO, base::Unretained(this)),
         base::Bind(&CdmAdapterTest::OnSessionMessage, base::Unretained(this)),
         base::Bind(&CdmAdapterTest::OnSessionClosed, base::Unretained(this)),
         base::Bind(&CdmAdapterTest::OnLegacySessionError,
                    base::Unretained(this)),
         base::Bind(&CdmAdapterTest::OnSessionKeysChange,
                    base::Unretained(this)),
         base::Bind(&CdmAdapterTest::OnSessionExpirationUpdate,
@@ skipping 67 matching lines @@
     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
   // should be fulfilled.
-  scoped_ptr<SimpleCdmPromise> CreatePromise(ExpectedResult expected_result) {
+  std::unique_ptr<SimpleCdmPromise> CreatePromise(
+      ExpectedResult expected_result) {
     if (expected_result == SUCCESS) {
       EXPECT_CALL(*this, OnResolve());
     } else {
       EXPECT_CALL(*this, OnReject(_, _, IsNotEmpty()));
     }
 
-    scoped_ptr<SimpleCdmPromise> promise(new CdmCallbackPromise<>(
+    std::unique_ptr<SimpleCdmPromise> promise(new CdmCallbackPromise<>(
         base::Bind(&CdmAdapterTest::OnResolve, base::Unretained(this)),
         base::Bind(&CdmAdapterTest::OnReject, base::Unretained(this))));
     return promise;
   }
 
   // Create a promise to be used when a new session is created.
   // |expected_result| is used to indicate how the promise should be fulfilled.
-  scoped_ptr<NewSessionCdmPromise> CreateSessionPromise(
+  std::unique_ptr<NewSessionCdmPromise> CreateSessionPromise(
       ExpectedResult expected_result) {
     if (expected_result == SUCCESS) {
       EXPECT_CALL(*this, OnResolveWithSession(_))
           .WillOnce(SaveArg<0>(&session_id_));
     } else {
       EXPECT_CALL(*this, OnReject(_, _, IsNotEmpty()));
     }
 
-    scoped_ptr<NewSessionCdmPromise> promise(
+    std::unique_ptr<NewSessionCdmPromise> promise(
         new CdmCallbackPromise<std::string>(
             base::Bind(&CdmAdapterTest::OnResolveWithSession,
                        base::Unretained(this)),
             base::Bind(&CdmAdapterTest::OnReject, base::Unretained(this))));
     return promise;
   }
 
   void RunUntilIdle() { message_loop_.RunUntilIdle(); }
 
   std::unique_ptr<CdmFileIO> CreateCdmFileIO(cdm::FileIOClient* client) {
@@ skipping 113 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