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

chrome/browser/extensions/extension_service_sync_unittest.cc

 // Copyright 2015 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 <map>
+#include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/field_trial.h"
 #include "base/test/mock_entropy_provider.h"
 #include "chrome/browser/extensions/component_loader.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_service_test_with_install.h"
 #include "chrome/browser/extensions/extension_sync_data.h"
 #include "chrome/browser/extensions/extension_sync_service.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/updater/extension_updater.h"
@@ skipping 75 matching lines @@
   // the FakeSyncChangeProcessor's SyncDataList as a map keyed by extension
   // id.
   syncer::SyncError ProcessSyncChanges(
       const tracked_objects::Location& from_here,
       const syncer::SyncChangeList& change_list) override {
     syncer::FakeSyncChangeProcessor::ProcessSyncChanges(from_here, change_list);
     for (const auto& change : change_list) {
       syncer::SyncData sync_data = change.sync_data();
       EXPECT_EQ(expected_type_, sync_data.GetDataType());
 
-      scoped_ptr<ExtensionSyncData> modified =
+      std::unique_ptr<ExtensionSyncData> modified =
           ExtensionSyncData::CreateFromSyncData(sync_data);
 
       // Start by removing any existing entry for this extension id.
       syncer::SyncDataList& data_list = data();
       for (auto iter = data_list.begin(); iter != data_list.end(); ++iter) {
-        scoped_ptr<ExtensionSyncData> existing =
+        std::unique_ptr<ExtensionSyncData> existing =
             ExtensionSyncData::CreateFromSyncData(*iter);
         if (existing->id() == modified->id()) {
           data_list.erase(iter);
           break;
         }
       }
 
       // Now add in the new data for this id, if appropriate.
       if (change.change_type() == SyncChange::ACTION_ADD ||
           change.change_type() == SyncChange::ACTION_UPDATE) {
         data_list.push_back(sync_data);
       } else if (change.change_type() != SyncChange::ACTION_DELETE) {
         ADD_FAILURE() << "Unexpected change type " << change.change_type();
       }
     }
     return syncer::SyncError();
   }
 
   // We override this to help catch the error of trying to use a single
   // StatefulChangeProcessor to process changes for both extensions and apps
   // sync data.
   syncer::SyncDataList GetAllSyncData(syncer::ModelType type) const override {
     EXPECT_EQ(expected_type_, type);
     return FakeSyncChangeProcessor::GetAllSyncData(type);
   }
 
   // This is a helper to vend a wrapped version of this object suitable for
   // passing in to MergeDataAndStartSyncing, which takes a
-  // scoped_ptr<SyncChangeProcessor>, since in tests we typically don't want to
+  // std::unique_ptr<SyncChangeProcessor>, since in tests we typically don't
+  // want to
   // give up ownership of a local change processor.
