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

media/cdm/aes_decryptor_unittest.cc

 // Copyright 2013 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/aes_decryptor.h"
 
 #include <stdint.h>
 #include <memory>
 #include <string>
 #include <vector>
@@ skipping 25 matching lines @@
 using ::testing::IsNull;
 using ::testing::NotNull;
 using ::testing::SaveArg;
 using ::testing::StrNe;
 using ::testing::Unused;
 
 MATCHER(IsEmpty, "") { return arg.empty(); }
 MATCHER(IsNotEmpty, "") { return !arg.empty(); }
 MATCHER(IsJSONDictionary, "") {
   std::string result(arg.begin(), arg.end());
-  scoped_ptr<base::Value> root(base::JSONReader().ReadToValue(result));
+  std::unique_ptr<base::Value> root(base::JSONReader().ReadToValue(result));
   return (root.get() && root->GetType() == base::Value::TYPE_DICTIONARY);
 }
 
 namespace media {
 
 const uint8_t kOriginalData[] = "Original subsample data.";
 const int kOriginalDataSize = 24;
 
 // In the examples below, 'k'(key) has to be 16 bytes, and will always require
 // 2 bytes of padding. 'kid'(keyid) is variable length, and may require 0, 1,
@@ skipping 139 matching lines @@
     const std::vector<SubsampleEntry>& subsample_entries) {
   DCHECK(!data.empty());
   scoped_refptr<DecoderBuffer> encrypted_buffer(new DecoderBuffer(data.size()));
   memcpy(encrypted_buffer->writable_data(), &data[0], data.size());
   CHECK(encrypted_buffer.get());
   std::string key_id_string(
       reinterpret_cast<const char*>(key_id.empty() ? NULL : &key_id[0]),
       key_id.size());
   std::string iv_string(
       reinterpret_cast<const char*>(iv.empty() ? NULL : &iv[0]), iv.size());
-  encrypted_buffer->set_decrypt_config(scoped_ptr<DecryptConfig>(
+  encrypted_buffer->set_decrypt_config(std::unique_ptr<DecryptConfig>(
       new DecryptConfig(key_id_string, iv_string, subsample_entries)));
   return encrypted_buffer;
 }
 
 enum ExpectedResult { RESOLVED, REJECTED };
 
 // These tests only test decryption logic (no decoding). Parameter to this
 // test specifies how the CDM should be loaded.
 //  "AesDecryptor" - use AesDecryptor directly.
 //  "CdmAdapter" - load ExternalClearKey using CdmAdapter.
@@ skipping 23 matching lines @@
                                       base::Unretained(this)),
                            base::Bind(&AesDecryptorTest::OnSessionClosed,
                                       base::Unretained(this)),
                            base::Bind(&AesDecryptorTest::OnSessionKeysChange,
                                       base::Unretained(this))),
           std::string());
     } else if (GetParam() == "CdmAdapter") {
       CdmConfig cdm_config;  // default settings of false are sufficient.
 
       helper_.reset(new ExternalClearKeyTestHelper());
-      scoped_ptr<CdmAllocator> allocator(new SimpleCdmAllocator());
+      std::unique_ptr<CdmAllocator> allocator(new SimpleCdmAllocator());
       CdmAdapter::Create(
           helper_->KeySystemName(), helper_->LibraryPath(), cdm_config,
           std::move(allocator), base::Bind(&AesDecryptorTest::CreateCdmFileIO,
                                            base::Unretained(this)),
           base::Bind(&AesDecryptorTest::OnSessionMessage,
                      base::Unretained(this)),
           base::Bind(&AesDecryptorTest::OnSessionClosed,
                      base::Unretained(this)),
           base::Bind(&AesDecryptorTest::OnLegacySessionError,
                      base::Unretained(this)),
@@ skipping 31 matching lines @@
   }
 
   void OnReject(ExpectedResult expected_result,
                 MediaKeys::Exception exception_code,
                 uint32_t system_code,
                 const std::string& error_message) {
     EXPECT_EQ(expected_result, REJECTED)
         << "Unexpectedly rejected with message: " << error_message;
   }
 
-  scoped_ptr<SimpleCdmPromise> CreatePromise(ExpectedResult expected_result) {
-    scoped_ptr<SimpleCdmPromise> promise(
-        new CdmCallbackPromise<>(base::Bind(&AesDecryptorTest::OnResolve,
-                                            base::Unretained(this),
-                                            expected_result),
-                                 base::Bind(&AesDecryptorTest::OnReject,
-                                            base::Unretained(this),
-                                            expected_result)));
+  std::unique_ptr<SimpleCdmPromise> CreatePromise(
+      ExpectedResult expected_result) {
+    std::unique_ptr<SimpleCdmPromise> promise(new CdmCallbackPromise<>(
+        base::Bind(&AesDecryptorTest::OnResolve, base::Unretained(this),
+                   expected_result),
+        base::Bind(&AesDecryptorTest::OnReject, base::Unretained(this),
+                   expected_result)));
     return promise;
   }
 
-  scoped_ptr<NewSessionCdmPromise> CreateSessionPromise(
+  std::unique_ptr<NewSessionCdmPromise> CreateSessionPromise(
       ExpectedResult expected_result) {
-    scoped_ptr<NewSessionCdmPromise> promise(
+    std::unique_ptr<NewSessionCdmPromise> promise(
         new CdmCallbackPromise<std::string>(
             base::Bind(&AesDecryptorTest::OnResolveWithSession,
-                       base::Unretained(this),
-                       expected_result),
-            base::Bind(&AesDecryptorTest::OnReject,
-                       base::Unretained(this),
+                       base::Unretained(this), expected_result),
+            base::Bind(&AesDecryptorTest::OnReject, base::Unretained(this),
                        expected_result)));
     return promise;
   }
 
   // Creates a new session using |key_id|. Returns the session ID.
   std::string CreateSession(const std::vector<uint8_t>& key_id) {
     DCHECK(!key_id.empty());
     EXPECT_CALL(*this, OnSessionMessage(IsNotEmpty(), _, IsJSONDictionary(),
                                         GURL::EmptyGURL()));
     cdm_->CreateSessionAndGenerateRequest(MediaKeys::TEMPORARY_SESSION,
@@ skipping 147 matching lines @@
                void(const std::string& session_id,
                     const base::Time& new_expiry_time));
 
   scoped_refptr<MediaKeys> cdm_;
   Decryptor* decryptor_;
   Decryptor::DecryptCB decrypt_cb_;
   std::string session_id_;
   CdmKeysInfo keys_info_;
 
   // Helper class to load/unload External Clear Key Library, if necessary.
-  scoped_ptr<ExternalClearKeyTestHelper> helper_;
+  std::unique_ptr<ExternalClearKeyTestHelper> helper_;
 
   base::MessageLoop message_loop_;
 
   // Constants for testing.
   const std::vector<uint8_t> original_data_;
   const std::vector<uint8_t> encrypted_data_;
   const std::vector<uint8_t> subsample_encrypted_data_;
   const std::vector<uint8_t> key_id_;
   const std::vector<uint8_t> iv_;
   const std::vector<SubsampleEntry> normal_subsample_entries_;
@@ skipping 523 matching lines @@
 INSTANTIATE_TEST_CASE_P(CdmAdapter,
                         AesDecryptorTest,
                         testing::Values("CdmAdapter"));
 #endif
 
 // TODO(jrummell): Once MojoCdm/MojoCdmService/MojoDecryptor/
 // MojoDecryptorService are implemented, add a third version that tests the
 // CDM via mojo.
 
 }  // namespace media