Migrate ResourceCoordinator to OnceCallback

This removes 'use_once_callback = false' flag from BUILD.gn from
services/resource_coordinator, and fixes all implementations of the
interface.

Bug: 714018, 729950
Change-Id: I203b0957fdc12da1829339f79d84210446ebad7e
Reviewed-on: https://chromium-review.googlesource.com/997064
Commit-Queue: Taiju Tsuiki <tzik@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Erik Chen <erikchen@chromium.org>
Cr-Commit-Position: refs/heads/master@{#550156}

components/services/heap_profiling/heap_profiling_service.cc

@@ -72,7 +72,7 @@ void HeapProfilingService::GetProfiledPids(GetProfiledPidsCallback callback) {
 
 void HeapProfilingService::DumpProcessesForTracing(
     bool strip_path_from_mapped_files,
-    const DumpProcessesForTracingCallback& callback) {
+    DumpProcessesForTracingCallback callback) {
   if (!helper_) {
     context()->connector()->BindInterface(
         resource_coordinator::mojom::kServiceName, &helper_);
@@ -88,16 +88,17 @@ void HeapProfilingService::DumpProcessesForTracing(
     // Need a memory map to make sense of the dump. The dump will be triggered
     // in the memory map global dump callback.
     helper_->GetVmRegionsForHeapProfiler(
-        pids, base::Bind(&HeapProfilingService::
-                             OnGetVmRegionsCompleteForDumpProcessesForTracing,
-                         weak_factory_.GetWeakPtr(),
-                         strip_path_from_mapped_files, callback));
+        pids,
+        base::BindOnce(&HeapProfilingService::
+                           OnGetVmRegionsCompleteForDumpProcessesForTracing,
+                       weak_factory_.GetWeakPtr(), strip_path_from_mapped_files,
+                       std::move(callback)));
   }
 }
 
 void HeapProfilingService::OnGetVmRegionsCompleteForDumpProcessesForTracing(
     bool strip_path_from_mapped_files,
-    const DumpProcessesForTracingCallback& callback,
+    DumpProcessesForTracingCallback callback,
     VmRegions vm_regions) {
   connection_manager_.DumpProcessesForTracing(
       keep_small_allocations_, strip_path_from_mapped_files,

components/services/heap_profiling/heap_profiling_service.h

@@ -54,7 +54,7 @@ class HeapProfilingService
   // HeapProfiler implementation.
   void DumpProcessesForTracing(
       bool strip_path_from_mapped_files,
-      const DumpProcessesForTracingCallback& callback) override;
+      DumpProcessesForTracingCallback callback) override;
 
  private:
   void OnProfilingServiceRequest(mojom::ProfilingServiceRequest request);
@@ -63,7 +63,7 @@ class HeapProfilingService
 
   void OnGetVmRegionsCompleteForDumpProcessesForTracing(
       bool strip_path_from_mapped_files,
-      const DumpProcessesForTracingCallback& callback,
+      DumpProcessesForTracingCallback callback,
       VmRegions vm_regions);
 
   service_manager::BinderRegistry registry_;

services/resource_coordinator/coordination_unit/coordination_unit_base.h

@@ -117,9 +117,8 @@ class CoordinationUnitInterface : public CoordinationUnitBase,
 
   void Bind(MojoRequestClass request) { binding_.Bind(std::move(request)); }
 
-  void GetID(
-      const typename MojoInterfaceClass::GetIDCallback& callback) override {
-    callback.Run(id_);
+  void GetID(typename MojoInterfaceClass::GetIDCallback callback) override {
+    std::move(callback).Run(id_);
   }
   void AddBinding(MojoRequestClass request) override {
     bindings_.AddBinding(this, std::move(request));

services/resource_coordinator/coordination_unit/coordination_unit_introspector_impl.cc

@@ -20,7 +20,7 @@ CoordinationUnitIntrospectorImpl::CoordinationUnitIntrospectorImpl() = default;
 CoordinationUnitIntrospectorImpl::~CoordinationUnitIntrospectorImpl() = default;
 
 void CoordinationUnitIntrospectorImpl::GetProcessToURLMap(
-    const GetProcessToURLMapCallback& callback) {
+    GetProcessToURLMapCallback callback) {
   std::vector<resource_coordinator::mojom::ProcessInfoPtr> process_infos;
   std::vector<ProcessCoordinationUnitImpl*> process_cus =
       ProcessCoordinationUnitImpl::GetAllProcessCoordinationUnits();
@@ -59,7 +59,7 @@ void CoordinationUnitIntrospectorImpl::GetProcessToURLMap(
     }
     process_infos.push_back(std::move(process_info));
   }
-  callback.Run(std::move(process_infos));
+  std::move(callback).Run(std::move(process_infos));
 }
 
 void CoordinationUnitIntrospectorImpl::BindToInterface(

services/resource_coordinator/coordination_unit/coordination_unit_introspector_impl.h

@@ -26,7 +26,7 @@ class CoordinationUnitIntrospectorImpl
       const service_manager::BindSourceInfo& source_info);
 
   // Overridden from mojom::CoordinationUnitIntrospector:
-  void GetProcessToURLMap(const GetProcessToURLMapCallback& callback) override;
+  void GetProcessToURLMap(GetProcessToURLMapCallback callback) override;
 
  private:
   mojo::BindingSet<mojom::CoordinationUnitIntrospector> bindings_;

services/resource_coordinator/memory_instrumentation/coordinator_impl.cc

@@ -112,57 +112,60 @@ void CoordinatorImpl::RequestGlobalMemoryDump(
     MemoryDumpType dump_type,
     MemoryDumpLevelOfDetail level_of_detail,
     const std::vector<std::string>& allocator_dump_names,
-    const RequestGlobalMemoryDumpCallback& callback) {
+    RequestGlobalMemoryDumpCallback callback) {
   // This merely strips out the |dump_guid| argument.
-  auto adapter = [](const RequestGlobalMemoryDumpCallback& callback,
-                    bool success, uint64_t,
-                    mojom::GlobalMemoryDumpPtr global_memory_dump) {
-    callback.Run(success, std::move(global_memory_dump));
+  auto adapter = [](RequestGlobalMemoryDumpCallback callback, bool success,
+                    uint64_t, mojom::GlobalMemoryDumpPtr global_memory_dump) {
+    std::move(callback).Run(success, std::move(global_memory_dump));
   };
 
   QueuedRequest::Args args(dump_type, level_of_detail, allocator_dump_names,
                            false /* add_to_trace */, base::kNullProcessId);
-  RequestGlobalMemoryDumpInternal(args, base::BindRepeating(adapter, callback));
+  RequestGlobalMemoryDumpInternal(args,
+                                  base::BindOnce(adapter, std::move(callback)));
 }
 
 void CoordinatorImpl::RequestGlobalMemoryDumpForPid(
     base::ProcessId pid,
-    const RequestGlobalMemoryDumpForPidCallback& callback) {
+    RequestGlobalMemoryDumpForPidCallback callback) {
   // Error out early if process id is null to avoid confusing with global
   // dump for all processes case when pid is kNullProcessId.
   if (pid == base::kNullProcessId) {
-    callback.Run(false, nullptr);
+    std::move(callback).Run(false, nullptr);
     return;
   }
 
   // This merely strips out the |dump_guid| argument; this is not relevant
   // as we are not adding to trace.
-  auto adapter = [](const RequestGlobalMemoryDumpForPidCallback& callback,
+  auto adapter = [](RequestGlobalMemoryDumpForPidCallback callback,
                     bool success, uint64_t,
                     mojom::GlobalMemoryDumpPtr global_memory_dump) {
-    callback.Run(success, std::move(global_memory_dump));
+    std::move(callback).Run(success, std::move(global_memory_dump));
   };
 
   QueuedRequest::Args args(
       base::trace_event::MemoryDumpType::SUMMARY_ONLY,
       base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND, {},
       false /* add_to_trace */, pid);
-  RequestGlobalMemoryDumpInternal(args, base::BindRepeating(adapter, callback));
+  RequestGlobalMemoryDumpInternal(args,
+                                  base::BindOnce(adapter, std::move(callback)));
 }
 
 void CoordinatorImpl::RequestGlobalMemoryDumpAndAppendToTrace(
     MemoryDumpType dump_type,
     MemoryDumpLevelOfDetail level_of_detail,
-    const RequestGlobalMemoryDumpAndAppendToTraceCallback& callback) {
+    RequestGlobalMemoryDumpAndAppendToTraceCallback callback) {
   // This merely strips out the |dump_ptr| argument.
-  auto adapter =
-      [](const RequestGlobalMemoryDumpAndAppendToTraceCallback& callback,
-         bool success, uint64_t dump_guid,
-         mojom::GlobalMemoryDumpPtr) { callback.Run(success, dump_guid); };
+  auto adapter = [](RequestGlobalMemoryDumpAndAppendToTraceCallback callback,
+                    bool success, uint64_t dump_guid,
+                    mojom::GlobalMemoryDumpPtr) {
+    std::move(callback).Run(success, dump_guid);
+  };
 
   QueuedRequest::Args args(dump_type, level_of_detail, {},
                            true /* add_to_trace */, base::kNullProcessId);
-  RequestGlobalMemoryDumpInternal(args, base::BindRepeating(adapter, callback));
+  RequestGlobalMemoryDumpInternal(args,
+                                  base::BindOnce(adapter, std::move(callback)));
 }
 
 void CoordinatorImpl::RegisterHeapProfiler(
@@ -173,11 +176,11 @@ void CoordinatorImpl::RegisterHeapProfiler(
 
 void CoordinatorImpl::GetVmRegionsForHeapProfiler(
     const std::vector<base::ProcessId>& pids,
-    const GetVmRegionsForHeapProfilerCallback& callback) {
+    GetVmRegionsForHeapProfilerCallback callback) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   uint64_t dump_guid = ++next_dump_id_;
   std::unique_ptr<QueuedVmRegionRequest> request =
-      std::make_unique<QueuedVmRegionRequest>(dump_guid, callback);
+      std::make_unique<QueuedVmRegionRequest>(dump_guid, std::move(callback));
   in_progress_vm_region_requests_[dump_guid] = std::move(request);
 
   std::vector<QueuedRequestDispatcher::ClientInfo> clients;
@@ -189,8 +192,9 @@ void CoordinatorImpl::GetVmRegionsForHeapProfiler(
 
   QueuedVmRegionRequest* request_ptr =
       in_progress_vm_region_requests_[dump_guid].get();
-  auto os_callback = base::Bind(&CoordinatorImpl::OnOSMemoryDumpForVMRegions,
-                                base::Unretained(this), dump_guid);
+  auto os_callback =
+      base::BindRepeating(&CoordinatorImpl::OnOSMemoryDumpForVMRegions,
+                          base::Unretained(this), dump_guid);
   QueuedRequestDispatcher::SetUpAndDispatchVmRegionRequest(request_ptr, clients,
                                                            pids, os_callback);
   FinalizeVmRegionDumpIfAllManagersReplied(dump_guid);
@@ -202,8 +206,8 @@ void CoordinatorImpl::RegisterClientProcess(
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   mojom::ClientProcess* client_process = client_process_ptr.get();
   client_process_ptr.set_connection_error_handler(
-      base::Bind(&CoordinatorImpl::UnregisterClientProcess,
-                 base::Unretained(this), client_process));
+      base::BindOnce(&CoordinatorImpl::UnregisterClientProcess,
+                     base::Unretained(this), client_process));
   auto identity = GetClientIdentityForCurrentRequest();
   auto client_info = std::make_unique<ClientInfo>(
       std::move(identity), std::move(client_process_ptr), process_type);
@@ -260,7 +264,7 @@ void CoordinatorImpl::UnregisterClientProcess(
 
 void CoordinatorImpl::RequestGlobalMemoryDumpInternal(
     const QueuedRequest::Args& args,
-    const RequestGlobalMemoryDumpInternalCallback& callback) {
+    RequestGlobalMemoryDumpInternalCallback callback) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
   UMA_HISTOGRAM_COUNTS_1000("Memory.Experimental.Debug.GlobalDumpQueueLength",
@@ -283,14 +287,15 @@ void CoordinatorImpl::RequestGlobalMemoryDumpInternal(
                 << base::trace_event::MemoryDumpLevelOfDetailToString(
                        args.level_of_detail)
                 << ") is already in the queue";
-        callback.Run(false /* success */, 0 /* dump_guid */,
-                     nullptr /* global_memory_dump */);
+        std::move(callback).Run(false /* success */, 0 /* dump_guid */,
+                                nullptr /* global_memory_dump */);
         return;
       }
     }
   }
 
-  queued_memory_dump_requests_.emplace_back(args, ++next_dump_id_, callback);
+  queued_memory_dump_requests_.emplace_back(args, ++next_dump_id_,
+                                            std::move(callback));
 
   // If another dump is already in queued, this dump will automatically be
   // scheduled when the other dump finishes.
@@ -490,7 +495,7 @@ void CoordinatorImpl::FinalizeVmRegionDumpIfAllManagersReplied(
 
   QueuedRequestDispatcher::VmRegions results =
       QueuedRequestDispatcher::FinalizeVmRegionRequest(it->second.get());
-  it->second->callback.Run(std::move(results));
+  std::move(it->second->callback).Run(std::move(results));
   in_progress_vm_region_requests_.erase(it);
 }
 
@@ -578,8 +583,8 @@ void CoordinatorImpl::FinalizeGlobalMemoryDumpIfAllManagersReplied() {
   if (!queued_memory_dump_requests_.empty()) {
     base::SequencedTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
-        base::Bind(&CoordinatorImpl::PerformNextQueuedGlobalMemoryDump,
-                   base::Unretained(this)));
+        base::BindOnce(&CoordinatorImpl::PerformNextQueuedGlobalMemoryDump,
+                       base::Unretained(this)));
   }
 }
 

services/resource_coordinator/memory_instrumentation/coordinator_impl.h

@@ -62,20 +62,20 @@ class CoordinatorImpl : public Coordinator,
       base::trace_event::MemoryDumpType,
       base::trace_event::MemoryDumpLevelOfDetail,
       const std::vector<std::string>& allocator_dump_names,
-      const RequestGlobalMemoryDumpCallback&) override;
+      RequestGlobalMemoryDumpCallback) override;
   void RequestGlobalMemoryDumpForPid(
       base::ProcessId,
-      const RequestGlobalMemoryDumpForPidCallback&) override;
+      RequestGlobalMemoryDumpForPidCallback) override;
   void RequestGlobalMemoryDumpAndAppendToTrace(
       base::trace_event::MemoryDumpType,
       base::trace_event::MemoryDumpLevelOfDetail,
-      const RequestGlobalMemoryDumpAndAppendToTraceCallback&) override;
+      RequestGlobalMemoryDumpAndAppendToTraceCallback) override;
   void RegisterHeapProfiler(mojom::HeapProfilerPtr heap_profiler) override;
 
   // mojom::HeapProfilerHelper implementation.
   void GetVmRegionsForHeapProfiler(
       const std::vector<base::ProcessId>& pids,
-      const GetVmRegionsForHeapProfilerCallback&) override;
+      GetVmRegionsForHeapProfilerCallback) override;
 
  protected:
   // virtual for testing.
@@ -89,7 +89,7 @@ class CoordinatorImpl : public Coordinator,
   using OSMemDumpMap =
       std::unordered_map<base::ProcessId, mojom::RawOSMemDumpPtr>;
   using RequestGlobalMemoryDumpInternalCallback =
-      base::Callback<void(bool, uint64_t, mojom::GlobalMemoryDumpPtr)>;
+      base::OnceCallback<void(bool, uint64_t, mojom::GlobalMemoryDumpPtr)>;
   friend std::default_delete<CoordinatorImpl>;  // For testing
   friend class CoordinatorImplTest;             // For testing
 
@@ -107,7 +107,7 @@ class CoordinatorImpl : public Coordinator,
 
   void RequestGlobalMemoryDumpInternal(
       const QueuedRequest::Args& args,
-      const RequestGlobalMemoryDumpInternalCallback& callback);
+      RequestGlobalMemoryDumpInternalCallback callback);
 
   // Callback of RequestChromeMemoryDump.
   void OnChromeMemoryDumpResponse(

services/resource_coordinator/memory_instrumentation/queued_request.cc

@@ -32,11 +32,10 @@ bool QueuedRequest::PendingResponse::operator<(
 QueuedRequest::Response::Response() {}
 QueuedRequest::Response::~Response() = default;
 
-QueuedRequest::QueuedRequest(
-    const Args& args,
-    uint64_t dump_guid,
-    const RequestGlobalMemoryDumpInternalCallback& callback)
-    : args(args), dump_guid(dump_guid), callback(callback) {}
+QueuedRequest::QueuedRequest(const Args& args,
+                             uint64_t dump_guid,
+                             RequestGlobalMemoryDumpInternalCallback callback)
+    : args(args), dump_guid(dump_guid), callback(std::move(callback)) {}
 QueuedRequest::~QueuedRequest() = default;
 
 base::trace_event::MemoryDumpRequestArgs QueuedRequest::GetRequestArgs() {
@@ -52,9 +51,8 @@ QueuedVmRegionRequest::Response::~Response() = default;
 
 QueuedVmRegionRequest::QueuedVmRegionRequest(
     uint64_t dump_guid,
-    const mojom::HeapProfilerHelper::GetVmRegionsForHeapProfilerCallback&
-        callback)
-    : dump_guid(dump_guid), callback(callback) {}
+    mojom::HeapProfilerHelper::GetVmRegionsForHeapProfilerCallback callback)
+    : dump_guid(dump_guid), callback(std::move(callback)) {}
 QueuedVmRegionRequest::~QueuedVmRegionRequest() = default;
 
 }  // namespace memory_instrumentation

services/resource_coordinator/memory_instrumentation/queued_request.h

@@ -25,7 +25,7 @@ using OSMemDumpMap =
 
 // Holds data for pending requests enqueued via RequestGlobalMemoryDump().
 struct QueuedRequest {
-  using RequestGlobalMemoryDumpInternalCallback = base::Callback<
+  using RequestGlobalMemoryDumpInternalCallback = base::OnceCallback<
       void(bool, uint64_t, memory_instrumentation::mojom::GlobalMemoryDumpPtr)>;
 
   struct Args {
@@ -69,7 +69,7 @@ struct QueuedRequest {
 
   QueuedRequest(const Args& args,
                 uint64_t dump_guid,
-                const RequestGlobalMemoryDumpInternalCallback& callback);
+                RequestGlobalMemoryDumpInternalCallback callback);
   ~QueuedRequest();
 
   base::trace_event::MemoryDumpRequestArgs GetRequestArgs();
@@ -87,7 +87,7 @@ struct QueuedRequest {
 
   const Args args;
   const uint64_t dump_guid;
-  const RequestGlobalMemoryDumpInternalCallback callback;
+  RequestGlobalMemoryDumpInternalCallback callback;
 
   // When a dump, requested via RequestGlobalMemoryDump(), is in progress this
   // set contains a |PendingResponse| for each |RequestChromeMemoryDump| and
@@ -111,11 +111,10 @@ struct QueuedRequest {
 struct QueuedVmRegionRequest {
   QueuedVmRegionRequest(
       uint64_t dump_guid,
-      const mojom::HeapProfilerHelper::GetVmRegionsForHeapProfilerCallback&
-          callback);
+      mojom::HeapProfilerHelper::GetVmRegionsForHeapProfilerCallback callback);
   ~QueuedVmRegionRequest();
   const uint64_t dump_guid;
-  const mojom::HeapProfilerHelper::GetVmRegionsForHeapProfilerCallback callback;
+  mojom::HeapProfilerHelper::GetVmRegionsForHeapProfilerCallback callback;
 
   struct Response {
     Response();

services/resource_coordinator/memory_instrumentation/queued_request_dispatcher.cc

@@ -225,8 +225,9 @@ void QueuedRequestDispatcher::SetUpAndDispatch(
     // https://bugs.chromium.org/p/chromium/issues/detail?id=812346#c16 for more
     // details.
     request->pending_responses.insert({client, ResponseType::kChromeDump});
-    client->RequestChromeMemoryDump(request->GetRequestArgs(),
-                                    base::Bind(chrome_callback, client));
+    client->RequestChromeMemoryDump(
+        request->GetRequestArgs(),
+        base::BindOnce(std::move(chrome_callback), client));
 
 // On most platforms each process can dump data about their own process
 // so ask each process to do so Linux is special see below.
@@ -234,7 +235,7 @@ void QueuedRequestDispatcher::SetUpAndDispatch(
     request->pending_responses.insert({client, ResponseType::kOSDump});
     client->RequestOSMemoryDump(request->memory_map_option(),
                                 {base::kNullProcessId},
-                                base::Bind(os_callback, client));
+                                base::BindOnce(os_callback, client));
 #endif  // !defined(OS_LINUX)
 
     // If we are in the single pid case, then we've already found the only
@@ -263,9 +264,9 @@ void QueuedRequestDispatcher::SetUpAndDispatch(
   }
   if (browser_client && pids.size() > 0) {
     request->pending_responses.insert({browser_client, ResponseType::kOSDump});
-    const auto callback = base::Bind(os_callback, browser_client);
+    auto callback = base::BindOnce(os_callback, browser_client);
     browser_client->RequestOSMemoryDump(request->memory_map_option(), pids,
-                                        callback);
+                                        std::move(callback));
   }
 #endif  // defined(OS_LINUX)
 
@@ -304,9 +305,9 @@ void QueuedRequestDispatcher::SetUpAndDispatchVmRegionRequest(
 
   request->pending_responses.insert(browser_client);
   request->responses[browser_client].process_id = browser_client_pid;
-  const auto callback = base::Bind(os_callback, browser_client);
+  auto callback = base::BindOnce(os_callback, browser_client);
   browser_client->RequestOSMemoryDump(mojom::MemoryMapOption::MODULES,
-                                      desired_pids, callback);
+                                      desired_pids, std::move(callback));
 #else
   for (const auto& client_info : clients) {
     if (std::find(desired_pids.begin(), desired_pids.end(), client_info.pid) !=
@@ -316,7 +317,7 @@ void QueuedRequestDispatcher::SetUpAndDispatchVmRegionRequest(
       request->responses[client].process_id = client_info.pid;
       client->RequestOSMemoryDump(mojom::MemoryMapOption::MODULES,
                                   {base::kNullProcessId},
-                                  base::Bind(os_callback, client));
+                                  base::BindOnce(os_callback, client));
     }
   }
 #endif  // defined(OS_LINUX)
@@ -539,8 +540,9 @@ void QueuedRequestDispatcher::Finalize(QueuedRequest* request,
   if (request->args.pid != base::kNullProcessId && !global_success) {
     global_dump = nullptr;
   }
-  const auto& callback = request->callback;
-  callback.Run(global_success, request->dump_guid, std::move(global_dump));
+  auto& callback = request->callback;
+  std::move(callback).Run(global_success, request->dump_guid,
+                          std::move(global_dump));
   UMA_HISTOGRAM_MEDIUM_TIMES("Memory.Experimental.Debug.GlobalDumpDuration",
                              base::Time::Now() - request->start_time);
   UMA_HISTOGRAM_COUNTS_1000(

services/resource_coordinator/memory_instrumentation/queued_request_dispatcher.h

@@ -21,15 +21,15 @@ class QueuedRequestDispatcher {
   using OSMemDumpMap =
       std::unordered_map<base::ProcessId,
                          memory_instrumentation::mojom::RawOSMemDumpPtr>;
-  using RequestGlobalMemoryDumpInternalCallback = base::Callback<
+  using RequestGlobalMemoryDumpInternalCallback = base::OnceCallback<
       void(bool, uint64_t, memory_instrumentation::mojom::GlobalMemoryDumpPtr)>;
-  using ChromeCallback = base::Callback<void(
+  using ChromeCallback = base::RepeatingCallback<void(
       mojom::ClientProcess*,
       bool,
       uint64_t,
       std::unique_ptr<base::trace_event::ProcessMemoryDump>)>;
   using OsCallback =
-      base::Callback<void(mojom::ClientProcess*, bool, OSMemDumpMap)>;
+      base::RepeatingCallback<void(mojom::ClientProcess*, bool, OSMemDumpMap)>;
   using VmRegions = std::unordered_map<
       base::ProcessId,
       std::vector<memory_instrumentation::mojom::VmRegionPtr>>;

services/resource_coordinator/public/cpp/frame_resource_coordinator.cc

@@ -35,8 +35,8 @@ void FrameResourceCoordinator::AddChildFrame(
   // We could keep the ID around ourselves, but this hop ensures that the child
   // has been created on the service-side.
   child.service()->GetID(
-      base::Bind(&FrameResourceCoordinator::AddChildFrameByID,
-                 weak_ptr_factory_.GetWeakPtr()));
+      base::BindOnce(&FrameResourceCoordinator::AddChildFrameByID,
+                     weak_ptr_factory_.GetWeakPtr()));
 }
 
 void FrameResourceCoordinator::RemoveChildFrame(
@@ -45,8 +45,8 @@ void FrameResourceCoordinator::RemoveChildFrame(
   if (!service_)
     return;
   child.service()->GetID(
-      base::Bind(&FrameResourceCoordinator::RemoveChildFrameByID,
-                 weak_ptr_factory_.GetWeakPtr()));
+      base::BindOnce(&FrameResourceCoordinator::RemoveChildFrameByID,
+                     weak_ptr_factory_.GetWeakPtr()));
 }
 
 void FrameResourceCoordinator::ConnectToService(

services/resource_coordinator/public/cpp/memory_instrumentation/client_process_impl.cc

@@ -74,7 +74,7 @@ ClientProcessImpl::~ClientProcessImpl() {}
 
 void ClientProcessImpl::RequestChromeMemoryDump(
     const base::trace_event::MemoryDumpRequestArgs& args,
-    const RequestChromeMemoryDumpCallback& callback) {
+    RequestChromeMemoryDumpCallback callback) {
   DCHECK(!callback.is_null());
   most_recent_chrome_memory_dump_guid_ = args.dump_guid;
   auto it_and_inserted =
@@ -106,10 +106,10 @@ void ClientProcessImpl::OnChromeMemoryDumpDone(
   }
 
   if (!process_memory_dump) {
-    callback.Run(false, dump_guid, nullptr);
+    std::move(callback).Run(false, dump_guid, nullptr);
     return;
   }
-  callback.Run(success, dump_guid, std::move(process_memory_dump));
+  std::move(callback).Run(success, dump_guid, std::move(process_memory_dump));
 }
 
 void ClientProcessImpl::RequestGlobalMemoryDump_NoCallback(
@@ -118,8 +118,8 @@ void ClientProcessImpl::RequestGlobalMemoryDump_NoCallback(
   if (!task_runner_->RunsTasksInCurrentSequence()) {
     task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&ClientProcessImpl::RequestGlobalMemoryDump_NoCallback,
-                   base::Unretained(this), dump_type, level_of_detail));
+        base::BindOnce(&ClientProcessImpl::RequestGlobalMemoryDump_NoCallback,
+                       base::Unretained(this), dump_type, level_of_detail));
     return;
   }
 
@@ -130,19 +130,20 @@ void ClientProcessImpl::RequestGlobalMemoryDump_NoCallback(
 
 void ClientProcessImpl::EnableHeapProfiling(
     base::trace_event::HeapProfilingMode mode,
-    const EnableHeapProfilingCallback& callback) {
-  callback.Run(base::trace_event::MemoryDumpManager::GetInstance()->
-                   EnableHeapProfiling(mode));
+    EnableHeapProfilingCallback callback) {
+  std::move(callback).Run(
+      base::trace_event::MemoryDumpManager::GetInstance()->EnableHeapProfiling(
+          mode));
 }
 
 void ClientProcessImpl::RequestOSMemoryDump(
     mojom::MemoryMapOption mmap_option,
     const std::vector<base::ProcessId>& pids,
-    const RequestOSMemoryDumpCallback& callback) {
+    RequestOSMemoryDumpCallback callback) {
   OSMemoryDumpArgs args;
   args.mmap_option = mmap_option;
   args.pids = pids;
-  args.callback = callback;
+  args.callback = std::move(callback);
 
 #if defined(OS_MACOSX)
   // If the most recent chrome memory dump hasn't finished, wait for that to
@@ -174,7 +175,7 @@ void ClientProcessImpl::PerformOSMemoryDump(OSMemoryDumpArgs args) {
       results[pid] = std::move(result);
     global_success = global_success && success;
   }
-  args.callback.Run(global_success, std::move(results));
+  std::move(args.callback).Run(global_success, std::move(results));
 }
 
 ClientProcessImpl::Config::Config(service_manager::Connector* connector,
@@ -187,7 +188,7 @@ ClientProcessImpl::Config::Config(service_manager::Connector* connector,
 ClientProcessImpl::Config::~Config() {}
 
 ClientProcessImpl::OSMemoryDumpArgs::OSMemoryDumpArgs() = default;
-ClientProcessImpl::OSMemoryDumpArgs::OSMemoryDumpArgs(const OSMemoryDumpArgs&) =
+ClientProcessImpl::OSMemoryDumpArgs::OSMemoryDumpArgs(OSMemoryDumpArgs&&) =
     default;
 ClientProcessImpl::OSMemoryDumpArgs::~OSMemoryDumpArgs() = default;
 

services/resource_coordinator/public/cpp/memory_instrumentation/client_process_impl.h

@@ -63,13 +63,12 @@ class SERVICES_RESOURCE_COORDINATOR_PUBLIC_CPP_EXPORT ClientProcessImpl
   // mojom::ClientProcess implementation. The Coordinator calls this.
   void RequestChromeMemoryDump(
       const base::trace_event::MemoryDumpRequestArgs& args,
-      const RequestChromeMemoryDumpCallback& callback) override;
+      RequestChromeMemoryDumpCallback callback) override;
 
   // mojom::ClientProcess implementation.
   // TODO(ssid): Use for GPU process.
-  void EnableHeapProfiling(
-      base::trace_event::HeapProfilingMode mode,
-      const EnableHeapProfilingCallback& callback) override;
+  void EnableHeapProfiling(base::trace_event::HeapProfilingMode mode,
+                           EnableHeapProfilingCallback callback) override;
 
   // Callback passed to base::MemoryDumpManager::CreateProcessDump().
   void OnChromeMemoryDumpDone(
@@ -78,14 +77,13 @@ class SERVICES_RESOURCE_COORDINATOR_PUBLIC_CPP_EXPORT ClientProcessImpl
       std::unique_ptr<base::trace_event::ProcessMemoryDump>);
 
   // mojom::ClientProcess implementation. The Coordinator calls this.
-  void RequestOSMemoryDump(
-      mojom::MemoryMapOption mmap_option,
-      const std::vector<base::ProcessId>& ids,
-      const RequestOSMemoryDumpCallback& callback) override;
+  void RequestOSMemoryDump(mojom::MemoryMapOption mmap_option,
+                           const std::vector<base::ProcessId>& ids,
+                           RequestOSMemoryDumpCallback callback) override;
 
   struct OSMemoryDumpArgs {
     OSMemoryDumpArgs();
-    OSMemoryDumpArgs(const OSMemoryDumpArgs&);
+    OSMemoryDumpArgs(OSMemoryDumpArgs&&);
     ~OSMemoryDumpArgs();
     mojom::MemoryMapOption mmap_option;
     std::vector<base::ProcessId> pids;

services/resource_coordinator/public/cpp/memory_instrumentation/memory_instrumentation.cc

@@ -97,9 +97,9 @@ MemoryInstrumentation::GetCoordinatorBindingForCurrentThread() {
     // invoking methods on the |coordinator| proxy objects.
     connector_task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(
+        base::BindOnce(
             &MemoryInstrumentation::BindCoordinatorRequestOnConnectorThread,
-            base::Unretained(this), base::Passed(std::move(coordinator_req))));
+            base::Unretained(this), std::move(coordinator_req)));
   }
   DCHECK(*coordinator);
   return *coordinator;

services/resource_coordinator/public/cpp/memory_instrumentation/tracing_integration_unittest.cc

@@ -121,16 +121,16 @@ class MockCoordinator : public Coordinator, public mojom::Coordinator {
       MemoryDumpType dump_type,
       MemoryDumpLevelOfDetail level_of_detail,
       const std::vector<std::string>& allocator_dump_names,
-      const RequestGlobalMemoryDumpCallback&) override;
+      RequestGlobalMemoryDumpCallback) override;
 
   void RequestGlobalMemoryDumpForPid(
       base::ProcessId pid,
-      const RequestGlobalMemoryDumpForPidCallback&) override {}
+      RequestGlobalMemoryDumpForPidCallback) override {}
 
   void RequestGlobalMemoryDumpAndAppendToTrace(
       MemoryDumpType dump_type,
       MemoryDumpLevelOfDetail level_of_detail,
-      const RequestGlobalMemoryDumpAndAppendToTraceCallback&) override;
+      RequestGlobalMemoryDumpAndAppendToTraceCallback) override;
 
  private:
   mojo::BindingSet<mojom::Coordinator> bindings_;
@@ -173,20 +173,21 @@ class MemoryTracingIntegrationTest : public testing::Test {
     bool success = false;
     uint64_t req_guid = ++guid_counter_;
     MemoryDumpRequestArgs request_args{req_guid, dump_type, level_of_detail};
-    ClientProcessImpl::RequestChromeMemoryDumpCallback callback = base::Bind(
-        [](bool* curried_success, base::Closure curried_quit_closure,
-           std::unique_ptr<base::trace_event::ProcessMemoryDump>*
-               curried_result,
-           uint64_t curried_expected_guid, bool success, uint64_t dump_guid,
-           std::unique_ptr<base::trace_event::ProcessMemoryDump> result) {
-          EXPECT_EQ(curried_expected_guid, dump_guid);
-          *curried_success = success;
-          if (curried_result)
-            *curried_result = std::move(result);
-          curried_quit_closure.Run();
-        },
-        &success, run_loop.QuitClosure(), result, req_guid);
-    client_process_->RequestChromeMemoryDump(request_args, callback);
+    ClientProcessImpl::RequestChromeMemoryDumpCallback callback =
+        base::BindOnce(
+            [](bool* curried_success, base::OnceClosure curried_quit_closure,
+               std::unique_ptr<base::trace_event::ProcessMemoryDump>*
+                   curried_result,
+               uint64_t curried_expected_guid, bool success, uint64_t dump_guid,
+               std::unique_ptr<base::trace_event::ProcessMemoryDump> result) {
+              EXPECT_EQ(curried_expected_guid, dump_guid);
+              *curried_success = success;
+              if (curried_result)
+                *curried_result = std::move(result);
+              std::move(curried_quit_closure).Run();
+            },
+            &success, run_loop.QuitClosure(), result, req_guid);
+    client_process_->RequestChromeMemoryDump(request_args, std::move(callback));
     run_loop.Run();
     return success;
   }
@@ -195,10 +196,12 @@ class MemoryTracingIntegrationTest : public testing::Test {
                          MemoryDumpLevelOfDetail level_of_detail) {
     uint64_t req_guid = ++guid_counter_;
     MemoryDumpRequestArgs request_args{req_guid, dump_type, level_of_detail};
-    ClientProcessImpl::RequestChromeMemoryDumpCallback callback = base::Bind(
-        [](bool success, uint64_t dump_guid,
-           std::unique_ptr<base::trace_event::ProcessMemoryDump> result) {});
-    client_process_->RequestChromeMemoryDump(request_args, callback);
+    ClientProcessImpl::RequestChromeMemoryDumpCallback callback =
+        base::BindOnce(
+            [](bool success, uint64_t dump_guid,
+               std::unique_ptr<base::trace_event::ProcessMemoryDump> result) {
+            });
+    client_process_->RequestChromeMemoryDump(request_args, std::move(callback));
   }
 
  protected:
@@ -249,17 +252,17 @@ void MockCoordinator::RequestGlobalMemoryDump(
     MemoryDumpType dump_type,
     MemoryDumpLevelOfDetail level_of_detail,
     const std::vector<std::string>& allocator_dump_names,
-    const RequestGlobalMemoryDumpCallback& callback) {
+    RequestGlobalMemoryDumpCallback callback) {
   client_->RequestChromeDump(dump_type, level_of_detail);
-  callback.Run(true, mojom::GlobalMemoryDumpPtr());
+  std::move(callback).Run(true, mojom::GlobalMemoryDumpPtr());
 }
 
 void MockCoordinator::RequestGlobalMemoryDumpAndAppendToTrace(
     MemoryDumpType dump_type,
     MemoryDumpLevelOfDetail level_of_detail,
-    const RequestGlobalMemoryDumpAndAppendToTraceCallback& callback) {
+    RequestGlobalMemoryDumpAndAppendToTraceCallback callback) {
   client_->RequestChromeDump(dump_type, level_of_detail);
-  callback.Run(1, true);
+  std::move(callback).Run(1, true);
 }
 
 // Checks that is the ClientProcessImpl is initialized after tracing already
@@ -526,11 +529,11 @@ TEST_F(MemoryTracingIntegrationTest, GenerationChangeDoesntReenterMDM) {
   base::RunLoop run_loop;
   thread->PostTask(
       FROM_HERE,
-      Bind(
+      base::BindOnce(
           [](scoped_refptr<base::SequencedTaskRunner> main_task_runner,
-             base::Closure quit_closure) {
+             base::OnceClosure quit_closure) {
             TRACE_EVENT0(MemoryDumpManager::kTraceCategory, "foo");
-            main_task_runner->PostTask(FROM_HERE, quit_closure);
+            main_task_runner->PostTask(FROM_HERE, std::move(quit_closure));
           },
           base::SequencedTaskRunnerHandle::Get(), run_loop.QuitClosure()));
   run_loop.Run();

services/resource_coordinator/public/cpp/page_resource_coordinator.cc

@@ -57,8 +57,8 @@ void PageResourceCoordinator::AddFrame(const FrameResourceCoordinator& frame) {
     return;
   // We could keep the ID around ourselves, but this hop ensures that the child
   // has been created on the service-side.
-  frame.service()->GetID(base::Bind(&PageResourceCoordinator::AddFrameByID,
-                                    weak_ptr_factory_.GetWeakPtr()));
+  frame.service()->GetID(base::BindOnce(&PageResourceCoordinator::AddFrameByID,
+                                        weak_ptr_factory_.GetWeakPtr()));
 }
 
 void PageResourceCoordinator::RemoveFrame(
@@ -66,8 +66,9 @@ void PageResourceCoordinator::RemoveFrame(
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   if (!service_)
     return;
-  frame.service()->GetID(base::Bind(&PageResourceCoordinator::RemoveFrameByID,
-                                    weak_ptr_factory_.GetWeakPtr()));
+  frame.service()->GetID(
+      base::BindOnce(&PageResourceCoordinator::RemoveFrameByID,
+                     weak_ptr_factory_.GetWeakPtr()));
 }
 
 void PageResourceCoordinator::ConnectToService(

services/resource_coordinator/public/cpp/process_resource_coordinator.cc

@@ -40,8 +40,9 @@ void ProcessResourceCoordinator::AddFrame(
     return;
   // We could keep the ID around ourselves, but this hop ensures that the child
   // has been created on the service-side.
-  frame.service()->GetID(base::Bind(&ProcessResourceCoordinator::AddFrameByID,
-                                    weak_ptr_factory_.GetWeakPtr()));
+  frame.service()->GetID(
+      base::BindOnce(&ProcessResourceCoordinator::AddFrameByID,
+                     weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ProcessResourceCoordinator::RemoveFrame(
@@ -50,8 +51,8 @@ void ProcessResourceCoordinator::RemoveFrame(
   if (!service_)
     return;
   frame.service()->GetID(
-      base::Bind(&ProcessResourceCoordinator::RemoveFrameByID,
-                 weak_ptr_factory_.GetWeakPtr()));
+      base::BindOnce(&ProcessResourceCoordinator::RemoveFrameByID,
+                     weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ProcessResourceCoordinator::ConnectToService(

services/resource_coordinator/public/mojom/BUILD.gn

@@ -29,7 +29,4 @@ mojom_component("mojom") {
   if (is_linux || is_android) {
     enabled_features += [ "private_swap_info" ]
   }
-
-  # TODO(crbug.com/714018): Convert the implementation to use OnceCallback.
-  use_once_callback = false
 }

services/resource_coordinator/resource_coordinator_service_unittest.cc

@@ -47,8 +47,8 @@ TEST_F(ResourceCoordinatorTest, ResourceCoordinatorInstantiate) {
   provider->CreatePageCoordinationUnit(mojo::MakeRequest(&coordination_unit),
                                        new_id);
 
-  coordination_unit->GetID(base::Bind(&ResourceCoordinatorTest::GetIDCallback,
-                                      base::Unretained(this)));
+  coordination_unit->GetID(base::BindOnce(
+      &ResourceCoordinatorTest::GetIDCallback, base::Unretained(this)));
 
   base::RunLoop loop;
   SetRunLoopToQuit(&loop);