-  scoped_ptr<syncer::SyncChangeProcessor> GetWrapped() {
-    return make_scoped_ptr(new syncer::SyncChangeProcessorWrapperForTest(this));
+  std::unique_ptr<syncer::SyncChangeProcessor> GetWrapped() {
+    return base::WrapUnique(
+        new syncer::SyncChangeProcessorWrapperForTest(this));
   }
 
  protected:
   // The expected ModelType of changes that this processor will see.
   syncer::ModelType expected_type_;
 
   DISALLOW_COPY_AND_ASSIGN(StatefulChangeProcessor);
 };
 
 }  // namespace
 
 class ExtensionServiceSyncTest
     : public extensions::ExtensionServiceTestWithInstall {
  public:
   void MockSyncStartFlare(bool* was_called,
                           syncer::ModelType* model_type_passed_in,
                           syncer::ModelType model_type) {
     *was_called = true;
     *model_type_passed_in = model_type;
   }
 
   // Helper to call MergeDataAndStartSyncing with no server data and dummy
   // change processor / error factory.
   void StartSyncing(syncer::ModelType type) {
     ASSERT_TRUE(type == syncer::EXTENSIONS || type == syncer::APPS);
     extension_sync_service()->MergeDataAndStartSyncing(
         type, syncer::SyncDataList(),
-        make_scoped_ptr(new syncer::FakeSyncChangeProcessor()),
-        make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+        base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
+        base::WrapUnique(new syncer::SyncErrorFactoryMock()));
   }
 
  protected:
   // Paths to some of the fake extensions.
   base::FilePath good0_path() {
     return data_dir()
         .AppendASCII("good")
         .AppendASCII("Extensions")
         .AppendASCII(good0)
         .AppendASCII("1.0.0.0");
@@ skipping 72 matching lines @@
   EXPECT_TRUE(flare_was_called);
   EXPECT_EQ(syncer::EXTENSIONS, triggered_type);
 
   // Reset.
   flare_was_called = false;
   triggered_type = syncer::UNSPECIFIED;
 
   // Once sync starts, flare should no longer be invoked.
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::EXTENSIONS, syncer::SyncDataList(),
-      make_scoped_ptr(new syncer::FakeSyncChangeProcessor()),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
   path = data_dir().AppendASCII("page_action.crx");
   InstallCRX(path, INSTALL_NEW);
   EXPECT_FALSE(flare_was_called);
   ASSERT_EQ(syncer::UNSPECIFIED, triggered_type);
 }
 
 TEST_F(ExtensionServiceSyncTest, DisableExtensionFromSync) {
   // Start the extensions service with one external extension already installed.
   base::FilePath source_install_dir =
       data_dir().AppendASCII("good").AppendASCII("Extensions");
@@ skipping 13 matching lines @@
   ASSERT_EQ(3u, loaded_.size());
 
   // We start enabled.
   const Extension* extension = service()->GetExtensionById(good0, true);
   ASSERT_TRUE(extension);
   ASSERT_TRUE(service()->IsExtensionEnabled(good0));
 
   // Sync starts up.
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::EXTENSIONS, syncer::SyncDataList(),
-      make_scoped_ptr(new syncer::FakeSyncChangeProcessor()),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   // Then sync data arrives telling us to disable |good0|.
   ExtensionSyncData disable_good_crx(*extension, false,
                                      Extension::DISABLE_USER_ACTION, false,
                                      false, ExtensionSyncData::BOOLEAN_UNSET);
   SyncChangeList list(
       1, disable_good_crx.GetSyncChange(SyncChange::ACTION_UPDATE));
   extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
 
   ASSERT_FALSE(service()->IsExtensionEnabled(good0));
@@ skipping 41 matching lines @@
   ExtensionSyncData disable_good0(*extension0, false,
                                   Extension::DISABLE_USER_ACTION, false, false,
                                   ExtensionSyncData::BOOLEAN_UNSET);
   ExtensionSyncData enable_good2(*extension2, true, Extension::DISABLE_NONE,
                                  false, false,
                                  ExtensionSyncData::BOOLEAN_UNSET);
   syncer::SyncDataList sync_data;
   sync_data.push_back(disable_good0.GetSyncData());
   sync_data.push_back(enable_good2.GetSyncData());
   extension_sync_service()->MergeDataAndStartSyncing(
-      syncer::EXTENSIONS,
-      sync_data,
-      make_scoped_ptr(new syncer::FakeSyncChangeProcessor()),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      syncer::EXTENSIONS, sync_data,
+      base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   // Both sync changes should be ignored, since the local state was changed
   // before sync started, and so the local state is considered more recent.
   EXPECT_TRUE(service()->IsExtensionEnabled(good0));
   EXPECT_FALSE(service()->IsExtensionEnabled(good2));
 }
 
 TEST_F(ExtensionServiceSyncTest, DontSelfNotify) {
   // Start the extension service with three extensions already installed.
   base::FilePath source_install_dir =
       data_dir().AppendASCII("good").AppendASCII("Extensions");
   base::FilePath pref_path =
       source_install_dir.DirName().Append(chrome::kPreferencesFilename);
 
   InitializeInstalledExtensionService(pref_path, source_install_dir);
 
   // The user has enabled sync.
   ProfileSyncServiceFactory::GetForProfile(profile())->SetFirstSetupComplete();
   // Make sure ExtensionSyncService is created, so it'll be notified of changes.
   extension_sync_service();
 
   service()->Init();
   ASSERT_TRUE(service()->is_ready());
   ASSERT_EQ(3u, loaded_.size());
   ASSERT_TRUE(service()->IsExtensionEnabled(good0));
 
   syncer::FakeSyncChangeProcessor* processor =
       new syncer::FakeSyncChangeProcessor;
   extension_sync_service()->MergeDataAndStartSyncing(
-      syncer::EXTENSIONS,
-      syncer::SyncDataList(),
-      make_scoped_ptr(processor),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      syncer::EXTENSIONS, syncer::SyncDataList(), base::WrapUnique(processor),
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   processor->changes().clear();
 
   // Simulate various incoming sync changes, and make sure they don't result in
   // any outgoing changes.
 
   {
     const Extension* extension = service()->GetExtensionById(good0, true);
     ASSERT_TRUE(extension);
 
@@ skipping 55 matching lines @@
 }
 
 TEST_F(ExtensionServiceSyncTest, GetSyncData) {
   InitializeEmptyExtensionService();
   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
   const Extension* extension = service()->GetInstalledExtension(good_crx);
   ASSERT_TRUE(extension);
 
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::EXTENSIONS, syncer::SyncDataList(),
-      make_scoped_ptr(new syncer::FakeSyncChangeProcessor()),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   syncer::SyncDataList list =
       extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
   ASSERT_EQ(list.size(), 1U);
-  scoped_ptr<ExtensionSyncData> data =
+  std::unique_ptr<ExtensionSyncData> data =
       ExtensionSyncData::CreateFromSyncData(list[0]);
   ASSERT_TRUE(data.get());
   EXPECT_EQ(extension->id(), data->id());
   EXPECT_FALSE(data->uninstalled());
   EXPECT_EQ(service()->IsExtensionEnabled(good_crx), data->enabled());
   EXPECT_EQ(extensions::util::IsIncognitoEnabled(good_crx, profile()),
             data->incognito_enabled());
   EXPECT_EQ(ExtensionSyncData::BOOLEAN_UNSET, data->all_urls_enabled());
   EXPECT_EQ(data->version(), *extension->version());
   EXPECT_EQ(extensions::ManifestURL::GetUpdateURL(extension),
             data->update_url());
   EXPECT_EQ(extension->name(), data->name());
 }
 
 TEST_F(ExtensionServiceSyncTest, GetSyncDataDisableReasons) {
   InitializeEmptyExtensionService();
   const Extension* extension =
       InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
   ASSERT_TRUE(extension);
 
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::EXTENSIONS, syncer::SyncDataList(),
-      make_scoped_ptr(new syncer::FakeSyncChangeProcessor()),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   {
     syncer::SyncDataList list =
         extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
     ASSERT_EQ(list.size(), 1U);
-    scoped_ptr<ExtensionSyncData> data =
+    std::unique_ptr<ExtensionSyncData> data =
         ExtensionSyncData::CreateFromSyncData(list[0]);
     ASSERT_TRUE(data.get());
     EXPECT_TRUE(data->enabled());
     EXPECT_TRUE(data->supports_disable_reasons());
     EXPECT_EQ(Extension::DISABLE_NONE, data->disable_reasons());
   }
 
   // Syncable disable reason, should propagate to sync.
   service()->DisableExtension(good_crx, Extension::DISABLE_USER_ACTION);
   {
     syncer::SyncDataList list =
         extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
     ASSERT_EQ(list.size(), 1U);
-    scoped_ptr<ExtensionSyncData> data =
+    std::unique_ptr<ExtensionSyncData> data =
         ExtensionSyncData::CreateFromSyncData(list[0]);
     ASSERT_TRUE(data.get());
     EXPECT_FALSE(data->enabled());
     EXPECT_TRUE(data->supports_disable_reasons());
     EXPECT_EQ(Extension::DISABLE_USER_ACTION, data->disable_reasons());
   }
   service()->EnableExtension(good_crx);
 
   // Non-syncable disable reason. The sync data should still say "enabled".
   service()->DisableExtension(good_crx, Extension::DISABLE_RELOAD);
   {
     syncer::SyncDataList list =
         extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
     ASSERT_EQ(list.size(), 1U);
-    scoped_ptr<ExtensionSyncData> data =
+    std::unique_ptr<ExtensionSyncData> data =
         ExtensionSyncData::CreateFromSyncData(list[0]);
     ASSERT_TRUE(data.get());
     EXPECT_TRUE(data->enabled());
     EXPECT_TRUE(data->supports_disable_reasons());
     EXPECT_EQ(Extension::DISABLE_NONE, data->disable_reasons());
   }
   service()->EnableExtension(good_crx);
 
   // Both a syncable and a non-syncable disable reason, only the former should
   // propagate to sync.
   service()->DisableExtension(
       good_crx, Extension::DISABLE_USER_ACTION | Extension::DISABLE_RELOAD);
   {
     syncer::SyncDataList list =
         extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
     ASSERT_EQ(list.size(), 1U);
-    scoped_ptr<ExtensionSyncData> data =
+    std::unique_ptr<ExtensionSyncData> data =
         ExtensionSyncData::CreateFromSyncData(list[0]);
     ASSERT_TRUE(data.get());
     EXPECT_FALSE(data->enabled());
     EXPECT_TRUE(data->supports_disable_reasons());
     EXPECT_EQ(Extension::DISABLE_USER_ACTION, data->disable_reasons());
   }
   service()->EnableExtension(good_crx);
 }
 
 TEST_F(ExtensionServiceSyncTest, GetSyncDataTerminated) {
   InitializeEmptyExtensionService();
   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
   TerminateExtension(good_crx);
   const Extension* extension = service()->GetInstalledExtension(good_crx);
   ASSERT_TRUE(extension);
 
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::EXTENSIONS, syncer::SyncDataList(),
-      make_scoped_ptr(new syncer::FakeSyncChangeProcessor()),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   syncer::SyncDataList list =
       extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
   ASSERT_EQ(list.size(), 1U);
-  scoped_ptr<ExtensionSyncData> data =
+  std::unique_ptr<ExtensionSyncData> data =
       ExtensionSyncData::CreateFromSyncData(list[0]);
   ASSERT_TRUE(data.get());
   EXPECT_EQ(extension->id(), data->id());
   EXPECT_FALSE(data->uninstalled());
   EXPECT_EQ(service()->IsExtensionEnabled(good_crx), data->enabled());
   EXPECT_EQ(extensions::util::IsIncognitoEnabled(good_crx, profile()),
             data->incognito_enabled());
   EXPECT_EQ(ExtensionSyncData::BOOLEAN_UNSET, data->all_urls_enabled());
   EXPECT_EQ(data->version(), *extension->version());
   EXPECT_EQ(extensions::ManifestURL::GetUpdateURL(extension),
             data->update_url());
   EXPECT_EQ(extension->name(), data->name());
 }
 
 TEST_F(ExtensionServiceSyncTest, GetSyncDataFilter) {
   InitializeEmptyExtensionService();
   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
   const Extension* extension = service()->GetInstalledExtension(good_crx);
   ASSERT_TRUE(extension);
 
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::APPS, syncer::SyncDataList(),
-      make_scoped_ptr(new syncer::FakeSyncChangeProcessor()),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   syncer::SyncDataList list =
       extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
   ASSERT_EQ(list.size(), 0U);
 }
 
 TEST_F(ExtensionServiceSyncTest, GetSyncExtensionDataUserSettings) {
   InitializeEmptyExtensionService();
   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
   const Extension* extension = service()->GetInstalledExtension(good_crx);
   ASSERT_TRUE(extension);
 
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::EXTENSIONS, syncer::SyncDataList(),
-      make_scoped_ptr(new syncer::FakeSyncChangeProcessor()),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   {
     syncer::SyncDataList list =
         extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
     ASSERT_EQ(list.size(), 1U);
-    scoped_ptr<ExtensionSyncData> data =
+    std::unique_ptr<ExtensionSyncData> data =
         ExtensionSyncData::CreateFromSyncData(list[0]);
     ASSERT_TRUE(data.get());
     EXPECT_TRUE(data->enabled());
     EXPECT_FALSE(data->incognito_enabled());
     EXPECT_EQ(ExtensionSyncData::BOOLEAN_UNSET, data->all_urls_enabled());
   }
 
   service()->DisableExtension(good_crx, Extension::DISABLE_USER_ACTION);
   {
     syncer::SyncDataList list =
         extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
     ASSERT_EQ(list.size(), 1U);
-    scoped_ptr<ExtensionSyncData> data =
+    std::unique_ptr<ExtensionSyncData> data =
         ExtensionSyncData::CreateFromSyncData(list[0]);
     ASSERT_TRUE(data.get());
     EXPECT_FALSE(data->enabled());
     EXPECT_FALSE(data->incognito_enabled());
     EXPECT_EQ(ExtensionSyncData::BOOLEAN_UNSET, data->all_urls_enabled());
   }
 
   extensions::util::SetIsIncognitoEnabled(good_crx, profile(), true);
   extensions::util::SetAllowedScriptingOnAllUrls(
       good_crx, profile(), false);
   {
     syncer::SyncDataList list =
         extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
     ASSERT_EQ(list.size(), 1U);
-    scoped_ptr<ExtensionSyncData> data =
+    std::unique_ptr<ExtensionSyncData> data =
         ExtensionSyncData::CreateFromSyncData(list[0]);
     ASSERT_TRUE(data.get());
     EXPECT_FALSE(data->enabled());
     EXPECT_TRUE(data->incognito_enabled());
     EXPECT_EQ(ExtensionSyncData::BOOLEAN_FALSE, data->all_urls_enabled());
   }
 
   service()->EnableExtension(good_crx);
   extensions::util::SetAllowedScriptingOnAllUrls(
       good_crx, profile(), true);
   {
     syncer::SyncDataList list =
         extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
     ASSERT_EQ(list.size(), 1U);
-    scoped_ptr<ExtensionSyncData> data =
+    std::unique_ptr<ExtensionSyncData> data =
         ExtensionSyncData::CreateFromSyncData(list[0]);
     ASSERT_TRUE(data.get());
     EXPECT_TRUE(data->enabled());
     EXPECT_TRUE(data->incognito_enabled());
     EXPECT_EQ(ExtensionSyncData::BOOLEAN_TRUE, data->all_urls_enabled());
   }
 }
 
 TEST_F(ExtensionServiceSyncTest, SyncForUninstalledExternalExtension) {
   InitializeEmptyExtensionService();
   InstallCRXWithLocation(
       data_dir().AppendASCII("good.crx"), Manifest::EXTERNAL_PREF, INSTALL_NEW);
   const Extension* extension = service()->GetInstalledExtension(good_crx);
   ASSERT_TRUE(extension);
 
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::EXTENSIONS, syncer::SyncDataList(),
-      make_scoped_ptr(new syncer::FakeSyncChangeProcessor()),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
   StartSyncing(syncer::APPS);
 
   UninstallExtension(good_crx, false);
   EXPECT_TRUE(
       ExtensionPrefs::Get(profile())->IsExternalExtensionUninstalled(good_crx));
 
   sync_pb::EntitySpecifics specifics;
   sync_pb::AppSpecifics* app_specifics = specifics.mutable_app();
   sync_pb::ExtensionSpecifics* extension_specifics =
       app_specifics->mutable_extension();
@@ skipping 11 matching lines @@
 
 TEST_F(ExtensionServiceSyncTest, GetSyncAppDataUserSettings) {
   InitializeEmptyExtensionService();
   const Extension* app =
       PackAndInstallCRX(data_dir().AppendASCII("app"), INSTALL_NEW);
   ASSERT_TRUE(app);
   ASSERT_TRUE(app->is_app());
 
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::APPS, syncer::SyncDataList(),
-      make_scoped_ptr(new syncer::FakeSyncChangeProcessor()),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   syncer::StringOrdinal initial_ordinal =
       syncer::StringOrdinal::CreateInitialOrdinal();
   {
     syncer::SyncDataList list =
         extension_sync_service()->GetAllSyncData(syncer::APPS);
     ASSERT_EQ(list.size(), 1U);
 
-    scoped_ptr<ExtensionSyncData> app_sync_data =
+    std::unique_ptr<ExtensionSyncData> app_sync_data =
         ExtensionSyncData::CreateFromSyncData(list[0]);
     EXPECT_TRUE(initial_ordinal.Equals(app_sync_data->app_launch_ordinal()));
     EXPECT_TRUE(initial_ordinal.Equals(app_sync_data->page_ordinal()));
   }
 
   AppSorting* sorting = ExtensionSystem::Get(profile())->app_sorting();
   sorting->SetAppLaunchOrdinal(app->id(), initial_ordinal.CreateAfter());
   {
     syncer::SyncDataList list =
         extension_sync_service()->GetAllSyncData(syncer::APPS);
     ASSERT_EQ(list.size(), 1U);
 
-    scoped_ptr<ExtensionSyncData> app_sync_data =
+    std::unique_ptr<ExtensionSyncData> app_sync_data =
         ExtensionSyncData::CreateFromSyncData(list[0]);
     ASSERT_TRUE(app_sync_data.get());
     EXPECT_TRUE(initial_ordinal.LessThan(app_sync_data->app_launch_ordinal()));
     EXPECT_TRUE(initial_ordinal.Equals(app_sync_data->page_ordinal()));
   }
 
   sorting->SetPageOrdinal(app->id(), initial_ordinal.CreateAfter());
   {
     syncer::SyncDataList list =
         extension_sync_service()->GetAllSyncData(syncer::APPS);
     ASSERT_EQ(list.size(), 1U);
 
-    scoped_ptr<ExtensionSyncData> app_sync_data =
+    std::unique_ptr<ExtensionSyncData> app_sync_data =
         ExtensionSyncData::CreateFromSyncData(list[0]);
     ASSERT_TRUE(app_sync_data.get());
     EXPECT_TRUE(initial_ordinal.LessThan(app_sync_data->app_launch_ordinal()));
     EXPECT_TRUE(initial_ordinal.LessThan(app_sync_data->page_ordinal()));
   }
 }
 
 // TODO (rdevlin.cronin): The OnExtensionMoved() method has been removed from
 // ExtensionService, so this test probably needs a new home. Unfortunately, it
 // relies pretty heavily on things like InitializeExtension[Sync]Service() and
 // PackAndInstallCRX(). When we clean up a bit more, this should move out.
 TEST_F(ExtensionServiceSyncTest, GetSyncAppDataUserSettingsOnExtensionMoved) {
   InitializeEmptyExtensionService();
   const size_t kAppCount = 3;
   const Extension* apps[kAppCount];
   apps[0] = PackAndInstallCRX(data_dir().AppendASCII("app1"), INSTALL_NEW);
   apps[1] = PackAndInstallCRX(data_dir().AppendASCII("app2"), INSTALL_NEW);
   apps[2] = PackAndInstallCRX(data_dir().AppendASCII("app4"), INSTALL_NEW);
   for (size_t i = 0; i < kAppCount; ++i) {
     ASSERT_TRUE(apps[i]);
     ASSERT_TRUE(apps[i]->is_app());
   }
 
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::APPS, syncer::SyncDataList(),
-      make_scoped_ptr(new syncer::FakeSyncChangeProcessor()),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   ExtensionSystem::Get(service()->GetBrowserContext())
       ->app_sorting()
       ->OnExtensionMoved(apps[0]->id(), apps[1]->id(), apps[2]->id());
   {
     syncer::SyncDataList list =
         extension_sync_service()->GetAllSyncData(syncer::APPS);
     ASSERT_EQ(list.size(), 3U);
 
-    scoped_ptr<ExtensionSyncData> data[kAppCount];
+    std::unique_ptr<ExtensionSyncData> data[kAppCount];
     for (size_t i = 0; i < kAppCount; ++i) {
       data[i] = ExtensionSyncData::CreateFromSyncData(list[i]);
       ASSERT_TRUE(data[i].get());
     }
 
     // The sync data is not always in the same order our apps were installed in,
     // so we do that sorting here so we can make sure the values are changed as
     // expected.
     syncer::StringOrdinal app_launch_ordinals[kAppCount];
     for (size_t i = 0; i < kAppCount; ++i) {
@@ skipping 10 matching lines @@
 
 TEST_F(ExtensionServiceSyncTest, GetSyncDataList) {
   InitializeEmptyExtensionService();
   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
   InstallCRX(data_dir().AppendASCII("page_action.crx"), INSTALL_NEW);
   InstallCRX(data_dir().AppendASCII("theme.crx"), INSTALL_NEW);
   InstallCRX(data_dir().AppendASCII("theme2.crx"), INSTALL_NEW);
 
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::APPS, syncer::SyncDataList(),
-      make_scoped_ptr(new syncer::FakeSyncChangeProcessor()),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::EXTENSIONS, syncer::SyncDataList(),
-      make_scoped_ptr(new syncer::FakeSyncChangeProcessor()),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   service()->DisableExtension(page_action, Extension::DISABLE_USER_ACTION);
   TerminateExtension(theme2_crx);
 
   EXPECT_EQ(0u, extension_sync_service()->GetAllSyncData(syncer::APPS).size());
   EXPECT_EQ(
       2u, extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS).size());
 }
 
 TEST_F(ExtensionServiceSyncTest, ProcessSyncDataUninstall) {
   InitializeEmptyExtensionService();
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::EXTENSIONS, syncer::SyncDataList(),
-      make_scoped_ptr(new syncer::FakeSyncChangeProcessor()),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   sync_pb::EntitySpecifics specifics;
   sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
   ext_specifics->set_id(good_crx);
   ext_specifics->set_version("1.0");
 
   SyncChangeList list =
       MakeSyncChangeList(good_crx, specifics, SyncChange::ACTION_DELETE);
 
   // Should do nothing.
@@ skipping 52 matching lines @@
     // Should again do nothing.
     extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
     EXPECT_TRUE(service()->GetExtensionById(good_crx, false));
   }
 }
 
 TEST_F(ExtensionServiceSyncTest, ProcessSyncDataSettings) {
   InitializeEmptyExtensionService();
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::EXTENSIONS, syncer::SyncDataList(),
-      make_scoped_ptr(new syncer::FakeSyncChangeProcessor()),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
   EXPECT_TRUE(service()->IsExtensionEnabled(good_crx));
   EXPECT_FALSE(extensions::util::IsIncognitoEnabled(good_crx, profile()));
   EXPECT_FALSE(extensions::util::HasSetAllowedScriptingOnAllUrls(
       good_crx, profile()));
   const bool kDefaultAllowedScripting =
       extensions::util::DefaultAllowedScriptingOnAllUrls();
   EXPECT_EQ(kDefaultAllowedScripting,
             extensions::util::AllowedScriptingOnAllUrls(good_crx, profile()));
@@ skipping 71 matching lines @@
               extensions::util::AllowedScriptingOnAllUrls(good_crx, profile()));
   }
 
   EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(good_crx));
 }
 
 TEST_F(ExtensionServiceSyncTest, ProcessSyncDataNewExtension) {
   InitializeEmptyExtensionService();
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::EXTENSIONS, syncer::SyncDataList(),
-      make_scoped_ptr(new syncer::FakeSyncChangeProcessor()),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   const base::FilePath path = data_dir().AppendASCII("good.crx");
   const ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
 
   struct TestCase {
     const char* name;  // For failure output only.
     bool sync_enabled;  // The "enabled" flag coming in from Sync.
     // The disable reason(s) coming in from Sync, or -1 for "not set".
     int sync_disable_reasons;
     // The disable reason(s) that should be set on the installed extension.
@@ skipping 36 matching lines @@
     SyncChangeList list =
         MakeSyncChangeList(good_crx, specifics, SyncChange::ACTION_UPDATE);
 
     extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
 
     ASSERT_TRUE(service()->pending_extension_manager()->IsIdPending(good_crx));
     UpdateExtension(good_crx, path, test_case.sync_enabled ? ENABLED
                                                            : DISABLED);
     EXPECT_EQ(test_case.expect_disable_reasons,
               prefs->GetDisableReasons(good_crx));
-    scoped_ptr<const PermissionSet> permissions =
+    std::unique_ptr<const PermissionSet> permissions =
         prefs->GetGrantedPermissions(good_crx);
     EXPECT_EQ(test_case.expect_permissions_granted, !permissions->IsEmpty());
     ASSERT_FALSE(service()->pending_extension_manager()->IsIdPending(good_crx));
 
     // Remove the extension again, so we can install it again for the next case.
     UninstallExtension(good_crx, false,
                        test_case.sync_enabled ? Extension::ENABLED
                                               : Extension::DISABLED);
   }
 }
 
 TEST_F(ExtensionServiceSyncTest, ProcessSyncDataTerminatedExtension) {
   InitializeExtensionServiceWithUpdater();
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::EXTENSIONS, syncer::SyncDataList(),
-      make_scoped_ptr(new syncer::FakeSyncChangeProcessor()),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
   TerminateExtension(good_crx);
   EXPECT_TRUE(service()->IsExtensionEnabled(good_crx));
   EXPECT_FALSE(extensions::util::IsIncognitoEnabled(good_crx, profile()));
 
   sync_pb::EntitySpecifics specifics;
   sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
   ext_specifics->set_id(good_crx);
   ext_specifics->set_version(
       service()->GetInstalledExtension(good_crx)->version()->GetString());
   ext_specifics->set_enabled(false);
   ext_specifics->set_incognito_enabled(true);
 
   SyncChangeList list =
       MakeSyncChangeList(good_crx, specifics, SyncChange::ACTION_UPDATE);
 
   extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
   EXPECT_FALSE(service()->IsExtensionEnabled(good_crx));
   EXPECT_TRUE(extensions::util::IsIncognitoEnabled(good_crx, profile()));
 
   EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(good_crx));
 }
 
 TEST_F(ExtensionServiceSyncTest, ProcessSyncDataVersionCheck) {
   InitializeExtensionServiceWithUpdater();
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::EXTENSIONS, syncer::SyncDataList(),
-      make_scoped_ptr(new syncer::FakeSyncChangeProcessor()),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
   EXPECT_TRUE(service()->IsExtensionEnabled(good_crx));
   EXPECT_FALSE(extensions::util::IsIncognitoEnabled(good_crx, profile()));
 
   sync_pb::EntitySpecifics specifics;
   sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
   ext_specifics->set_id(good_crx);
   ext_specifics->set_enabled(true);
 
   const base::Version installed_version =
       *service()->GetInstalledExtension(good_crx)->version();
 
   {
     ext_specifics->set_version(installed_version.GetString());
 
     SyncChangeList list =
         MakeSyncChangeList(good_crx, specifics, SyncChange::ACTION_UPDATE);
 
     // Should do nothing if extension version == sync version.
     extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
     EXPECT_FALSE(service()->updater()->WillCheckSoon());
     // Make sure the version we'll send back to sync didn't change.
     syncer::SyncDataList data =
         extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
     ASSERT_EQ(1u, data.size());
-    scoped_ptr<ExtensionSyncData> extension_data =
+    std::unique_ptr<ExtensionSyncData> extension_data =
         ExtensionSyncData::CreateFromSyncData(data[0]);
     ASSERT_TRUE(extension_data);
     EXPECT_EQ(installed_version, extension_data->version());
   }
 
   // Should do nothing if extension version > sync version.
   {
     ext_specifics->set_version("0.0.0.0");
 
     SyncChangeList list =
         MakeSyncChangeList(good_crx, specifics, SyncChange::ACTION_UPDATE);
 
     extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
     EXPECT_FALSE(service()->updater()->WillCheckSoon());
     // Make sure the version we'll send back to sync didn't change.
     syncer::SyncDataList data =
         extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
     ASSERT_EQ(1u, data.size());
-    scoped_ptr<ExtensionSyncData> extension_data =
+    std::unique_ptr<ExtensionSyncData> extension_data =
         ExtensionSyncData::CreateFromSyncData(data[0]);
     ASSERT_TRUE(extension_data);
     EXPECT_EQ(installed_version, extension_data->version());
   }
 
   // Should kick off an update if extension version < sync version.
   {
     const base::Version new_version("9.9.9.9");
     ext_specifics->set_version(new_version.GetString());
 
     SyncChangeList list =
         MakeSyncChangeList(good_crx, specifics, SyncChange::ACTION_UPDATE);
 
     extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
     EXPECT_TRUE(service()->updater()->WillCheckSoon());
     // Make sure that we'll send the NEW version back to sync, even though we
     // haven't actually updated yet. This is to prevent the data in sync from
     // flip-flopping back and forth until all clients are up to date.
     syncer::SyncDataList data =
         extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
     ASSERT_EQ(1u, data.size());
-    scoped_ptr<ExtensionSyncData> extension_data =
+    std::unique_ptr<ExtensionSyncData> extension_data =
         ExtensionSyncData::CreateFromSyncData(data[0]);
     ASSERT_TRUE(extension_data);
     EXPECT_EQ(new_version, extension_data->version());
   }
 
   EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(good_crx));
 }
 
 TEST_F(ExtensionServiceSyncTest, ProcessSyncDataNotInstalled) {
   InitializeExtensionServiceWithUpdater();
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::EXTENSIONS, syncer::SyncDataList(),
-      make_scoped_ptr(new syncer::FakeSyncChangeProcessor()),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   sync_pb::EntitySpecifics specifics;
   sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
   ext_specifics->set_id(good_crx);
   ext_specifics->set_enabled(false);
   ext_specifics->set_incognito_enabled(true);
   ext_specifics->set_update_url("http://www.google.com/");
   ext_specifics->set_version("1.2.3.4");
 
   SyncChangeList list =
@@ skipping 12 matching lines @@
   EXPECT_EQ(ext_specifics->update_url(), info->update_url().spec());
   EXPECT_TRUE(info->is_from_sync());
   EXPECT_EQ(Manifest::INTERNAL, info->install_source());
   // TODO(akalin): Figure out a way to test |info.ShouldAllowInstall()|.
 }
 
 TEST_F(ExtensionServiceSyncTest, ProcessSyncDataEnableDisable) {
   InitializeEmptyExtensionService();
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::EXTENSIONS, syncer::SyncDataList(),
-      make_scoped_ptr(new syncer::FakeSyncChangeProcessor()),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   const ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
 
   struct TestCase {
     const char* name;  // For failure output only.
     // Set of disable reasons before any Sync data comes in. If this is != 0,
     // the extension is disabled.
     int previous_disable_reasons;
     bool sync_enable;  // The enabled flag coming in from Sync.
     // The disable reason(s) coming in from Sync, or -1 for "not set".
@@ skipping 80 matching lines @@
     // Remove the extension again, so we can install it again for the next case.
     UninstallExtension(id, false, expect_enabled ? Extension::ENABLED
                                                  : Extension::DISABLED);
   }
 }
 
 TEST_F(ExtensionServiceSyncTest, ProcessSyncDataDeferredEnable) {
   InitializeEmptyExtensionService();
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::EXTENSIONS, syncer::SyncDataList(),
-      make_scoped_ptr(new syncer::FakeSyncChangeProcessor()),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   base::FilePath base_path = data_dir().AppendASCII("permissions_increase");
   base::FilePath pem_path = base_path.AppendASCII("permissions.pem");
 
   base::FilePath path = base_path.AppendASCII("v1");
   const Extension* extension = PackAndInstallCRX(path, pem_path, INSTALL_NEW);
   // The extension must now be installed and enabled.
   ASSERT_TRUE(extension);
   ASSERT_TRUE(registry()->enabled_extensions().Contains(extension->id()));
 
@@ skipping 28 matching lines @@
 TEST_F(ExtensionServiceSyncTest, ProcessSyncDataPermissionApproval) {
   // This is the update URL specified in the test extension. Setting it here is
   // necessary to make it considered syncable.
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kAppsGalleryUpdateURL,
       "http://localhost/autoupdate/updates.xml");
 
   InitializeEmptyExtensionService();
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::EXTENSIONS, syncer::SyncDataList(),
-      make_scoped_ptr(new syncer::FakeSyncChangeProcessor()),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   const base::FilePath base_path =
       data_dir().AppendASCII("permissions_increase");
   const base::FilePath pem_path = base_path.AppendASCII("permissions.pem");
   const base::FilePath path_v1 = base_path.AppendASCII("v1");
   const base::FilePath path_v2 = base_path.AppendASCII("v2");
 
   base::ScopedTempDir crx_dir;
   ASSERT_TRUE(crx_dir.CreateUniqueTempDir());
   const base::FilePath crx_path_v1 = crx_dir.path().AppendASCII("temp1.crx");
@@ skipping 37 matching lines @@
     // during updating).
     {
       const Extension* extension = InstallCRX(crx_path_v1, INSTALL_NEW);
       // The extension should now be installed and enabled.
       ASSERT_TRUE(extension);
       ASSERT_EQ(v1, extension->VersionString());
       id = extension->id();
     }
     ASSERT_TRUE(registry()->enabled_extensions().Contains(id));
 
-    scoped_ptr<const PermissionSet> granted_permissions_v1 =
+    std::unique_ptr<const PermissionSet> granted_permissions_v1 =
         prefs->GetGrantedPermissions(id);
 
     // Update to a new version with increased permissions.
     UpdateExtension(id, crx_path_v2, DISABLED);
 
     // Now the extension should be disabled due to a permissions increase.
     {
       const Extension* extension =
           registry()->disabled_extensions().GetByID(id);
       ASSERT_TRUE(extension);
       ASSERT_EQ(v2, extension->VersionString());
     }
     ASSERT_TRUE(prefs->HasDisableReason(
         id, Extension::DISABLE_PERMISSIONS_INCREASE));
 
     // No new permissions should have been granted.
-    scoped_ptr<const PermissionSet> granted_permissions_v2 =
+    std::unique_ptr<const PermissionSet> granted_permissions_v2 =
         prefs->GetGrantedPermissions(id);
     ASSERT_EQ(*granted_permissions_v1, *granted_permissions_v2);
 
     // Now a sync update comes in.
     sync_pb::EntitySpecifics specifics;
     sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
     ext_specifics->set_id(id);
     ext_specifics->set_enabled(true);
     ext_specifics->set_version(test_case.sync_version);
     if (test_case.sync_disable_reasons != -1)
       ext_specifics->set_disable_reasons(test_case.sync_disable_reasons);
 
     SyncChangeList list =
         MakeSyncChangeList(good_crx, specifics, SyncChange::ACTION_UPDATE);
 
     extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
 
     // Check expectations.
     const bool expect_enabled = !test_case.expect_disable_reasons;
     EXPECT_EQ(expect_enabled, service()->IsExtensionEnabled(id));
     EXPECT_EQ(test_case.expect_disable_reasons, prefs->GetDisableReasons(id));
-    scoped_ptr<const PermissionSet> granted_permissions =
+    std::unique_ptr<const PermissionSet> granted_permissions =
         prefs->GetGrantedPermissions(id);
     if (test_case.expect_permissions_granted) {
-      scoped_ptr<const PermissionSet> active_permissions =
+      std::unique_ptr<const PermissionSet> active_permissions =
           prefs->GetActivePermissions(id);
       EXPECT_EQ(*granted_permissions, *active_permissions);
     } else {
       EXPECT_EQ(*granted_permissions, *granted_permissions_v1);
     }
 
     // Remove the extension again, so we can install it again for the next case.
     UninstallExtension(id, false, expect_enabled ? Extension::ENABLED
                                                  : Extension::DISABLED);
   }
 }
 
 // Regression test for crbug.com/558299
 TEST_F(ExtensionServiceSyncTest, DontSyncThemes) {
   InitializeEmptyExtensionService();
 
   // The user has enabled sync.
   ProfileSyncServiceFactory::GetForProfile(profile())->SetFirstSetupComplete();
   // Make sure ExtensionSyncService is created, so it'll be notified of changes.
   extension_sync_service();
 
   service()->Init();
   ASSERT_TRUE(service()->is_ready());
 
   syncer::FakeSyncChangeProcessor* processor =
       new syncer::FakeSyncChangeProcessor;
   extension_sync_service()->MergeDataAndStartSyncing(
-      syncer::EXTENSIONS,
-      syncer::SyncDataList(),
-      make_scoped_ptr(processor),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock));
+      syncer::EXTENSIONS, syncer::SyncDataList(), base::WrapUnique(processor),
+      base::WrapUnique(new syncer::SyncErrorFactoryMock));
 
   processor->changes().clear();
 
   // Sanity check: Installing an extension should result in a sync change.
   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
   EXPECT_EQ(1u, processor->changes().size());
 
   processor->changes().clear();
 
   // Installing a theme should not result in a sync change (themes are handled
