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

chrome/browser/supervised_user/supervised_user_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/supervised_user_settings_service.h"
 
 #include <stddef.h>
+
 #include <utility>
 
 #include "base/callback.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/supervised_user/supervised_user_url_filter.h"
 #include "chrome/common/chrome_constants.h"
 #include "components/prefs/json_pref_store.h"
 #include "components/prefs/pref_filter.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/user_metrics.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_error_factory.h"
@@ skipping 38 matching lines @@
 }
 
 SupervisedUserSettingsService::~SupervisedUserSettingsService() {}
 
 void SupervisedUserSettingsService::Init(
     base::FilePath profile_path,
     base::SequencedTaskRunner* sequenced_task_runner,
     bool load_synchronously) {
   base::FilePath path =
       profile_path.Append(chrome::kSupervisedUserSettingsFilename);
-  PersistentPrefStore* store = new JsonPrefStore(
-      path, sequenced_task_runner, scoped_ptr<PrefFilter>());
+  PersistentPrefStore* store = new JsonPrefStore(path, sequenced_task_runner,
+                                                 std::unique_ptr<PrefFilter>());
   Init(store);
   if (load_synchronously) {
     store_->ReadPrefs();
     // TODO(bauerb): Temporary CHECK while investigating
     // https://crbug.com/425785. Remove (or change to DCHECK) once the bug
     // is fixed.
     CHECK(store_->IsInitializationComplete());
   } else {
     store_->ReadPrefsAsync(nullptr);
   }
 }
 
 void SupervisedUserSettingsService::Init(
     scoped_refptr<PersistentPrefStore> store) {
   DCHECK(!store_.get());
   store_ = store;
   store_->AddObserver(this);
 }
 
-scoped_ptr<SupervisedUserSettingsService::SettingsCallbackList::Subscription>
-    SupervisedUserSettingsService::Subscribe(
-    const SettingsCallback& callback) {
+std::unique_ptr<
+    SupervisedUserSettingsService::SettingsCallbackList::Subscription>
+SupervisedUserSettingsService::Subscribe(const SettingsCallback& callback) {
   if (IsReady()) {
-    scoped_ptr<base::DictionaryValue> settings = GetSettings();
+    std::unique_ptr<base::DictionaryValue> settings = GetSettings();
     callback.Run(settings.get());
   }
 
   return callback_list_.Add(callback);
 }
 
 Profile* SupervisedUserSettingsService::GetProfile(){
   return profile_;
 }
 
@@ skipping 15 matching lines @@
                       WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
 }
 
 // static
 std::string SupervisedUserSettingsService::MakeSplitSettingKey(
     const std::string& prefix,
     const std::string& key) {
   return prefix + kSplitSettingKeySeparator + key;
 }
 
