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

chrome/browser/extensions/api/storage/settings_apitest.cc

 // Copyright (c) 2012 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 <utility>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
@@ skipping 110 matching lines @@
     base::MessageLoop::current()->RunUntilIdle();
     InitSyncWithSyncableService(sync_processor, GetSyncableService());
   }
 
   void SendChanges(const syncer::SyncChangeList& change_list) {
     base::MessageLoop::current()->RunUntilIdle();
     SendChangesToSyncableService(change_list, GetSyncableService());
   }
 
   void SetPolicies(const base::DictionaryValue& policies) {
-    scoped_ptr<policy::PolicyBundle> bundle(new policy::PolicyBundle());
+    std::unique_ptr<policy::PolicyBundle> bundle(new policy::PolicyBundle());
     policy::PolicyMap& policy_map = bundle->Get(policy::PolicyNamespace(
         policy::POLICY_DOMAIN_EXTENSIONS, kManagedStorageExtensionId));
     policy_map.LoadFrom(&policies, policy::POLICY_LEVEL_MANDATORY,
                         policy::POLICY_SCOPE_USER, policy::POLICY_SOURCE_CLOUD);
     policy_provider_.UpdatePolicy(std::move(bundle));
   }
 
  private:
   const Extension* MaybeLoadAndReplyWhenSatisfied(
       Namespace settings_namespace,
@@ skipping 33 matching lines @@
     message.SetString("action", action);
     message.SetBoolean("isFinalAction", is_final_action);
     std::string message_json;
     base::JSONWriter::Write(message, &message_json);
     return message_json;
   }
 
   void InitSyncWithSyncableService(
       syncer::SyncChangeProcessor* sync_processor,
       syncer::SyncableService* settings_service) {
-    EXPECT_FALSE(
-        settings_service->MergeDataAndStartSyncing(
-                              kModelType,
-                              syncer::SyncDataList(),
-                              scoped_ptr<syncer::SyncChangeProcessor>(
-                                  new syncer::SyncChangeProcessorWrapperForTest(
-                                      sync_processor)),
-                              scoped_ptr<syncer::SyncErrorFactory>(
-                                  new syncer::SyncErrorFactoryMock()))
-            .error()
-            .IsSet());
+    EXPECT_FALSE(settings_service
+                     ->MergeDataAndStartSyncing(
+                         kModelType, syncer::SyncDataList(),
+                         std::unique_ptr<syncer::SyncChangeProcessor>(
+                             new syncer::SyncChangeProcessorWrapperForTest(
+                                 sync_processor)),
+                         std::unique_ptr<syncer::SyncErrorFactory>(
+                             new syncer::SyncErrorFactoryMock()))
+                     .error()
+                     .IsSet());
   }
 
   void SendChangesToSyncableService(
       const syncer::SyncChangeList& change_list,
       syncer::SyncableService* settings_service) {
     EXPECT_FALSE(
         settings_service->ProcessSyncChanges(FROM_HERE, change_list).IsSet());
   }
 
  protected:
@@ skipping 265 matching lines @@
   ASSERT_EQ(base::Value::TYPE_LIST, list.type());
   dict = list.GetItems();
   ASSERT_TRUE(dict.valid());
   ASSERT_EQ(base::Value::TYPE_DICTIONARY, dict.type());
   ASSERT_TRUE(dict.GetProperty("anything").valid());
   EXPECT_EQ(base::Value::TYPE_INTEGER, dict.GetProperty("anything").type());
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest, ManagedStorage) {
   // Set policies for the test extension.
-  scoped_ptr<base::DictionaryValue> policy =
+  std::unique_ptr<base::DictionaryValue> policy =
       extensions::DictionaryBuilder()
           .Set("string-policy", "value")
           .Set("int-policy", -123)
           .Set("double-policy", 456e7)
           .SetBoolean("boolean-policy", true)
           .Set("list-policy", extensions::ListBuilder()
                                   .Append("one")
                                   .Append("two")
                                   .Append("three")
                                   .Build())
@@ skipping 17 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(ExtensionSettingsApiTest,
                        DISABLED_PRE_ManagedStorageEvents) {
   ResultCatcher catcher;
 
   // This test starts without any test extensions installed.
   EXPECT_FALSE(GetSingleLoadedExtension());
   message_.clear();
 
   // Set policies for the test extension.
-  scoped_ptr<base::DictionaryValue> policy = extensions::DictionaryBuilder()
-      .Set("constant-policy", "aaa")
-      .Set("changes-policy", "bbb")
-      .Set("deleted-policy", "ccc")
-      .Build();
+  std::unique_ptr<base::DictionaryValue> policy =
+      extensions::DictionaryBuilder()
+          .Set("constant-policy", "aaa")
+          .Set("changes-policy", "bbb")
+          .Set("deleted-policy", "ccc")
+          .Build();
   SetPolicies(*policy);
 
   ExtensionTestMessageListener ready_listener("ready", false);
   // Load the extension to install the event listener.
   const Extension* extension = LoadExtension(
       test_data_dir_.AppendASCII("settings/managed_storage_events"));
   ASSERT_TRUE(extension);
   // Wait until the extension sends the "ready" message.
   ASSERT_TRUE(ready_listener.WaitUntilSatisfied());
 
@@ skipping 30 matching lines @@
   // Disable the 'managed' namespace.
   StorageFrontend* frontend = StorageFrontend::Get(browser()->profile());
   frontend->DisableStorageForTesting(MANAGED);
   EXPECT_FALSE(frontend->IsStorageEnabled(MANAGED));
   // Now run the extension.
   ASSERT_TRUE(RunExtensionTest("settings/managed_storage_disabled"))
       << message_;
 }
 
 }  // namespace extensions