@@ skipping 181 matching lines @@
   EXPECT_NE(extension->VersionString(), old_version);
 }
 
 TEST_F(ExtensionServiceTestSupervised, UpdateWithPermissionIncreaseNoApproval) {
   InitNeedCustodianApprovalFieldTrial(false);
 
   InitServices(true /* profile_is_supervised */);
 
   MockPermissionRequestCreator* creator = new MockPermissionRequestCreator;
   supervised_user_service()->AddPermissionRequestCreator(
-      make_scoped_ptr(creator));
+      base::WrapUnique(creator));
 
   std::string id = InstallPermissionsTestExtension();
 
   // Update to a new version with increased permissions.
   // Since we don't require the custodian's approval, no permission request
   // should be created.
   const std::string version2("2");
   EXPECT_CALL(*creator, CreateExtensionUpdateRequest(
                             UpdateRequestId(id, version2), testing::_))
       .Times(0);
   UpdatePermissionsTestExtension(id, version2, DISABLED);
 }
 
 TEST_F(ExtensionServiceTestSupervised,
        UpdateWithPermissionIncreaseApprovalOldVersion) {
   InitNeedCustodianApprovalFieldTrial(true);
 
   InitServices(true /* profile_is_supervised */);
 
   MockPermissionRequestCreator* creator = new MockPermissionRequestCreator;
   supervised_user_service()->AddPermissionRequestCreator(
-      make_scoped_ptr(creator));
+      base::WrapUnique(creator));
 
   const std::string version1("1");
   const std::string version2("2");
 
   std::string id = InstallPermissionsTestExtension();
 
   // Update to a new version with increased permissions.
   EXPECT_CALL(*creator, CreateExtensionUpdateRequest(
                             UpdateRequestId(id, version2), testing::_));
   UpdatePermissionsTestExtension(id, version2, DISABLED);
