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

chrome/browser/supervised_user/legacy/supervised_user_shared_settings_service.cc

 // Copyright 2014 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/supervised_user/legacy/supervised_user_shared_settings_service.h"
 
 #include <map>
 #include <set>
 #include <utility>
 
@@ skipping 137 matching lines @@
   return value;
 }
 
 void SupervisedUserSharedSettingsService::SetValue(
     const std::string& su_id,
     const std::string& key,
     const Value& value) {
   SetValueInternal(su_id, key, value, true);
 }
 
-scoped_ptr<
+std::unique_ptr<
     SupervisedUserSharedSettingsService::ChangeCallbackList::Subscription>
 SupervisedUserSharedSettingsService::Subscribe(
     const SupervisedUserSharedSettingsService::ChangeCallback& cb) {
   return callbacks_.Add(cb);
 }
 
 // static
 void SupervisedUserSharedSettingsService::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterDictionaryPref(prefs::kSupervisedUserSharedSettings);
@@ skipping 16 matching lines @@
   std::string title = su_id + ":" + key;
   return SyncData::CreateLocalData(title, title, specifics);
 }
 
 void SupervisedUserSharedSettingsService::Shutdown() {}
 
 syncer::SyncMergeResult
 SupervisedUserSharedSettingsService::MergeDataAndStartSyncing(
     syncer::ModelType type,
     const syncer::SyncDataList& initial_sync_data,
-    scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
-    scoped_ptr<syncer::SyncErrorFactory> error_handler) {
+    std::unique_ptr<syncer::SyncChangeProcessor> sync_processor,
+    std::unique_ptr<syncer::SyncErrorFactory> error_handler) {
   DCHECK_EQ(SUPERVISED_USER_SHARED_SETTINGS, type);
   sync_processor_ = std::move(sync_processor);
   error_handler_ = std::move(error_handler);
 
   int num_before_association = 0;
   std::map<std::string, std::set<std::string> > pref_seen_keys;
   const DictionaryValue* pref_dict =
       prefs_->GetDictionary(prefs::kSupervisedUserSharedSettings);
   for (DictionaryValue::Iterator it(*pref_dict); !it.IsAtEnd(); it.Advance()) {
     const DictionaryValue* dict = nullptr;
@@ skipping 10 matching lines @@
   int num_added = 0;
   int num_modified = 0;
 
   // Iterate over all initial sync data, and update it locally. This means that
   // the value from the server always wins over a local value.
   for (const SyncData& sync_data : initial_sync_data) {
     DCHECK_EQ(SUPERVISED_USER_SHARED_SETTINGS, sync_data.GetDataType());
     const ::sync_pb::ManagedUserSharedSettingSpecifics&
         supervised_user_shared_setting =
             sync_data.GetSpecifics().managed_user_shared_setting();
-    scoped_ptr<Value> value =
+    std::unique_ptr<Value> value =
         base::JSONReader::Read(supervised_user_shared_setting.value());
     const std::string& su_id = supervised_user_shared_setting.mu_id();
     ScopedSupervisedUserSharedSettingsUpdate update(prefs_, su_id);
     const std::string& key = supervised_user_shared_setting.key();
     DictionaryValue* dict = FindOrCreateDictionary(update.Get(), key);
     dict->SetWithoutPathExpansion(kValue, value.release());
 
     // Every setting we get from the server should have the acknowledged flag
     // set.
     DCHECK(supervised_user_shared_setting.acknowledged());
@@ skipping 99 matching lines @@
         if (has_key) {
           // If the supervised user already exists, it should be an update
           // action.
           DCHECK_EQ(SyncChange::ACTION_UPDATE, sync_change.change_type());
         } else {
           // Otherwise, it should be an add action.
           DCHECK_EQ(SyncChange::ACTION_ADD, sync_change.change_type());
           dict = new DictionaryValue;
           update_dict->SetWithoutPathExpansion(key, dict);
         }
-        scoped_ptr<Value> value =
+        std::unique_ptr<Value> value =
             base::JSONReader::Read(supervised_user_shared_setting.value());
         dict->SetWithoutPathExpansion(kValue, value.release());
         dict->SetBooleanWithoutPathExpansion(
             kAcknowledged, supervised_user_shared_setting.acknowledged());
         break;
       }
       case SyncChange::ACTION_DELETE: {
         if (has_key)
           update_dict->RemoveWithoutPathExpansion(key, nullptr);
         else
           NOTREACHED() << "Trying to delete nonexistent key " << key;
         break;
       }
       case SyncChange::ACTION_INVALID: {
         NOTREACHED();
         break;
       }
     }
     callbacks_.Notify(su_id, key);
   }
 
   SyncError error;
   return error;
 }