Convert Pass()→std::move() in //chrome/browser/extensions

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 <stddef.h>
 #include <stdint.h>
+#include <utility>
 
 #include "base/callback.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 289 matching lines @@
   scoped_ptr<base::ListValue> args(new base::ListValue());
   base::DictionaryValue* process = CreateProcessFromModel(
       model_->GetUniqueChildProcessId(index), model_, index, false);
   DCHECK(process != NULL);
 
   if (process == NULL)
     return;
 
   args->Append(process);
 
-  DispatchEvent(events::PROCESSES_ON_CREATED, keys::kOnCreated, args.Pass());
+  DispatchEvent(events::PROCESSES_ON_CREATED, keys::kOnCreated,
+                std::move(args));
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void ProcessesEventRouter::OnItemsChanged(int start, int length) {
 #if defined(ENABLE_TASK_MANAGER)
   // If we don't have any listeners, return immediately.
   if (listeners_ == 0)
     return;
 
   if (!model_)
@@ skipping 27 matching lines @@
     for (; !it.IsAtEnd(); it.Advance()) {
       if (!it.GetCurrentValue()->GetInteger(idkey, &id))
         continue;
 
       // Store each process indexed by the string version of its id.
       processes->Set(base::IntToString(id), it.GetCurrentValue());
     }
 
     scoped_ptr<base::ListValue> args(new base::ListValue());
     args->Append(processes);
-    DispatchEvent(events::PROCESSES_ON_UPDATED, keys::kOnUpdated, args.Pass());
+    DispatchEvent(events::PROCESSES_ON_UPDATED, keys::kOnUpdated,
+                  std::move(args));
   }
 
   if (updated_memory) {
     IDMap<base::DictionaryValue>::iterator it(&processes_map);
     for (; !it.IsAtEnd(); it.Advance()) {
       if (!it.GetCurrentValue()->GetInteger(idkey, &id))
         continue;
 
       AddMemoryDetails(it.GetCurrentValue(), model_, it.GetCurrentKey());
 
       // Store each process indexed by the string version of its id if we didn't
       // already insert it as part of the onUpdated processing above.
       if (!updated)
         processes->Set(base::IntToString(id), it.GetCurrentValue());
     }
 
     scoped_ptr<base::ListValue> args(new base::ListValue());
     args->Append(processes);
     DispatchEvent(events::PROCESSES_ON_UPDATED_WITH_MEMORY,
-                  keys::kOnUpdatedWithMemory, args.Pass());
+                  keys::kOnUpdatedWithMemory, std::move(args));
   }
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void ProcessesEventRouter::OnItemsToBeRemoved(int start, int length) {
 #if defined(ENABLE_TASK_MANAGER)
   DCHECK_EQ(length, 1);
 
   // Process exit for renderer processes has the data about exit code and
   // termination status, therefore we will rely on notifications and not on
   // the Task Manager data. We do use the rest of this method for non-renderer
   // processes.
   if (model_->GetResourceType(start) == task_manager::Resource::RENDERER)
     return;
 
   // The callback function parameters.
   scoped_ptr<base::ListValue> args(new base::ListValue());
 
   // First arg: The id of the process that was closed.
   args->Append(new base::FundamentalValue(
       model_->GetUniqueChildProcessId(start)));
 
   // Second arg: The exit type for the process.
   args->Append(new base::FundamentalValue(0));
 
   // Third arg: The exit code for the process.
   args->Append(new base::FundamentalValue(0));
 
-  DispatchEvent(events::PROCESSES_ON_EXITED, keys::kOnExited, args.Pass());
+  DispatchEvent(events::PROCESSES_ON_EXITED, keys::kOnExited, std::move(args));
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void ProcessesEventRouter::ProcessHangEvent(content::RenderWidgetHost* widget) {
 #if defined(ENABLE_TASK_MANAGER)
   std::string event(keys::kOnUnresponsive);
   if (!HasEventListeners(event))
     return;
 
   base::DictionaryValue* process = NULL;
   int count = model_->ResourceCount();
   int id = widget->GetProcess()->GetID();
 
   for (int i = 0; i < count; ++i) {
     if (model_->IsResourceFirstInGroup(i)) {
       if (id == model_->GetUniqueChildProcessId(i)) {
         process = CreateProcessFromModel(id, model_, i, false);
         break;
       }
     }
   }
 
   if (process == NULL)
     return;
 
   scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(process);
 
   DispatchEvent(events::PROCESSES_ON_UNRESPONSIVE, keys::kOnUnresponsive,
-                args.Pass());
+                std::move(args));
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void ProcessesEventRouter::ProcessClosedEvent(
     content::RenderProcessHost* rph,
     content::RenderProcessHost::RendererClosedDetails* details) {
 #if defined(ENABLE_TASK_MANAGER)
   // The callback function parameters.
   scoped_ptr<base::ListValue> args(new base::ListValue());
 
   // First arg: The id of the process that was closed.
   args->Append(new base::FundamentalValue(rph->GetID()));
 
   // Second arg: The exit type for the process.
   args->Append(new base::FundamentalValue(details->status));
 
   // Third arg: The exit code for the process.
   args->Append(new base::FundamentalValue(details->exit_code));
 
-  DispatchEvent(events::PROCESSES_ON_EXITED, keys::kOnExited, args.Pass());
+  DispatchEvent(events::PROCESSES_ON_EXITED, keys::kOnExited, std::move(args));
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void ProcessesEventRouter::DispatchEvent(
     events::HistogramValue histogram_value,
     const std::string& event_name,
     scoped_ptr<base::ListValue> event_args) {
   EventRouter* event_router = EventRouter::Get(browser_context_);
   if (event_router) {
     scoped_ptr<Event> event(
-        new Event(histogram_value, event_name, event_args.Pass()));
-    event_router->BroadcastEvent(event.Pass());
+        new Event(histogram_value, event_name, std::move(event_args)));
+    event_router->BroadcastEvent(std::move(event));
   }
 }
 
 bool ProcessesEventRouter::HasEventListeners(const std::string& event_name) {
   EventRouter* event_router = EventRouter::Get(browser_context_);
   return event_router && event_router->HasEventListener(event_name);
 }
 
 ProcessesAPI::ProcessesAPI(content::BrowserContext* context)
     : browser_context_(context) {
@@ skipping 285 matching lines @@
 
   SetResult(processes);
   SendResponse(true);
 
   // Balance the AddRef in the RunAsync.
   Release();
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 }  // namespace extensions