@@ skipping 27 matching lines @@
 }
 
 TEST_F(ExtensionServiceTestSupervised,
        UpdateWithPermissionIncreaseApprovalMatchingVersion) {
   InitNeedCustodianApprovalFieldTrial(true);
 
   InitServices(true /* profile_is_supervised */);
 
   MockPermissionRequestCreator* creator = new MockPermissionRequestCreator;
   supervised_user_service()->AddPermissionRequestCreator(
-      make_scoped_ptr(creator));
+      base::WrapUnique(creator));
 
   std::string id = InstallPermissionsTestExtension();
 
   // Update to a new version with increased permissions.
   const std::string version2("2");
   EXPECT_CALL(*creator, CreateExtensionUpdateRequest(
                             UpdateRequestId(id, version2), testing::_));
   UpdatePermissionsTestExtension(id, version2, DISABLED);
 
   // Simulate a custodian approval for re-enabling the extension coming in
@@ skipping 15 matching lines @@
 }
 
 TEST_F(ExtensionServiceTestSupervised,
        UpdateWithPermissionIncreaseApprovalNewVersion) {
   InitNeedCustodianApprovalFieldTrial(true);
 
   InitServices(true /* profile_is_supervised */);
 
   MockPermissionRequestCreator* creator = new MockPermissionRequestCreator;
   supervised_user_service()->AddPermissionRequestCreator(
-      make_scoped_ptr(creator));
+      base::WrapUnique(creator));
 
   std::string id = InstallPermissionsTestExtension();
 
   // Update to a new version with increased permissions.
   const std::string version2("2");
   EXPECT_CALL(*creator, CreateExtensionUpdateRequest(
                             UpdateRequestId(id, version2), testing::_));
   UpdatePermissionsTestExtension(id, version2, DISABLED);
 
   // Simulate a custodian approval for re-enabling the extension coming in
