convert //chrome_elf to std::unique_ptr

chrome_elf/blacklist/test/blacklist_test.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 <stddef.h>
 
+#include <memory>
+
 #include "base/environment.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/i18n/case_conversion.h"
 #include "base/macros.h"
 #include "base/path_service.h"
 #include "base/scoped_native_library.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 92 matching lines @@
       EXPECT_TRUE(TestDll_RemoveDllFromBlacklist(uppercase_name.c_str()));
 
       // The blocked dll was removed, so the number of blocked dlls should
       // return to what it originally was.
       int num_blocked_dlls = 0;
       TestDll_SuccessfullyBlocked(NULL, &num_blocked_dlls);
       EXPECT_EQ(num_initially_blocked_, num_blocked_dlls);
     }
   }
 
-  scoped_ptr<base::win::RegKey> blacklist_registry_key_;
+  std::unique_ptr<base::win::RegKey> blacklist_registry_key_;
   registry_util::RegistryOverrideManager override_manager_;
 
   // The number of dlls initially blocked by the blacklist.
   int num_initially_blocked_;
 
  private:
   void SetUp() override {
     // Force an import from blacklist_test_main_dll.
     InitBlacklistTestDll();
     blacklist_registry_key_.reset(
@@ skipping 129 matching lines @@
       KEY_QUERY_VALUE | KEY_SET_VALUE);
   for (size_t i = 0; i < arraysize(test_data); ++i) {
     finch_blacklist_registry_key.WriteValue(test_data[i].dll_name,
                                             test_data[i].dll_name);
   }
 
   TestDll_AddDllsFromRegistryToBlacklist();
   CheckBlacklistedDllsNotLoaded();
 }
 
-void TestResetBeacon(scoped_ptr<base::win::RegKey>& key,
+void TestResetBeacon(std::unique_ptr<base::win::RegKey>& key,
                      DWORD input_state,
                      DWORD expected_output_state) {
   LONG result = key->WriteValue(blacklist::kBeaconState, input_state);
   EXPECT_EQ(ERROR_SUCCESS, result);
 
   EXPECT_TRUE(blacklist::ResetBeacon());
   DWORD blacklist_state = blacklist::BLACKLIST_STATE_MAX;
   result = key->ReadValueDW(blacklist::kBeaconState, &blacklist_state);
   EXPECT_EQ(ERROR_SUCCESS, result);
   EXPECT_EQ(expected_output_state, blacklist_state);
@@ skipping 59 matching lines @@
                                        &blacklist_state);
   EXPECT_EQ(blacklist_state, blacklist::BLACKLIST_SETUP_RUNNING);
 
   DWORD attempt_count = blacklist::kBeaconMaxAttempts;
   blacklist_registry_key_->ReadValueDW(blacklist::kBeaconAttemptCount,
                                        &attempt_count);
   EXPECT_EQ(static_cast<DWORD>(0), attempt_count);
 }
 
 }  // namespace