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

chrome/browser/extensions/api/storage/settings_sync_unittest.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 <stddef.h>
+
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/memory/linked_ptr.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/api/storage/settings_sync_util.h"
 #include "chrome/browser/extensions/api/storage/sync_value_store_cache.h"
 #include "chrome/browser/extensions/api/storage/syncable_settings_storage.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread.h"
 #include "extensions/browser/api/storage/settings_test_util.h"
 #include "extensions/browser/api/storage/storage_frontend.h"
@@ skipping 135 matching lines @@
            extension_id << "/" << key << " (out of " << changes_.size() << ")";
     }
     return matching_changes[0];
   }
 
  private:
   SettingSyncDataList changes_;
   bool fail_all_requests_;
 };
 
-scoped_ptr<KeyedService> MockExtensionSystemFactoryFunction(
+std::unique_ptr<KeyedService> MockExtensionSystemFactoryFunction(
     content::BrowserContext* context) {
-  return make_scoped_ptr(new MockExtensionSystem(context));
+  return base::WrapUnique(new MockExtensionSystem(context));
 }
 
-scoped_ptr<KeyedService> BuildEventRouter(content::BrowserContext* profile) {
-  return make_scoped_ptr(new extensions::EventRouter(profile, nullptr));
+std::unique_ptr<KeyedService> BuildEventRouter(
+    content::BrowserContext* profile) {
+  return base::WrapUnique(new extensions::EventRouter(profile, nullptr));
 }
 
 }  // namespace
 
 class ExtensionSettingsSyncTest : public testing::Test {
  public:
   ExtensionSettingsSyncTest()
       : ui_thread_(BrowserThread::UI, base::MessageLoop::current()),
         file_thread_(BrowserThread::FILE, base::MessageLoop::current()),
         storage_factory_(new TestValueStoreFactory()),
@@ skipping 66 matching lines @@
     return static_cast<TestingValueStore*>(
         storage_factory_->GetExisting(extension_id));
   }
 
   // Need these so that the DCHECKs for running on FILE or UI threads pass.
   base::MessageLoop message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
 
   base::ScopedTempDir temp_dir_;
-  scoped_ptr<TestingProfile> profile_;
-  scoped_ptr<StorageFrontend> frontend_;
+  std::unique_ptr<TestingProfile> profile_;
+  std::unique_ptr<StorageFrontend> frontend_;
   scoped_refptr<TestValueStoreFactory> storage_factory_;
-  scoped_ptr<MockSyncChangeProcessor> sync_processor_;
-  scoped_ptr<syncer::SyncChangeProcessorWrapperForTest> sync_processor_wrapper_;
+  std::unique_ptr<MockSyncChangeProcessor> sync_processor_;
+  std::unique_ptr<syncer::SyncChangeProcessorWrapperForTest>
+      sync_processor_wrapper_;
 };
 
 // Get a semblance of coverage for both EXTENSION_SETTINGS and APP_SETTINGS
 // sync by roughly alternative which one to test.
 
 TEST_F(ExtensionSettingsSyncTest, NoDataDoesNotInvokeSync) {
   syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Manifest::Type type = Manifest::TYPE_EXTENSION;
 
   EXPECT_EQ(0u, GetAllSyncData(model_type).size());
 
   // Have one extension created before sync is set up, the other created after.
   AddExtensionAndGetStorage("s1", type);
   EXPECT_EQ(0u, GetAllSyncData(model_type).size());
 
   GetSyncableService(model_type)
       ->MergeDataAndStartSyncing(
           model_type, syncer::SyncDataList(),
           std::move(sync_processor_wrapper_),
-          make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+          base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   AddExtensionAndGetStorage("s2", type);
   EXPECT_EQ(0u, GetAllSyncData(model_type).size());
 
   GetSyncableService(model_type)->StopSyncing(model_type);
 
   EXPECT_EQ(0u, sync_processor_->changes().size());
   EXPECT_EQ(0u, GetAllSyncData(model_type).size());
 }
 
@@ skipping 20 matching lines @@
 
   syncer::SyncDataList sync_data;
   sync_data.push_back(settings_sync_util::CreateData(
       "s1", "foo", value1, model_type));
   sync_data.push_back(settings_sync_util::CreateData(
       "s2", "bar", value2, model_type));
 
   GetSyncableService(model_type)
       ->MergeDataAndStartSyncing(
           model_type, sync_data, std::move(sync_processor_wrapper_),
-          make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+          base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   // Already in sync, so no changes.
   EXPECT_EQ(0u, sync_processor_->changes().size());
 
   // Regression test: not-changing the synced value shouldn't result in a sync
   // change, and changing the synced value should result in an update.
   storage1->Set(DEFAULTS, "foo", value1);
   EXPECT_EQ(0u, sync_processor_->changes().size());
 
   storage1->Set(DEFAULTS, "foo", value2);
@@ skipping 16 matching lines @@
   ValueStore* storage1 = AddExtensionAndGetStorage("s1", type);
   ValueStore* storage2 = AddExtensionAndGetStorage("s2", type);
 
   storage1->Set(DEFAULTS, "foo", value1);
   storage2->Set(DEFAULTS, "bar", value2);
 
   GetSyncableService(model_type)
       ->MergeDataAndStartSyncing(
           model_type, syncer::SyncDataList(),
           std::move(sync_processor_wrapper_),
-          make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+          base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   // All settings should have been pushed to sync.
   EXPECT_EQ(2u, sync_processor_->changes().size());
   SettingSyncData* change = sync_processor_->GetOnlyChange("s1", "foo");
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD, change->change_type());
   EXPECT_TRUE(value1.Equals(&change->value()));
   change = sync_processor_->GetOnlyChange("s2", "bar");
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD, change->change_type());
   EXPECT_TRUE(value2.Equals(&change->value()));
 
@@ skipping 17 matching lines @@
   storage1->Set(DEFAULTS, "overwriteMe", value1);
 
   syncer::SyncDataList sync_data;
   sync_data.push_back(settings_sync_util::CreateData(
       "s1", "foo", value1, model_type));
   sync_data.push_back(settings_sync_util::CreateData(
       "s2", "bar", value2, model_type));
   GetSyncableService(model_type)
       ->MergeDataAndStartSyncing(
           model_type, sync_data, std::move(sync_processor_wrapper_),
-          make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+          base::WrapUnique(new syncer::SyncErrorFactoryMock()));
   expected1.Set("foo", value1.DeepCopy());
   expected2.Set("bar", value2.DeepCopy());
 
   ValueStore* storage2 = AddExtensionAndGetStorage("s2", type);
 
   // All changes should be local, so no sync changes.
   EXPECT_EQ(0u, sync_processor_->changes().size());
 
   // Sync settings should have been pushed to local settings.
   EXPECT_PRED_FORMAT2(SettingsEq, expected1, storage1->Get());
@@ skipping 21 matching lines @@
   storage1->Set(DEFAULTS, "foo", value1);
   expected1.Set("foo", value1.DeepCopy());
 
   syncer::SyncDataList sync_data;
   sync_data.push_back(settings_sync_util::CreateData(
       "s2", "bar", value2, model_type));
 
   GetSyncableService(model_type)
       ->MergeDataAndStartSyncing(
           model_type, sync_data, std::move(sync_processor_wrapper_),
-          make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+          base::WrapUnique(new syncer::SyncErrorFactoryMock()));
   expected2.Set("bar", value2.DeepCopy());
 
   // Make sync add some settings.
   syncer::SyncChangeList change_list;
   change_list.push_back(settings_sync_util::CreateAdd(
       "s1", "bar", value2, model_type));
   change_list.push_back(settings_sync_util::CreateAdd(
       "s2", "foo", value1, model_type));
   GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
   expected1.Set("bar", value2.DeepCopy());
@@ skipping 53 matching lines @@
 
   syncer::SyncDataList sync_data;
   sync_data.push_back(settings_sync_util::CreateData(
       "s3", "bar", value2, model_type));
   sync_data.push_back(settings_sync_util::CreateData(
       "s4", "bar", value2, model_type));
 
   GetSyncableService(model_type)
       ->MergeDataAndStartSyncing(
           model_type, sync_data, std::move(sync_processor_wrapper_),
-          make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+          base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   // Add something locally.
   storage1->Set(DEFAULTS, "bar", value2);
   storage2->Set(DEFAULTS, "bar", value2);
   storage3->Set(DEFAULTS, "foo", value1);
   storage4->Set(DEFAULTS, "foo", value1);
 
   SettingSyncData* change = sync_processor_->GetOnlyChange("s1", "bar");
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD, change->change_type());
   EXPECT_TRUE(value2.Equals(&change->value()));
@@ skipping 117 matching lines @@
 
   // Stop each separately, there should be no changes either time.
   syncer::SyncDataList sync_data;
   sync_data.push_back(settings_sync_util::CreateData(
       "s1", "foo", value1, syncer::EXTENSION_SETTINGS));
 
   GetSyncableService(syncer::EXTENSION_SETTINGS)
       ->MergeDataAndStartSyncing(
           syncer::EXTENSION_SETTINGS, sync_data,
           std::move(sync_processor_wrapper_),
-          make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+          base::WrapUnique(new syncer::SyncErrorFactoryMock()));
   GetSyncableService(syncer::EXTENSION_SETTINGS)->
       StopSyncing(syncer::EXTENSION_SETTINGS);
   EXPECT_EQ(0u, sync_processor_->changes().size());
 
   sync_data.clear();
   sync_data.push_back(settings_sync_util::CreateData(
       "s2", "bar", value2, syncer::APP_SETTINGS));
 
-  scoped_ptr<syncer::SyncChangeProcessorWrapperForTest> app_settings_delegate_(
-      new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
+  std::unique_ptr<syncer::SyncChangeProcessorWrapperForTest>
+      app_settings_delegate_(
+          new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
   GetSyncableService(syncer::APP_SETTINGS)
       ->MergeDataAndStartSyncing(
           syncer::APP_SETTINGS, sync_data, std::move(app_settings_delegate_),
-          make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+          base::WrapUnique(new syncer::SyncErrorFactoryMock()));
   GetSyncableService(syncer::APP_SETTINGS)->
       StopSyncing(syncer::APP_SETTINGS);
   EXPECT_EQ(0u, sync_processor_->changes().size());
 }
 
 TEST_F(ExtensionSettingsSyncTest, FailingStartSyncingDisablesSync) {
   syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Manifest::Type type = Manifest::TYPE_EXTENSION;
 
   base::StringValue fooValue("fooValue");
@@ skipping 10 matching lines @@
   GetExisting("bad")->set_status_code(ValueStore::CORRUPTION);
   {
     syncer::SyncDataList sync_data;
     sync_data.push_back(settings_sync_util::CreateData(
           "good", "foo", fooValue, model_type));
     sync_data.push_back(settings_sync_util::CreateData(
           "bad", "foo", fooValue, model_type));
     GetSyncableService(model_type)
         ->MergeDataAndStartSyncing(
             model_type, sync_data, std::move(sync_processor_wrapper_),
-            make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+            base::WrapUnique(new syncer::SyncErrorFactoryMock()));
   }
   GetExisting("bad")->set_status_code(ValueStore::OK);
 
   {
     base::DictionaryValue dict;
     dict.Set("foo", fooValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
     base::DictionaryValue dict;
@@ skipping 95 matching lines @@
 
   // Restarting sync should make bad start syncing again.
   sync_processor_->ClearChanges();
   GetSyncableService(model_type)->StopSyncing(model_type);
   sync_processor_wrapper_.reset(
       new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
   GetSyncableService(model_type)
       ->MergeDataAndStartSyncing(
           model_type, syncer::SyncDataList(),
           std::move(sync_processor_wrapper_),
-          make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+          base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   // Local settings will have been pushed to sync, since it's empty (in this
   // test; presumably it wouldn't be live, since we've been getting changes).
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             sync_processor_->GetOnlyChange("good", "foo")->change_type());
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             sync_processor_->GetOnlyChange("good", "bar")->change_type());
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             sync_processor_->GetOnlyChange("bad", "bar")->change_type());
   EXPECT_EQ(3u, sync_processor_->changes().size());
@@ skipping 47 matching lines @@
   // Unlike before, initially succeeding MergeDataAndStartSyncing.
   {
     syncer::SyncDataList sync_data;
     sync_data.push_back(settings_sync_util::CreateData(
           "good", "foo", fooValue, model_type));
     sync_data.push_back(settings_sync_util::CreateData(
           "bad", "foo", fooValue, model_type));
     GetSyncableService(model_type)
         ->MergeDataAndStartSyncing(
             model_type, sync_data, std::move(sync_processor_wrapper_),
-            make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+            base::WrapUnique(new syncer::SyncErrorFactoryMock()));
   }
 
   EXPECT_EQ(0u, sync_processor_->changes().size());
 
   {
     base::DictionaryValue dict;
     dict.Set("foo", fooValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
@@ skipping 80 matching lines @@
     EXPECT_EQ(1u, all_sync_data.size());
     EXPECT_EQ("good/foo", syncer::SyncDataLocal(all_sync_data[0]).GetTag());
   }
   GetExisting("bad")->set_status_code(ValueStore::OK);
 
   // Sync shouldn't be disabled for good (nor bad -- but this is unimportant).
   GetSyncableService(model_type)
       ->MergeDataAndStartSyncing(
           model_type, syncer::SyncDataList(),
           std::move(sync_processor_wrapper_),
-          make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+          base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             sync_processor_->GetOnlyChange("good", "foo")->change_type());
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             sync_processor_->GetOnlyChange("bad", "foo")->change_type());
   EXPECT_EQ(2u, sync_processor_->changes().size());
 
   sync_processor_->ClearChanges();
   good->Set(DEFAULTS, "bar", barValue);
   bad->Set(DEFAULTS, "bar", barValue);
@@ skipping 18 matching lines @@
   good->Set(DEFAULTS, "foo", fooValue);
   bad->Set(DEFAULTS, "foo", fooValue);
 
   // good will successfully push foo:fooValue to sync, but bad will fail to
   // get them so won't.
   GetExisting("bad")->set_status_code(ValueStore::CORRUPTION);
   GetSyncableService(model_type)
       ->MergeDataAndStartSyncing(
           model_type, syncer::SyncDataList(),
           std::move(sync_processor_wrapper_),
-          make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+          base::WrapUnique(new syncer::SyncErrorFactoryMock()));
   GetExisting("bad")->set_status_code(ValueStore::OK);
 
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             sync_processor_->GetOnlyChange("good", "foo")->change_type());
   EXPECT_EQ(1u, sync_processor_->changes().size());
 
   // bad should now be disabled for sync.
   sync_processor_->ClearChanges();
   good->Set(DEFAULTS, "bar", barValue);
   bad->Set(DEFAULTS, "bar", barValue);
@@ skipping 29 matching lines @@
   // Re-enabling sync without failing should cause the local changes from bad
   // to be pushed to sync successfully, as should future changes to bad.
   sync_processor_->ClearChanges();
   GetSyncableService(model_type)->StopSyncing(model_type);
   sync_processor_wrapper_.reset(
       new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
   GetSyncableService(model_type)
       ->MergeDataAndStartSyncing(
           model_type, syncer::SyncDataList(),
           std::move(sync_processor_wrapper_),
-          make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+          base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             sync_processor_->GetOnlyChange("good", "foo")->change_type());
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             sync_processor_->GetOnlyChange("good", "bar")->change_type());
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             sync_processor_->GetOnlyChange("bad", "foo")->change_type());
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             sync_processor_->GetOnlyChange("bad", "bar")->change_type());
   EXPECT_EQ(4u, sync_processor_->changes().size());
@@ skipping 20 matching lines @@
   ValueStore* bad = AddExtensionAndGetStorage("bad", type);
 
   // Only set bad; setting good will cause it to fail below.
   bad->Set(DEFAULTS, "foo", fooValue);
 
   sync_processor_->set_fail_all_requests(true);
   GetSyncableService(model_type)
       ->MergeDataAndStartSyncing(
           model_type, syncer::SyncDataList(),
           std::move(sync_processor_wrapper_),
-          make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+          base::WrapUnique(new syncer::SyncErrorFactoryMock()));
   sync_processor_->set_fail_all_requests(false);
 
   // Changes from good will be send to sync, changes from bad won't.
   sync_processor_->ClearChanges();
   good->Set(DEFAULTS, "foo", barValue);
   bad->Set(DEFAULTS, "foo", barValue);
 
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             sync_processor_->GetOnlyChange("good", "foo")->change_type());
   EXPECT_EQ(1u, sync_processor_->changes().size());