@@ skipping 23 matching lines @@
       id, base::Version(version3)));
 
   // Update to the matching version. Now the extension should get enabled.
   UpdatePermissionsTestExtension(id, version3, ENABLED);
 }
 
 TEST_F(ExtensionServiceSyncTest, SyncUninstallByCustodianSkipsPolicy) {
   InitializeEmptyExtensionService();
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::EXTENSIONS, syncer::SyncDataList(),
-      make_scoped_ptr(new syncer::FakeSyncChangeProcessor()),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   // Install two extensions.
   base::FilePath path1 = data_dir().AppendASCII("good.crx");
   base::FilePath path2 = data_dir().AppendASCII("good2048.crx");
   const Extension* extensions[] = {
     InstallCRX(path1, INSTALL_NEW),
     InstallCRX(path2, INSTALL_NEW, Extension::WAS_INSTALLED_BY_CUSTODIAN)
   };
 
   // Add a policy provider that will disallow any changes.
@@ skipping 98 matching lines @@
                  INSTALL_NEW);
   EXPECT_TRUE(v1->is_app());
   EXPECT_FALSE(v1->is_extension());
   std::string id = v1->id();
 
   StatefulChangeProcessor extensions_processor(syncer::ModelType::EXTENSIONS);
   StatefulChangeProcessor apps_processor(syncer::ModelType::APPS);
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::EXTENSIONS, syncer::SyncDataList(),
       extensions_processor.GetWrapped(),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::APPS, syncer::SyncDataList(), apps_processor.GetWrapped(),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   // Check the app/extension change processors to be sure the right data was
   // added.
   EXPECT_TRUE(extensions_processor.changes().empty());
   EXPECT_TRUE(extensions_processor.data().empty());
   EXPECT_EQ(1u, apps_processor.data().size());
   ASSERT_EQ(1u, apps_processor.changes().size());
   const SyncChange& app_change = apps_processor.changes()[0];
   EXPECT_EQ(SyncChange::ACTION_ADD, app_change.change_type());
