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

chrome/browser/extensions/api/processes/processes_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/processes/processes_api.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 
@@ skipping 38 matching lines @@
 // This does not include memory. The memory refresh flag will only be added once
 // a listener to OnUpdatedWithMemory event is added.
 int64_t GetRefreshTypesForProcessOptionalData() {
   return task_management::REFRESH_TYPE_CPU |
       task_management::REFRESH_TYPE_NETWORK_USAGE |
       task_management::REFRESH_TYPE_SQLITE_MEMORY |
       task_management::REFRESH_TYPE_V8_MEMORY |
       task_management::REFRESH_TYPE_WEBCACHE_STATS;
 }
 
-scoped_ptr<api::processes::Cache> CreateCacheData(
+std::unique_ptr<api::processes::Cache> CreateCacheData(
     const blink::WebCache::ResourceTypeStat& stat) {
-  scoped_ptr<api::processes::Cache> cache(new api::processes::Cache());
+  std::unique_ptr<api::processes::Cache> cache(new api::processes::Cache());
   cache->size = static_cast<double>(stat.size);
   cache->live_size = static_cast<double>(stat.liveSize);
   return cache;
 }
 
 api::processes::ProcessType GetProcessType(
     task_management::Task::Type task_type) {
   switch (task_type) {
     case task_management::Task::BROWSER:
       return api::processes::PROCESS_TYPE_BROWSER;
@@ skipping 246 matching lines @@
                   false,  // include_optional
                   &process);
   DispatchEvent(events::PROCESSES_ON_UNRESPONSIVE,
                 api::processes::OnUnresponsive::kEventName,
                 api::processes::OnUnresponsive::Create(process));
 }
 
 void ProcessesEventRouter::DispatchEvent(
     events::HistogramValue histogram_value,
     const std::string& event_name,
-    scoped_ptr<base::ListValue> event_args) const {
+    std::unique_ptr<base::ListValue> event_args) const {
   EventRouter* event_router = EventRouter::Get(browser_context_);
   if (event_router) {
-    scoped_ptr<Event> event(
+    std::unique_ptr<Event> event(
         new Event(histogram_value, event_name, std::move(event_args)));
     event_router->BroadcastEvent(std::move(event));
   }
 }
 
 bool ProcessesEventRouter::HasEventListeners(
     const std::string& event_name) const {
   EventRouter* event_router = EventRouter::Get(browser_context_);
   return event_router && event_router->HasEventListener(event_name);
 }
@@ skipping 91 matching lines @@
     processes_event_router_.reset(new ProcessesEventRouter(browser_context_));
   return processes_event_router_.get();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ProcessesGetProcessIdForTabFunction:
 ////////////////////////////////////////////////////////////////////////////////
 
 ExtensionFunction::ResponseAction ProcessesGetProcessIdForTabFunction::Run() {
   // For this function, the task manager doesn't even need to be running.
-  scoped_ptr<api::processes::GetProcessIdForTab::Params> params(
+  std::unique_ptr<api::processes::GetProcessIdForTab::Params> params(
       api::processes::GetProcessIdForTab::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   const int tab_id = params->tab_id;
   content::WebContents* contents = nullptr;
   int tab_index = -1;
   if (!ExtensionTabUtil::GetTabById(
           tab_id,
           Profile::FromBrowserContext(browser_context()),
           include_incognito(),
@@ skipping 11 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ProcessesTerminateFunction:
 ////////////////////////////////////////////////////////////////////////////////
 
 ExtensionFunction::ResponseAction ProcessesTerminateFunction::Run() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // For this function, the task manager doesn't even need to be running.
-  scoped_ptr<api::processes::Terminate::Params> params(
+  std::unique_ptr<api::processes::Terminate::Params> params(
       api::processes::Terminate::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   child_process_host_id_ = params->process_id;
   if (child_process_host_id_ < 0) {
     return RespondNow(Error(errors::kInvalidArgument,
                             base::IntToString(child_process_host_id_)));
   } else if (child_process_host_id_ == 0) {
     // Cannot kill the browser process.
     return RespondNow(Error(errors::kNotAllowedToTerminate,
@@ skipping 71 matching lines @@
 // ProcessesGetProcessInfoFunction:
 ////////////////////////////////////////////////////////////////////////////////
 
 ProcessesGetProcessInfoFunction::ProcessesGetProcessInfoFunction()
     : task_management::TaskManagerObserver(
           base::TimeDelta::FromSeconds(1),
           GetRefreshTypesFlagOnlyEssentialData()) {
 }
 
 ExtensionFunction::ResponseAction ProcessesGetProcessInfoFunction::Run() {
-  scoped_ptr<api::processes::GetProcessInfo::Params> params(
+  std::unique_ptr<api::processes::GetProcessInfo::Params> params(
       api::processes::GetProcessInfo::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   if (params->process_ids.as_integer)
     process_host_ids_.push_back(*params->process_ids.as_integer);
   else
     process_host_ids_.swap(*params->process_ids.as_integers);
 
   include_memory_ = params->include_memory;
   if (include_memory_)
     AddRefreshType(task_management::REFRESH_TYPE_MEMORY);
@@ skipping 102 matching lines @@
   // Send the response.
   Respond(ArgumentList(
       api::processes::GetProcessInfo::Results::Create(processes)));
 
   // Stop observing the task manager, and balance the AddRef() in Run().
   task_management::TaskManagerInterface::GetTaskManager()->RemoveObserver(this);
   Release();
 }
 
 }  // namespace extensions