@@ skipping 22 matching lines @@
 
   // Restarting sync makes everything work again.
   sync_processor_->ClearChanges();
   GetSyncableService(model_type)->StopSyncing(model_type);
   sync_processor_wrapper_.reset(
       new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
   GetSyncableService(model_type)
       ->MergeDataAndStartSyncing(
           model_type, syncer::SyncDataList(),
           std::move(sync_processor_wrapper_),
-          make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+          base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             sync_processor_->GetOnlyChange("good", "foo")->change_type());
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             sync_processor_->GetOnlyChange("good", "bar")->change_type());
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             sync_processor_->GetOnlyChange("bad", "foo")->change_type());
   EXPECT_EQ(3u, sync_processor_->changes().size());
 
   sync_processor_->ClearChanges();
@@ skipping 14 matching lines @@
   base::StringValue fooValue("fooValue");
   base::StringValue barValue("barValue");
 
   ValueStore* good = AddExtensionAndGetStorage("good", type);
   ValueStore* bad = AddExtensionAndGetStorage("bad", type);
 
   GetSyncableService(model_type)
       ->MergeDataAndStartSyncing(
           model_type, syncer::SyncDataList(),
           std::move(sync_processor_wrapper_),
-          make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+          base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   // bad will fail to send changes.
   good->Set(DEFAULTS, "foo", fooValue);
   sync_processor_->set_fail_all_requests(true);
   bad->Set(DEFAULTS, "foo", fooValue);
   sync_processor_->set_fail_all_requests(false);
 
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             sync_processor_->GetOnlyChange("good", "foo")->change_type());
   EXPECT_EQ(1u, sync_processor_->changes().size());