-  scoped_ptr<ExtensionSyncData> app_data =
+  std::unique_ptr<ExtensionSyncData> app_data =
       ExtensionSyncData::CreateFromSyncData(app_change.sync_data());
   EXPECT_TRUE(app_data->is_app());
   EXPECT_EQ(id, app_data->id());
   EXPECT_EQ(*v1->version(), app_data->version());
 
   // Update the app to v2, which is an extension.
   const Extension* v2 =
       InstallCRX(data_dir().AppendASCII("sync_datatypes").AppendASCII("v2.crx"),
                  INSTALL_UPDATED);
   EXPECT_FALSE(v2->is_app());
   EXPECT_TRUE(v2->is_extension());
   EXPECT_EQ(id, v2->id());
 
   // Make sure we saw an extension item added.
   ASSERT_EQ(1u, extensions_processor.changes().size());
   const SyncChange& extension_change = extensions_processor.changes()[0];
   EXPECT_EQ(SyncChange::ACTION_ADD, extension_change.change_type());
-  scoped_ptr<ExtensionSyncData> extension_data =
+  std::unique_ptr<ExtensionSyncData> extension_data =
       ExtensionSyncData::CreateFromSyncData(extension_change.sync_data());
   EXPECT_FALSE(extension_data->is_app());
   EXPECT_EQ(id, extension_data->id());
   EXPECT_EQ(*v2->version(), extension_data->version());
 
   // Get the current data from the change processors to use as the input to
   // the following call to MergeDataAndStartSyncing. This simulates what should
   // happen with sync.
   syncer::SyncDataList extensions_data =
       extensions_processor.GetAllSyncData(syncer::EXTENSIONS);
   syncer::SyncDataList apps_data = apps_processor.GetAllSyncData(syncer::APPS);
 
   // Stop syncing, then start again.
   extension_sync_service()->StopSyncing(syncer::EXTENSIONS);
   extension_sync_service()->StopSyncing(syncer::APPS);
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::EXTENSIONS, extensions_data, extensions_processor.GetWrapped(),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::APPS, apps_data, apps_processor.GetWrapped(),
-      make_scoped_ptr(new syncer::SyncErrorFactoryMock()));
+      base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   // Make sure we saw an app item deleted.
   bool found_delete = false;
   for (const auto& change : apps_processor.changes()) {
     if (change.change_type() == SyncChange::ACTION_DELETE) {
-      scoped_ptr<ExtensionSyncData> data =
+      std::unique_ptr<ExtensionSyncData> data =
           ExtensionSyncData::CreateFromSyncChange(change);
       if (data->id() == id) {
         found_delete = true;
         break;
       }
     }
   }
   EXPECT_TRUE(found_delete);
 
   // Make sure there is one extension, and there are no more apps.
   EXPECT_EQ(1u, extensions_processor.data().size());
   EXPECT_TRUE(apps_processor.data().empty());
 }