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

chrome/browser/extensions/api/preference/preference_api.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/extensions/api/preference/preference_api.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <utility>
@@ skipping 324 matching lines @@
 
   // Mapping from extension pref keys to browser pref keys and permissions.
   PrefMap mapping_;
 
   // Mapping from browser pref keys to extension event names and permissions.
   PrefMap event_mapping_;
 
   // Mapping from browser pref keys to transformers.
   std::map<std::string, PrefTransformerInterface*> transformers_;
 
-  scoped_ptr<PrefTransformerInterface> identity_transformer_;
+  std::unique_ptr<PrefTransformerInterface> identity_transformer_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefMapping);
 };
 
 }  // namespace
 
 PreferenceEventRouter::PreferenceEventRouter(Profile* profile)
     : profile_(profile) {
   registrar_.Init(profile_->GetPrefs());
   incognito_registrar_.Init(profile_->GetOffTheRecordPrefs());
@@ skipping 275 matching lines @@
   if (!ValidateBrowserPref(
           pref_key, PreferenceFunction::PERMISSION_TYPE_READ, &browser_pref)) {
     return false;
   }
   PrefService* prefs = incognito ? GetProfile()->GetOffTheRecordPrefs()
                                  : GetProfile()->GetPrefs();
   const PrefService::Preference* pref =
       prefs->FindPreference(browser_pref.c_str());
   CHECK(pref);
 
-  scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue);
 
   // Retrieve level of control.
   std::string level_of_control = helpers::GetLevelOfControl(
       GetProfile(), extension_id(), browser_pref, incognito);
   result->SetString(keys::kLevelOfControl, level_of_control);
 
   // Retrieve pref value.
   PrefTransformerInterface* transformer =
       PrefMapping::GetInstance()->FindTransformerForBrowserPref(browser_pref);
   base::Value* transformed_value =
@@ skipping 71 matching lines @@
   ExtensionPrefs* prefs = ExtensionPrefs::Get(GetProfile());
   const PrefService::Preference* pref =
       prefs->pref_service()->FindPreference(browser_pref.c_str());
   CHECK(pref);
 
   // Validate new value.
   PrefTransformerInterface* transformer =
       PrefMapping::GetInstance()->FindTransformerForBrowserPref(browser_pref);
   std::string error;
   bool bad_message = false;
-  scoped_ptr<base::Value> browser_pref_value(
+  std::unique_ptr<base::Value> browser_pref_value(
       transformer->ExtensionToBrowserPref(value, &error, &bad_message));
   if (!browser_pref_value) {
     error_ = error;
     bad_message_ = bad_message;
     return false;
   }
   EXTENSION_FUNCTION_VALIDATE(browser_pref_value->GetType() == pref->GetType());
 
   // Validate also that the stored value can be converted back by the
   // transformer.
-  scoped_ptr<base::Value> extensionPrefValue(
+  std::unique_ptr<base::Value> extensionPrefValue(
       transformer->BrowserToExtensionPref(browser_pref_value.get()));
   if (!extensionPrefValue) {
     error_ =  ErrorUtils::FormatErrorMessage(kConversionErrorMessage,
                                                       pref->name());
     bad_message_ = true;
     return false;
   }
 
   PreferenceAPI::Get(GetProfile())->SetExtensionControlledPref(
       extension_id(), browser_pref, scope, browser_pref_value.release());
@@ skipping 38 matching lines @@
           pref_key, PreferenceFunction::PERMISSION_TYPE_WRITE, &browser_pref)) {
     return false;
   }
 
   PreferenceAPI::Get(GetProfile())
       ->RemoveExtensionControlledPref(extension_id(), browser_pref, scope);
   return true;
 }
 
 }  // namespace extensions