@@ skipping 31 matching lines @@
 
   // Restarting sync makes everything work again.
   sync_processor_->ClearChanges();
   GetSyncableService(model_type)->StopSyncing(model_type);
   sync_processor_wrapper_.reset(
       new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
   GetSyncableService(model_type)
       ->MergeDataAndStartSyncing(
           model_type, syncer::SyncDataList(),
           std::move(sync_processor_wrapper_),
-          make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+          base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             sync_processor_->GetOnlyChange("good", "foo")->change_type());
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             sync_processor_->GetOnlyChange("good", "bar")->change_type());
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             sync_processor_->GetOnlyChange("bad", "foo")->change_type());
   EXPECT_EQ(3u, sync_processor_->changes().size());
 
   sync_processor_->ClearChanges();
@@ skipping 16 matching lines @@
   std::string string_10k;
   for (size_t i = 0; i < 10000; ++i) {
     string_10k.append("a");
   }
   base::StringValue large_value(string_10k);
 
   GetSyncableService(model_type)
       ->MergeDataAndStartSyncing(
           model_type, syncer::SyncDataList(),
           std::move(sync_processor_wrapper_),
-          make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+          base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   // Large local change rejected and doesn't get sent out.
   ValueStore* storage1 = AddExtensionAndGetStorage("s1", type);
   EXPECT_FALSE(
       storage1->Set(DEFAULTS, "large_value", large_value)->status().ok());
   EXPECT_EQ(0u, sync_processor_->changes().size());
 
   // Large incoming change should still get accepted.
   ValueStore* storage2 = AddExtensionAndGetStorage("s2", type);
   {
@@ skipping 15 matching lines @@
 }
 
 TEST_F(ExtensionSettingsSyncTest, Dots) {
   syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Manifest::Type type = Manifest::TYPE_EXTENSION;
 
   ValueStore* storage = AddExtensionAndGetStorage("ext", type);
 
   {
     syncer::SyncDataList sync_data_list;
-    scoped_ptr<base::Value> string_value(new base::StringValue("value"));
+    std::unique_ptr<base::Value> string_value(new base::StringValue("value"));
     sync_data_list.push_back(settings_sync_util::CreateData(
         "ext", "key.with.dot", *string_value, model_type));
 
     GetSyncableService(model_type)
         ->MergeDataAndStartSyncing(
             model_type, sync_data_list, std::move(sync_processor_wrapper_),
-            make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+            base::WrapUnique(new syncer::SyncErrorFactoryMock()));
   }
 
   // Test dots in keys that come from sync.
   {
     ValueStore::ReadResult data = storage->Get();
     ASSERT_TRUE(data->status().ok());
 
     base::DictionaryValue expected_data;
     expected_data.SetWithoutPathExpansion(
         "key.with.dot",
         new base::StringValue("value"));
     EXPECT_TRUE(base::Value::Equals(&expected_data, &data->settings()));
   }
 
   // Test dots in keys going to sync.
   {
-    scoped_ptr<base::Value> string_value(new base::StringValue("spot"));
+    std::unique_ptr<base::Value> string_value(new base::StringValue("spot"));
     storage->Set(DEFAULTS, "key.with.spot", *string_value);
 
     ASSERT_EQ(1u, sync_processor_->changes().size());
     SettingSyncData* sync_data = sync_processor_->changes()[0];
     EXPECT_EQ(syncer::SyncChange::ACTION_ADD, sync_data->change_type());
     EXPECT_EQ("ext", sync_data->extension_id());
     EXPECT_EQ("key.with.spot", sync_data->key());
     EXPECT_TRUE(sync_data->value().Equals(string_value.get()));
   }
 }
 
 // In other (frontend) tests, we assume that the result of GetStorage
 // is a pointer to the a Storage owned by a Frontend object, but for
 // the unlimitedStorage case, this might not be true. So, write the
 // tests in a "callback" style.  We should really rewrite all tests to
 // be asynchronous in this way.
 
 namespace {
 
 static void UnlimitedSyncStorageTestCallback(ValueStore* sync_storage) {
   // Sync storage should still run out after ~100K; the unlimitedStorage
   // permission can't apply to sync.
-  scoped_ptr<base::Value> kilobyte = util::CreateKilobyte();
+  std::unique_ptr<base::Value> kilobyte = util::CreateKilobyte();
   for (int i = 0; i < 100; ++i) {
     sync_storage->Set(ValueStore::DEFAULTS, base::IntToString(i), *kilobyte);
   }
 
   EXPECT_FALSE(sync_storage->Set(ValueStore::DEFAULTS, "WillError", *kilobyte)
                   ->status().ok());
 }
 
 static void UnlimitedLocalStorageTestCallback(ValueStore* local_storage) {
   // Local storage should never run out.
-  scoped_ptr<base::Value> megabyte = util::CreateMegabyte();
+  std::unique_ptr<base::Value> megabyte = util::CreateMegabyte();
   for (int i = 0; i < 7; ++i) {
     local_storage->Set(ValueStore::DEFAULTS, base::IntToString(i), *megabyte);
   }
 
   EXPECT_TRUE(local_storage->Set(ValueStore::DEFAULTS, "WontError", *megabyte)
                    ->status().ok());
 }
 
 }  // namespace
 
@@ skipping 17 matching lines @@
                             settings_namespace::SYNC,
                             base::Bind(&UnlimitedSyncStorageTestCallback));
   frontend_->RunWithStorage(extension,
                             settings_namespace::LOCAL,
                             base::Bind(&UnlimitedLocalStorageTestCallback));
 
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 }  // namespace extensions