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

chrome/browser/chromeos/preferences_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 "chrome/browser/chromeos/preferences.h"
 
 #include <utility>
 
 #include "base/json/json_string_value_serializer.h"
 #include "base/macros.h"
@@ skipping 97 matching lines @@
           id, std::string(), std::string(), std::vector<std::string>(),
           std::vector<std::string>(), false, GURL(), GURL());
       input_method_extensions_->push_back(descriptor);
     }
 
    protected:
     ~State() override{};
 
    private:
     MyMockInputMethodManager* const manager_;
-    scoped_ptr<InputMethodDescriptors> input_method_extensions_;
+    std::unique_ptr<InputMethodDescriptors> input_method_extensions_;
   };
 
   MyMockInputMethodManager(StringPrefMember* previous,
                            StringPrefMember* current)
       : previous_(previous),
         current_(current) {
     state_ = new State(this);
   }
 
   ~MyMockInputMethodManager() override {}
 
-  scoped_ptr<InputMethodDescriptors> GetSupportedInputMethods() const override {
+  std::unique_ptr<InputMethodDescriptors> GetSupportedInputMethods()
+      const override {
     return whitelist_.GetSupportedInputMethods();
   }
 
   std::string last_input_method_id_;
 
  private:
   StringPrefMember* previous_;
   StringPrefMember* current_;
   InputMethodWhitelist whitelist_;
 };
@@ skipping 50 matching lines @@
     UserSessionManager::GetInstance()->RemoveProfileForTesting(test_profile_);
   }
 
   void InitPreferences() {
     prefs_->InitUserPrefsForTesting(
         pref_service_, test_user_, mock_manager_->GetActiveIMEState());
     prefs_->SetInputMethodListForTesting();
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
-  scoped_ptr<TestingProfileManager> profile_manager_;
-  scoped_ptr<chromeos::ScopedUserManagerEnabler> user_manager_enabler_;
-  scoped_ptr<Preferences> prefs_;
+  std::unique_ptr<TestingProfileManager> profile_manager_;
+  std::unique_ptr<chromeos::ScopedUserManagerEnabler> user_manager_enabler_;
+  std::unique_ptr<Preferences> prefs_;
   StringPrefMember previous_input_method_;
   StringPrefMember current_input_method_;
 
   // Not owned.
   const user_manager::User* test_user_;
   TestingProfile* test_profile_;
   syncable_prefs::TestingPrefServiceSyncable* pref_service_;
   input_method::MyMockInputMethodManager* mock_manager_;
 
  private:
@@ skipping 48 matching lines @@
         NULL);
   }
 
   void InitComponentExtensionIMEManager() {
     // Set our custom IME list on the mock delegate.
     input_method::MockComponentExtIMEManagerDelegate* mock_delegate =
         new input_method::MockComponentExtIMEManagerDelegate();
     mock_delegate->set_ime_list(CreateImeList());
 
     // Pass the mock delegate to a new ComponentExtensionIMEManager.
-    scoped_ptr<ComponentExtensionIMEManagerDelegate> delegate(mock_delegate);
-    scoped_ptr<ComponentExtensionIMEManager> component_extension_ime_manager(
-        new ComponentExtensionIMEManager);
+    std::unique_ptr<ComponentExtensionIMEManagerDelegate> delegate(
+        mock_delegate);
+    std::unique_ptr<ComponentExtensionIMEManager>
+        component_extension_ime_manager(new ComponentExtensionIMEManager);
     component_extension_ime_manager->Initialize(std::move(delegate));
 
     // Add the ComponentExtensionIMEManager to the mock InputMethodManager.
     mock_manager_->SetComponentExtensionIMEManager(
         std::move(component_extension_ime_manager));
   }
 
   std::vector<ComponentExtensionIME> CreateImeList() {
     std::vector<ComponentExtensionIME> ime_list;
 
@@ skipping 99 matching lines @@
       prefs::kLanguagePreloadEnginesSyncable,
       base::StringValue("xkb:se::swe")));
   sync_data_list.push_back(CreatePrefSyncData(
       prefs::kLanguageEnabledExtensionImesSyncable,
       base::StringValue(kIdentityIMEID)));
 
   // Sync for the first time.
   syncer::SyncableService* sync =
       pref_service_->GetSyncableService(
           syncer::PREFERENCES);
