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

chrome/browser/extensions/chrome_extensions_browser_client.cc

 // Copyright 2013 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/chrome_extensions_browser_client.h"
 
 #include <utility>
 
 #include "base/command_line.h"
+#include "base/memory/ptr_util.h"
 #include "base/version.h"
 #include "build/build_config.h"
 #include "chrome/browser/app_mode/app_mode_utils.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/activity_log/activity_log.h"
 #include "chrome/browser/extensions/api/chrome_extensions_api_client.h"
 #include "chrome/browser/extensions/api/content_settings/content_settings_service.h"
 #include "chrome/browser/extensions/api/generated_api_registration.h"
 #include "chrome/browser/extensions/api/preference/chrome_direct_setting.h"
 #include "chrome/browser/extensions/api/preference/preference_api.h"
@@ skipping 162 matching lines @@
     content::BrowserContext* context,
     std::vector<ExtensionPrefsObserver*>* observers) const {
   observers->push_back(ContentSettingsService::Get(context));
 }
 
 ProcessManagerDelegate*
 ChromeExtensionsBrowserClient::GetProcessManagerDelegate() const {
   return process_manager_delegate_.get();
 }
 
-scoped_ptr<ExtensionHostDelegate>
+std::unique_ptr<ExtensionHostDelegate>
 ChromeExtensionsBrowserClient::CreateExtensionHostDelegate() {
-  return scoped_ptr<ExtensionHostDelegate>(new ChromeExtensionHostDelegate);
+  return std::unique_ptr<ExtensionHostDelegate>(
+      new ChromeExtensionHostDelegate);
 }
 
 bool ChromeExtensionsBrowserClient::DidVersionUpdate(
     content::BrowserContext* context) {
   Profile* profile = static_cast<Profile*>(context);
 
   // Unit tests may not provide prefs; assume everything is up-to-date.
   ExtensionPrefs* extension_prefs = ExtensionPrefs::Get(profile);
   if (!extension_prefs)
     return false;
@@ skipping 70 matching lines @@
   api::ChromeGeneratedFunctionRegistry::RegisterAll(registry);
 }
 
 void ChromeExtensionsBrowserClient::RegisterMojoServices(
     content::RenderFrameHost* render_frame_host,
     const Extension* extension) const {
   RegisterServicesForFrame(render_frame_host, extension);
   RegisterChromeServicesForFrame(render_frame_host, extension);
 }
 
-scoped_ptr<RuntimeAPIDelegate>
+std::unique_ptr<RuntimeAPIDelegate>
 ChromeExtensionsBrowserClient::CreateRuntimeAPIDelegate(
     content::BrowserContext* context) const {
-  return scoped_ptr<RuntimeAPIDelegate>(new ChromeRuntimeAPIDelegate(context));
+  return std::unique_ptr<RuntimeAPIDelegate>(
+      new ChromeRuntimeAPIDelegate(context));
 }
 
 const ComponentExtensionResourceManager*
 ChromeExtensionsBrowserClient::GetComponentExtensionResourceManager() {
   return resource_manager_.get();
 }
 
 void ChromeExtensionsBrowserClient::BroadcastEventToRenderers(
     events::HistogramValue histogram_value,
     const std::string& event_name,
-    scoped_ptr<base::ListValue> args) {
+    std::unique_ptr<base::ListValue> args) {
   g_browser_process->extension_event_router_forwarder()
       ->BroadcastEventToRenderers(histogram_value, event_name, std::move(args),
                                   GURL());
 }
 
 net::NetLog* ChromeExtensionsBrowserClient::GetNetLog() {
   return g_browser_process->net_log();
 }
 
 ExtensionCache* ChromeExtensionsBrowserClient::GetExtensionCache() {
   if (!extension_cache_.get()) {
 #if defined(OS_CHROMEOS)
     extension_cache_.reset(new ExtensionCacheImpl(
-        make_scoped_ptr(new ChromeOSExtensionCacheDelegate())));
+        base::WrapUnique(new ChromeOSExtensionCacheDelegate())));
 #else
     extension_cache_.reset(new NullExtensionCache());
 #endif
   }
   return extension_cache_.get();
 }
 
 bool ChromeExtensionsBrowserClient::IsBackgroundUpdateAllowed() {
   return !base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableBackgroundNetworking);
@@ skipping 12 matching lines @@
 }
 
 ExtensionWebContentsObserver*
 ChromeExtensionsBrowserClient::GetExtensionWebContentsObserver(
     content::WebContents* web_contents) {
   return ChromeExtensionWebContentsObserver::FromWebContents(web_contents);
 }
 
 void ChromeExtensionsBrowserClient::ReportError(
     content::BrowserContext* context,
-    scoped_ptr<ExtensionError> error) {
+    std::unique_ptr<ExtensionError> error) {
   ErrorConsole::Get(context)->ReportError(std::move(error));
 }
 
 void ChromeExtensionsBrowserClient::CleanUpWebView(
     content::BrowserContext* browser_context,
     int embedder_process_id,
     int view_instance_id) {
   // Clean up context menus for the WebView.
   auto menu_manager =
       MenuManager::Get(Profile::FromBrowserContext(browser_context));
@@ skipping 38 matching lines @@
 scoped_refptr<update_client::UpdateClient>
 ChromeExtensionsBrowserClient::CreateUpdateClient(
     content::BrowserContext* context) {
   return update_client::UpdateClientFactory(
       make_scoped_refptr(new ChromeUpdateClientConfig(context)));
 }
 
 std::unique_ptr<ExtensionApiFrameIdMapHelper>
 ChromeExtensionsBrowserClient::CreateExtensionApiFrameIdMapHelper(
     ExtensionApiFrameIdMap* map) {
-  return make_scoped_ptr(new ChromeExtensionApiFrameIdMapHelper(map));
+  return base::WrapUnique(new ChromeExtensionApiFrameIdMapHelper(map));
 }
 
 }  // namespace extensions