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

extensions/browser/extension_function_dispatcher.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 "extensions/browser/extension_function_dispatcher.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/json/json_string_value_serializer.h"
@@ skipping 33 matching lines @@
 using content::BrowserThread;
 using content::RenderViewHost;
 
 namespace extensions {
 namespace {
 
 // Notifies the ApiActivityMonitor that an extension API function has been
 // called. May be called from any thread.
 void NotifyApiFunctionCalled(const std::string& extension_id,
                              const std::string& api_name,
-                             scoped_ptr<base::ListValue> args,
+                             std::unique_ptr<base::ListValue> args,
                              content::BrowserContext* browser_context) {
   // The ApiActivityMonitor can only be accessed from the main (UI) thread. If
   // we're running on the wrong thread, re-dispatch from the main thread.
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(BrowserThread::UI,
                             FROM_HERE,
                             base::Bind(&NotifyApiFunctionCalled,
                                        extension_id,
                                        api_name,
                                        base::Passed(&args),
                                        browser_context));
     return;
   }
   // The BrowserContext may become invalid after the task above is posted.
   if (!ExtensionsBrowserClient::Get()->IsValidContext(browser_context))
     return;
 
   ApiActivityMonitor* monitor =
       ExtensionsBrowserClient::Get()->GetApiActivityMonitor(browser_context);
   if (monitor)
     monitor->OnApiFunctionCalled(extension_id, api_name, std::move(args));
 }
 
 // Separate copy of ExtensionAPI used for IO thread extension functions. We need
 // this because ExtensionAPI has mutable data. It should be possible to remove
 // this once all the extension APIs are updated to the feature system.
 struct Static {
   Static() : api(ExtensionAPI::CreateWithDefaultConfiguration()) {}
-  scoped_ptr<ExtensionAPI> api;
+  std::unique_ptr<ExtensionAPI> api;
 };
 base::LazyInstance<Static> g_global_io_data = LAZY_INSTANCE_INITIALIZER;
 
 // Kills the specified process because it sends us a malformed message.
 // Track the specific function's |histogram_value|, as this may indicate a bug
 // in that API's implementation on the renderer.
 void KillBadMessageSender(const base::Process& process,
                           functions::HistogramValue histogram_value) {
   NOTREACHED();
   content::RecordAction(base::UserMetricsAction("BadMessageTerminate_EFD"));
@@ skipping 183 matching lines @@
     function->Run()->Execute();
     return;
   }
 
   QuotaService* quota = extension_info_map->GetQuotaService();
   std::string violation_error = quota->Assess(extension->id(),
                                               function.get(),
                                               &params.arguments,
                                               base::TimeTicks::Now());
   if (violation_error.empty()) {
-    scoped_ptr<base::ListValue> args(params.arguments.DeepCopy());
+    std::unique_ptr<base::ListValue> args(params.arguments.DeepCopy());
     NotifyApiFunctionCalled(extension->id(), params.name, std::move(args),
                             static_cast<content::BrowserContext*>(profile_id));
     UMA_HISTOGRAM_SPARSE_SLOWLY("Extensions.FunctionCalls",
                                 function->histogram_value());
     tracked_objects::ScopedProfile scoped_profile(
         FROM_HERE_WITH_EXPLICIT_FUNCTION(function->name()),
         tracked_objects::ScopedProfile::ENABLED);
     function->Run()->Execute();
   } else {
     function->OnQuotaExceeded(violation_error);
@@ skipping 86 matching lines @@
   ProcessManager* process_manager = ProcessManager::Get(browser_context_);
 
   ExtensionSystem* extension_system = ExtensionSystem::Get(browser_context_);
   QuotaService* quota = extension_system->quota_service();
   std::string violation_error = quota->Assess(extension->id(),
                                               function.get(),
                                               &params.arguments,
                                               base::TimeTicks::Now());
 
   if (violation_error.empty()) {
-    scoped_ptr<base::ListValue> args(params.arguments.DeepCopy());
+    std::unique_ptr<base::ListValue> args(params.arguments.DeepCopy());
 
     // See crbug.com/39178.
     ExtensionsBrowserClient::Get()->PermitExternalProtocolHandler();
     NotifyApiFunctionCalled(extension->id(), params.name, std::move(args),
                             browser_context_);
     UMA_HISTOGRAM_SPARSE_SLOWLY("Extensions.FunctionCalls",
                                 function->histogram_value());
     tracked_objects::ScopedProfile scoped_profile(
         FROM_HERE_WITH_EXPLICIT_FUNCTION(function->name()),
         tracked_objects::ScopedProfile::ENABLED);
@@ skipping 89 matching lines @@
 // static
 void ExtensionFunctionDispatcher::SendAccessDenied(
     const ExtensionFunction::ResponseCallback& callback,
     functions::HistogramValue histogram_value) {
   base::ListValue empty_list;
   callback.Run(ExtensionFunction::FAILED, empty_list,
                "Access to extension API denied.", histogram_value);
 }
 
 }  // namespace extensions