-  sync->MergeDataAndStartSyncing(syncer::PREFERENCES,
-                                 sync_data_list,
-                                 scoped_ptr<syncer::SyncChangeProcessor>(
+  sync->MergeDataAndStartSyncing(syncer::PREFERENCES, sync_data_list,
+                                 std::unique_ptr<syncer::SyncChangeProcessor>(
                                      new syncer::FakeSyncChangeProcessor),
-                                 scoped_ptr<syncer::SyncErrorFactory>(
+                                 std::unique_ptr<syncer::SyncErrorFactory>(
                                      new syncer::SyncErrorFactoryMock));
   content::RunAllBlockingPoolTasksUntilIdle();
 
   // Note that we expect the preload_engines to have been translated to input
   // method IDs during the merge.
   std::string expected_languages("es,ru,fi");
   std::string expected_preload_engines(
       "xkb:us:altgr-intl:eng,xkb:us:intl:eng,xkb:se::swe");
   std::string expected_extensions(kIdentityIMEID);
   {
@@ skipping 68 matching lines @@
   sync_data_list.push_back(CreatePrefSyncData(
       prefs::kLanguagePreloadEngines,
       base::StringValue(ToInputMethodIds("xkb:ru::rus"))));
   sync_data_list.push_back(CreatePrefSyncData(
       prefs::kLanguageEnabledExtensionImes, base::StringValue(kIdentityIMEID)));
 
   // Sync.
   syncer::SyncableService* sync =
       pref_service_->GetSyncableService(
           syncer::PREFERENCES);
-  sync->MergeDataAndStartSyncing(syncer::PREFERENCES,
-                                 sync_data_list,
-                                 scoped_ptr<syncer::SyncChangeProcessor>(
+  sync->MergeDataAndStartSyncing(syncer::PREFERENCES, sync_data_list,
+                                 std::unique_ptr<syncer::SyncChangeProcessor>(
                                      new syncer::FakeSyncChangeProcessor),
-                                 scoped_ptr<syncer::SyncErrorFactory>(
+                                 std::unique_ptr<syncer::SyncErrorFactory>(
                                      new syncer::SyncErrorFactoryMock));
   content::RunAllBlockingPoolTasksUntilIdle();
   {
     SCOPED_TRACE("Local preferences should have remained the same.");
     ExpectLocalValues(languages, preload_engines, extensions);
   }
   // Change local preferences.
   SetLocalValues("ja", ToInputMethodIds("xkb:jp::jpn"), kToUpperIMEID);
   content::RunAllBlockingPoolTasksUntilIdle();
   {
@@ skipping 16 matching lines @@
   sync_data_list.push_back(CreatePrefSyncData(
       prefs::kLanguagePreloadEnginesSyncable,
       base::StringValue(ToInputMethodIds("xkb:ru::rus"))));
   sync_data_list.push_back(CreatePrefSyncData(
       prefs::kLanguageEnabledExtensionImesSyncable,
       base::StringValue(kToUpperIMEID)));
 
   syncer::SyncableService* sync =
       pref_service_->GetSyncableService(
           syncer::PREFERENCES);
-  sync->MergeDataAndStartSyncing(syncer::PREFERENCES,
-                                 sync_data_list,
-                                 scoped_ptr<syncer::SyncChangeProcessor>(
+  sync->MergeDataAndStartSyncing(syncer::PREFERENCES, sync_data_list,
+                                 std::unique_ptr<syncer::SyncChangeProcessor>(
                                      new syncer::FakeSyncChangeProcessor),
-                                 scoped_ptr<syncer::SyncErrorFactory>(
+                                 std::unique_ptr<syncer::SyncErrorFactory>(
                                      new syncer::SyncErrorFactoryMock));
   content::RunAllBlockingPoolTasksUntilIdle();
   {
     SCOPED_TRACE("Local preferences should have remained the same.");
     ExpectLocalValues("es", "xkb:es::spa", kIdentityIMEID);
   }
   {
     SCOPED_TRACE("Global preferences should have remained the same.");
     ExpectGlobalValues("ru,fi", ToInputMethodIds("xkb:ru::rus"), kToUpperIMEID);
   }
@@ skipping 34 matching lines @@
       base::StringValue(
           "nacl_mozc_us,xkb:ru::rus,xkb:ru::rus,xkb:es::spa,xkb:es::spa")));
   sync_data_list.push_back(CreatePrefSyncData(
       prefs::kLanguageEnabledExtensionImesSyncable,
       base::StringValue(std::string())));
 
   // Sync for the first time.
   syncer::SyncableService* sync =
       pref_service_->GetSyncableService(
           syncer::PREFERENCES);
-  sync->MergeDataAndStartSyncing(syncer::PREFERENCES,
-                                 sync_data_list,
-                                 scoped_ptr<syncer::SyncChangeProcessor>(
+  sync->MergeDataAndStartSyncing(syncer::PREFERENCES, sync_data_list,
+                                 std::unique_ptr<syncer::SyncChangeProcessor>(
                                      new syncer::FakeSyncChangeProcessor),
-                                 scoped_ptr<syncer::SyncErrorFactory>(
+                                 std::unique_ptr<syncer::SyncErrorFactory>(
                                      new syncer::SyncErrorFactoryMock));
   content::RunAllBlockingPoolTasksUntilIdle();
   {
     SCOPED_TRACE("Server values should have merged into local values.");
     ExpectLocalValues(
         "en,es,ja,hr,lv,lt,es-419,he,el,da,ca,es,cs,bg,ar,fi,de",
         ToInputMethodIds("xkb:es::spa,xkb:us:dvorak,xkb:ua::ukr,"
                          "nacl_mozc_us,xkb:ru::rus"),
         local_extensions);
   }
@@ skipping 28 matching lines @@
       prefs::kLanguagePreloadEnginesSyncable,
       base::StringValue(preload_engines)));
   sync_data_list.push_back(CreatePrefSyncData(
       prefs::kLanguageEnabledExtensionImesSyncable,
       base::StringValue(kUnknownIMEID)));
 
   // Sync for the first time.
   syncer::SyncableService* sync =
       pref_service_->GetSyncableService(
           syncer::PREFERENCES);
-  sync->MergeDataAndStartSyncing(syncer::PREFERENCES,
-                                 sync_data_list,
-                                 scoped_ptr<syncer::SyncChangeProcessor>(
+  sync->MergeDataAndStartSyncing(syncer::PREFERENCES, sync_data_list,
+                                 std::unique_ptr<syncer::SyncChangeProcessor>(
                                      new syncer::FakeSyncChangeProcessor),
-                                 scoped_ptr<syncer::SyncErrorFactory>(
+                                 std::unique_ptr<syncer::SyncErrorFactory>(
                                      new syncer::SyncErrorFactoryMock));
   content::RunAllBlockingPoolTasksUntilIdle();
   {
     SCOPED_TRACE("Only valid server values should have been merged in.");
     ExpectLocalValues(
         "es,en-US",
         ToInputMethodIds("xkb:es::spa,xkb:us::eng,xkb:ru::rus,xkb:jp::jpn"),
         kIdentityIMEID);
   }
 }
@@ skipping 18 matching lines @@
       prefs::kLanguagePreloadEnginesSyncable,
       base::StringValue(preload_engines)));
   sync_data_list.push_back(CreatePrefSyncData(
       prefs::kLanguageEnabledExtensionImesSyncable,
       base::StringValue(kUnknownIMEID)));
 
   // Sync for the first time.
   syncer::SyncableService* sync =
       pref_service_->GetSyncableService(
           syncer::PREFERENCES);
-  sync->MergeDataAndStartSyncing(syncer::PREFERENCES,
-                                 sync_data_list,
-                                 scoped_ptr<syncer::SyncChangeProcessor>(
+  sync->MergeDataAndStartSyncing(syncer::PREFERENCES, sync_data_list,
+                                 std::unique_ptr<syncer::SyncChangeProcessor>(
                                      new syncer::FakeSyncChangeProcessor),
-                                 scoped_ptr<syncer::SyncErrorFactory>(
+                                 std::unique_ptr<syncer::SyncErrorFactory>(
                                      new syncer::SyncErrorFactoryMock));
   content::RunAllBlockingPoolTasksUntilIdle();
   InitPreferences();
   content::RunAllBlockingPoolTasksUntilIdle();
 
   {
     SCOPED_TRACE("Local values should have been merged on initialization.");
     ExpectLocalValues(
         "es,en-US",
         ToInputMethodIds("xkb:es::spa,xkb:us::eng,xkb:ru::rus,xkb:jp::jpn"),
         kIdentityIMEID);
   }
   {
     SCOPED_TRACE(
         "Syncable values should have added local values on initialization.");
     ExpectGlobalValues(
         "es,en-US",
         "xkb:es::spa,xkb:us::eng,xkb:ru::rus,xkb:xy::xyz," +
             ToInputMethodIds("xkb:jp::jpn"),
         std::string(kIdentityIMEID) + "," + kUnknownIMEID);
   }
 }
 
 }  // namespace chromeos