Enable use_once_callback for //content/common/*.mojom

content/browser/loader/url_loader_factory_impl.cc

 // Copyright 2016 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 "content/browser/loader/url_loader_factory_impl.h"
 
 #include "base/memory/ptr_util.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/loader/resource_requester_info.h"
 #include "content/common/resource_request.h"
 #include "content/common/url_loader.mojom.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 
 namespace content {
 
 namespace {
 
-void DispatchSyncLoadResult(
-    const URLLoaderFactoryImpl::SyncLoadCallback& callback,
-    const SyncLoadResult* result) {
+void DispatchSyncLoadResult(URLLoaderFactoryImpl::SyncLoadCallback callback,
+                            const SyncLoadResult* result) {
   // |result| can be null when a loading task is aborted unexpectedly. Reply
   // with a failure result on that case.
   // TODO(tzik): Test null-result case.
   if (!result) {
     SyncLoadResult failure;
     failure.error_code = net::ERR_FAILED;
-    callback.Run(failure);
+    std::move(callback).Run(failure);
     return;
   }
 
-  callback.Run(*result);
+  std::move(callback).Run(*result);
 }
 
 } // namespace
 
 URLLoaderFactoryImpl::URLLoaderFactoryImpl(
     scoped_refptr<ResourceRequesterInfo> requester_info,
     const scoped_refptr<base::SingleThreadTaskRunner>& io_thread_runner)
     : requester_info_(std::move(requester_info)),
       io_thread_task_runner_(io_thread_runner) {
   DCHECK((requester_info_->IsRenderer() && requester_info_->filter()) ||
@@ skipping 13 matching lines @@
     const ResourceRequest& url_request,
     mojom::URLLoaderClientPtr client) {
   DCHECK_EQ(options, mojom::kURLLoadOptionNone);
   CreateLoaderAndStart(requester_info_.get(), std::move(request), routing_id,
                        request_id, url_request, std::move(client));
 }
 
 void URLLoaderFactoryImpl::SyncLoad(int32_t routing_id,
                                     int32_t request_id,
                                     const ResourceRequest& url_request,
-                                    const SyncLoadCallback& callback) {
+                                    SyncLoadCallback callback) {
   SyncLoad(requester_info_.get(), routing_id, request_id, url_request,
-           callback);
+           std::move(callback));
 }
 
 // static
 void URLLoaderFactoryImpl::CreateLoaderAndStart(
     ResourceRequesterInfo* requester_info,
     mojom::URLLoaderAssociatedRequest request,
     int32_t routing_id,
     int32_t request_id,
     const ResourceRequest& url_request,
     mojom::URLLoaderClientPtr client) {
   DCHECK(ResourceDispatcherHostImpl::Get()
              ->io_thread_task_runner()
              ->BelongsToCurrentThread());
 
   ResourceDispatcherHostImpl* rdh = ResourceDispatcherHostImpl::Get();
   rdh->OnRequestResourceWithMojo(requester_info, routing_id, request_id,
                                  url_request, std::move(request),
                                  std::move(client));
 }
 
 // static
 void URLLoaderFactoryImpl::SyncLoad(ResourceRequesterInfo* requester_info,
                                     int32_t routing_id,
                                     int32_t request_id,
                                     const ResourceRequest& url_request,
-                                    const SyncLoadCallback& callback) {
+                                    SyncLoadCallback callback) {
   DCHECK(ResourceDispatcherHostImpl::Get()
              ->io_thread_task_runner()
              ->BelongsToCurrentThread());
 
   ResourceDispatcherHostImpl* rdh = ResourceDispatcherHostImpl::Get();
-  rdh->OnSyncLoadWithMojo(requester_info, routing_id, request_id, url_request,
-                          base::Bind(&DispatchSyncLoadResult, callback));
+  rdh->OnSyncLoadWithMojo(
+      requester_info, routing_id, request_id, url_request,
+      base::Bind(&DispatchSyncLoadResult, base::Passed(&callback)));

[mmenke, 2017/04/21 16:25:57]

You could use BindOnce here, too, and make OnSyncLoadWithMojo take a
non-const-ref callback, and work your way down a bit.

[tzik, 2017/04/24 09:17:11]

Let me do it in a separate CL.
# This should hopefully be handled by a tool based refactoring later. But doing
it manually for now.

 }
 
 void URLLoaderFactoryImpl::Create(
     scoped_refptr<ResourceRequesterInfo> requester_info,
     mojo::InterfaceRequest<mojom::URLLoaderFactory> request,
     const scoped_refptr<base::SingleThreadTaskRunner>& io_thread_runner) {
   mojo::MakeStrongBinding(base::WrapUnique(new URLLoaderFactoryImpl(
                               std::move(requester_info), io_thread_runner)),
                           std::move(request));
 }
 
 }  // namespace content