Convert //chrome/browser/chromeos from scoped_ptr to std::unique_ptr

chrome/browser/chromeos/extensions/external_cache_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 "chrome/browser/chromeos/extensions/external_cache.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 122 matching lines @@
 
   void AddInstalledExtension(const std::string& id,
                              const std::string& version) {
     installed_extensions_[id] = version;
   }
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
 
   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
-  scoped_ptr<net::TestURLFetcherFactory> fetcher_factory_;
+  std::unique_ptr<net::TestURLFetcherFactory> fetcher_factory_;
 
-  scoped_ptr<base::SequencedWorkerPoolOwner> pool_owner_;
+  std::unique_ptr<base::SequencedWorkerPoolOwner> pool_owner_;
   scoped_refptr<base::SequencedTaskRunner> background_task_runner_;
 
   base::ScopedTempDir cache_dir_;
   base::ScopedTempDir temp_dir_;
-  scoped_ptr<base::DictionaryValue> prefs_;
+  std::unique_ptr<base::DictionaryValue> prefs_;
   std::map<std::string, std::string> installed_extensions_;
 
   ScopedTestDeviceSettingsService test_device_settings_service_;
   ScopedTestCrosSettings test_cros_settings_;
 
   DISALLOW_COPY_AND_ASSIGN(ExternalCacheTest);
 };
 
 TEST_F(ExternalCacheTest, Basic) {
   base::FilePath cache_dir(CreateCacheDir(false));
   ExternalCache external_cache(cache_dir, request_context_getter(),
       background_task_runner(), this, true, false);
 
-  scoped_ptr<base::DictionaryValue> prefs(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> prefs(new base::DictionaryValue);
   base::DictionaryValue* dict = CreateEntryWithUpdateUrl(true);
   prefs->Set(kTestExtensionId1, dict);
   CreateExtensionFile(cache_dir, kTestExtensionId1, "1");
   dict = CreateEntryWithUpdateUrl(true);
   prefs->Set(kTestExtensionId2, dict);
   prefs->Set(kTestExtensionId3, CreateEntryWithUpdateUrl(false));
   CreateExtensionFile(cache_dir, kTestExtensionId3, "3");
   prefs->Set(kTestExtensionId4, CreateEntryWithUpdateUrl(false));
 
   external_cache.UpdateExtensionsList(std::move(prefs));
@@ skipping 81 matching lines @@
 
   // Damaged file should be removed from disk.
   external_cache.OnDamagedFileDetected(
       GetExtensionFile(cache_dir, kTestExtensionId2, "2"));
   WaitForCompletion();
   EXPECT_EQ(provided_prefs()->size(), 3ul);
   EXPECT_FALSE(base::PathExists(
       GetExtensionFile(cache_dir, kTestExtensionId2, "2")));
 
   // Shutdown with callback OnExtensionListsUpdated that clears prefs.
-  scoped_ptr<base::DictionaryValue> empty(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> empty(new base::DictionaryValue);
   external_cache.Shutdown(
         base::Bind(&ExternalCacheTest::OnExtensionListsUpdated,
                    base::Unretained(this),
                    base::Unretained(empty.get())));
   WaitForCompletion();
   EXPECT_EQ(provided_prefs()->size(), 0ul);
 
   // After Shutdown directory shouldn't be touched.
   external_cache.OnDamagedFileDetected(
       GetExtensionFile(cache_dir, kTestExtensionId4, "4"));
   WaitForCompletion();
   EXPECT_TRUE(base::PathExists(
       GetExtensionFile(cache_dir, kTestExtensionId4, "4")));
 }
 
 TEST_F(ExternalCacheTest, PreserveInstalled) {
   base::FilePath cache_dir(CreateCacheDir(false));
   ExternalCache external_cache(cache_dir, request_context_getter(),
       background_task_runner(), this, true, false);
 
-  scoped_ptr<base::DictionaryValue> prefs(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> prefs(new base::DictionaryValue);
   prefs->Set(kTestExtensionId1, CreateEntryWithUpdateUrl(true));
   prefs->Set(kTestExtensionId2, CreateEntryWithUpdateUrl(true));
 
   AddInstalledExtension(kTestExtensionId1, "1");
 
   external_cache.UpdateExtensionsList(std::move(prefs));
   WaitForCompletion();
 
   ASSERT_TRUE(provided_prefs());
   EXPECT_EQ(provided_prefs()->size(), 1ul);
 
   // File not in cache but extension installed.
   const base::DictionaryValue* entry1 = NULL;
   ASSERT_TRUE(provided_prefs()->GetDictionary(kTestExtensionId1, &entry1));
   EXPECT_TRUE(entry1->HasKey(
       extensions::ExternalProviderImpl::kExternalUpdateUrl));
   EXPECT_FALSE(entry1->HasKey(
       extensions::ExternalProviderImpl::kExternalCrx));
   EXPECT_FALSE(entry1->HasKey(
       extensions::ExternalProviderImpl::kExternalVersion));
 }
 
 }  // namespace chromeos