-void SupervisedUserSettingsService::UploadItem(const std::string& key,
-                                               scoped_ptr<base::Value> value) {
+void SupervisedUserSettingsService::UploadItem(
+    const std::string& key,
+    std::unique_ptr<base::Value> value) {
   DCHECK(!SettingShouldApplyToPrefs(key));
 
   std::string key_suffix = key;
   base::DictionaryValue* dict = nullptr;
   if (sync_processor_) {
     content::RecordAction(UserMetricsAction("ManagedUsers_UploadItem_Syncing"));
     dict = GetDictionaryAndSplitKey(&key_suffix);
     DCHECK(GetQueuedItems()->empty());
     SyncChangeList change_list;
     SyncData data = CreateSyncDataForSetting(key, *value);
     SyncChange::SyncChangeType change_type =
         dict->HasKey(key_suffix) ? SyncChange::ACTION_UPDATE
                                  : SyncChange::ACTION_ADD;
     change_list.push_back(SyncChange(FROM_HERE, change_type, data));
     SyncError error =
         sync_processor_->ProcessSyncChanges(FROM_HERE, change_list);
     DCHECK(!error.IsSet()) << error.ToString();
   } else {
     // Queue the item up to be uploaded when we start syncing
     // (in MergeDataAndStartSyncing()).
     content::RecordAction(UserMetricsAction("ManagedUsers_UploadItem_Queued"));
     dict = GetQueuedItems();
   }
   dict->SetWithoutPathExpansion(key_suffix, value.release());
 }
 
 void SupervisedUserSettingsService::SetLocalSetting(
     const std::string& key,
-    scoped_ptr<base::Value> value) {
+    std::unique_ptr<base::Value> value) {
   if (value)
     local_settings_->SetWithoutPathExpansion(key, value.release());
   else
     local_settings_->RemoveWithoutPathExpansion(key, nullptr);
 
   InformSubscribers();
 }
 
 // static
 SyncData SupervisedUserSettingsService::CreateSyncDataForSetting(
     const std::string& name,
     const base::Value& value) {
   std::string json_value;
   base::JSONWriter::Write(value, &json_value);
   ::sync_pb::EntitySpecifics specifics;
   specifics.mutable_managed_user_setting()->set_name(name);
   specifics.mutable_managed_user_setting()->set_value(json_value);
   return SyncData::CreateLocalData(name, name, specifics);
 }
 
 void SupervisedUserSettingsService::Shutdown() {
   store_->RemoveObserver(this);
 }
 
 SyncMergeResult SupervisedUserSettingsService::MergeDataAndStartSyncing(
     ModelType type,
     const SyncDataList& initial_sync_data,
-    scoped_ptr<SyncChangeProcessor> sync_processor,
-    scoped_ptr<SyncErrorFactory> error_handler) {
+    std::unique_ptr<SyncChangeProcessor> sync_processor,
+    std::unique_ptr<SyncErrorFactory> error_handler) {
   DCHECK_EQ(SUPERVISED_USER_SETTINGS, type);
   sync_processor_ = std::move(sync_processor);
   error_handler_ = std::move(error_handler);
 
   std::set<std::string> seen_keys;
   int num_before_association = 0;
   // Getting number of atomic setting items.
   num_before_association = GetAtomicSettings()->size();
   for (base::DictionaryValue::Iterator it(*GetAtomicSettings()); !it.IsAtEnd();
        it.Advance()) {
@@ skipping 18 matching lines @@
 
   // Clear all atomic and split settings, then recreate them from Sync data.
   Clear();
   int num_added = 0;
   int num_modified = 0;
   std::set<std::string> added_sync_keys;
   for (const SyncData& sync_data : initial_sync_data) {
     DCHECK_EQ(SUPERVISED_USER_SETTINGS, sync_data.GetDataType());
     const ::sync_pb::ManagedUserSettingSpecifics& supervised_user_setting =
         sync_data.GetSpecifics().managed_user_setting();
-    scoped_ptr<base::Value> value =
+    std::unique_ptr<base::Value> value =
         JSONReader::Read(supervised_user_setting.value());
     std::string name_suffix = supervised_user_setting.name();
     std::string name_key = name_suffix;
     base::DictionaryValue* dict = GetDictionaryAndSplitKey(&name_suffix);
     dict->SetWithoutPathExpansion(name_suffix, value.release());
     if (seen_keys.find(name_key) == seen_keys.end()) {
       added_sync_keys.insert(name_key);
       num_added++;
     } else {
       num_modified++;
@@ skipping 95 matching lines @@
     SyncData data = sync_change.sync_data();
     DCHECK_EQ(SUPERVISED_USER_SETTINGS, data.GetDataType());
     const ::sync_pb::ManagedUserSettingSpecifics& supervised_user_setting =
         data.GetSpecifics().managed_user_setting();
     std::string key = supervised_user_setting.name();
     base::DictionaryValue* dict = GetDictionaryAndSplitKey(&key);
     SyncChange::SyncChangeType change_type = sync_change.change_type();
     switch (change_type) {
       case SyncChange::ACTION_ADD:
       case SyncChange::ACTION_UPDATE: {
-        scoped_ptr<base::Value> value =
+        std::unique_ptr<base::Value> value =
             JSONReader::Read(supervised_user_setting.value());
         if (dict->HasKey(key)) {
           DLOG_IF(WARNING, change_type == SyncChange::ACTION_ADD)
               << "Value for key " << key << " already exists";
         } else {
           DLOG_IF(WARNING, change_type == SyncChange::ACTION_UPDATE)
               << "Value for key " << key << " doesn't exist yet";
         }
         dict->SetWithoutPathExpansion(key, value.release());
         break;
@@ skipping 40 matching lines @@
 
 base::DictionaryValue* SupervisedUserSettingsService::GetOrCreateDictionary(
     const std::string& key) const {
   base::Value* value = nullptr;
   base::DictionaryValue* dict = nullptr;
   if (store_->GetMutableValue(key, &value)) {
     bool success = value->GetAsDictionary(&dict);
     DCHECK(success);
   } else {
     dict = new base::DictionaryValue;
-    store_->SetValue(key, make_scoped_ptr(dict),
+    store_->SetValue(key, base::WrapUnique(dict),
                      WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   }
 
   return dict;
 }
 
 base::DictionaryValue*
 SupervisedUserSettingsService::GetAtomicSettings() const {
   return GetOrCreateDictionary(kAtomicSettings);
 }
@@ skipping 17 matching lines @@
   base::DictionaryValue* dict = nullptr;
   if (!split_settings->GetDictionary(prefix, &dict)) {
     dict = new base::DictionaryValue;
     DCHECK(!split_settings->HasKey(prefix));
     split_settings->Set(prefix, dict);
   }
   key->erase(0, pos + 1);
   return dict;
 }
 
-scoped_ptr<base::DictionaryValue> SupervisedUserSettingsService::GetSettings() {
+std::unique_ptr<base::DictionaryValue>
+SupervisedUserSettingsService::GetSettings() {
   DCHECK(IsReady());
   if (!active_ || initialization_failed_)
-    return scoped_ptr<base::DictionaryValue>();
+    return std::unique_ptr<base::DictionaryValue>();
 
-  scoped_ptr<base::DictionaryValue> settings(local_settings_->DeepCopy());
+  std::unique_ptr<base::DictionaryValue> settings(local_settings_->DeepCopy());
 
   base::DictionaryValue* atomic_settings = GetAtomicSettings();
   for (base::DictionaryValue::Iterator it(*atomic_settings); !it.IsAtEnd();
        it.Advance()) {
     if (!SettingShouldApplyToPrefs(it.key()))
       continue;
 
     settings->Set(it.key(), it.value().DeepCopy());
   }
 
   base::DictionaryValue* split_settings = GetSplitSettings();
   for (base::DictionaryValue::Iterator it(*split_settings); !it.IsAtEnd();
        it.Advance()) {
     if (!SettingShouldApplyToPrefs(it.key()))
       continue;
 
     settings->Set(it.key(), it.value().DeepCopy());
   }
 
   return settings;
 }
 
 void SupervisedUserSettingsService::InformSubscribers() {
   if (!IsReady())
     return;
 
-  scoped_ptr<base::DictionaryValue> settings = GetSettings();
+  std::unique_ptr<base::DictionaryValue> settings = GetSettings();
   callback_list_.Notify(settings.get());
 }