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

content/browser/frame_host/render_frame_host_impl.cc

 // Copyright 2013 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/frame_host/render_frame_host_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 2422 matching lines @@
 void RenderFrameHostImpl::OnShowCreatedWindow(int pending_widget_routing_id,
                                               WindowOpenDisposition disposition,
                                               const gfx::Rect& initial_rect,
                                               bool user_gesture) {
   delegate_->ShowCreatedWindow(GetProcess()->GetID(), pending_widget_routing_id,
                                disposition, initial_rect, user_gesture);
 }
 
 void RenderFrameHostImpl::CreateNewWindow(
     mojom::CreateNewWindowParamsPtr params,
-    const CreateNewWindowCallback& callback) {
+    CreateNewWindowCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   bool no_javascript_access = false;
 
   // Filter out URLs that this process cannot request.
   GetProcess()->FilterURL(false, &params->target_url);
 
   // Ignore creation when sent from a frame that's not current or created.
   bool can_create_window =
       frame_tree_node_->current_frame_host() == this && render_frame_created_ &&
       GetContentClient()->browser()->CanCreateWindow(
           this, last_committed_url(),
           frame_tree_node_->frame_tree()->GetMainFrame()->last_committed_url(),
           last_committed_origin_.GetURL(), params->window_container_type,
           params->target_url, params->referrer, params->frame_name,
           params->disposition, *params->features, params->user_gesture,
           params->opener_suppressed, &no_javascript_access);
 
   mojom::CreateNewWindowReplyPtr reply = mojom::CreateNewWindowReply::New();
   if (!can_create_window) {
-    RunCreateWindowCompleteCallback(callback, std::move(reply),
+    RunCreateWindowCompleteCallback(std::move(callback), std::move(reply),
                                     MSG_ROUTING_NONE, MSG_ROUTING_NONE,
                                     MSG_ROUTING_NONE, 0);
     return;
   }
 
   // This will clone the sessionStorage for namespace_id_to_clone.
 
   StoragePartition* storage_partition = BrowserContext::GetStoragePartition(
       GetSiteInstance()->GetBrowserContext(), GetSiteInstance());
   DOMStorageContextWrapper* dom_storage_context =
@@ skipping 45 matching lines @@
   // If we did not create a WebContents to host the renderer-created
   // RenderFrame/RenderView/RenderWidget objects, make sure to send invalid
   // routing ids back to the renderer.
   if (main_frame_route_id != MSG_ROUTING_NONE) {
     bool succeeded =
         RenderWidgetHost::FromID(render_process_id,
                                  main_frame_widget_route_id) != nullptr;
     if (!succeeded) {
       DCHECK(!RenderFrameHost::FromID(render_process_id, main_frame_route_id));
       DCHECK(!RenderViewHost::FromID(render_process_id, render_view_route_id));
-      RunCreateWindowCompleteCallback(callback, std::move(reply),
+      RunCreateWindowCompleteCallback(std::move(callback), std::move(reply),
                                       MSG_ROUTING_NONE, MSG_ROUTING_NONE,
                                       MSG_ROUTING_NONE, 0);
       return;
     }
     DCHECK(RenderFrameHost::FromID(render_process_id, main_frame_route_id));
     DCHECK(RenderViewHost::FromID(render_process_id, render_view_route_id));
   }
 
   RunCreateWindowCompleteCallback(
-      callback, std::move(reply), render_view_route_id, main_frame_route_id,
-      main_frame_widget_route_id, cloned_namespace->id());
+      std::move(callback), std::move(reply), render_view_route_id,
+      main_frame_route_id, main_frame_widget_route_id, cloned_namespace->id());
 }
 
 void RenderFrameHostImpl::RunCreateWindowCompleteCallback(
-    const CreateNewWindowCallback& callback,
+    CreateNewWindowCallback callback,
     mojom::CreateNewWindowReplyPtr reply,
     int render_view_route_id,
     int main_frame_route_id,
     int main_frame_widget_route_id,
     int cloned_session_storage_namespace_id) {
   reply->route_id = render_view_route_id;
   reply->main_frame_route_id = main_frame_route_id;
   reply->main_frame_widget_route_id = main_frame_widget_route_id;
   reply->cloned_session_storage_namespace_id =
       cloned_session_storage_namespace_id;
-  callback.Run(std::move(reply));
+  std::move(callback).Run(std::move(reply));
 }
 
 void RenderFrameHostImpl::RegisterMojoInterfaces() {
   device::GeolocationServiceContext* geolocation_service_context =
       delegate_ ? delegate_->GetGeolocationServiceContext() : NULL;
 
 #if !defined(OS_ANDROID)
   // The default (no-op) implementation of InstalledAppProvider. On Android, the
   // real implementation is provided in Java.
   GetInterfaceRegistry()->AddInterface(
@@ skipping 1219 matching lines @@
 }
 
 void RenderFrameHostImpl::ForwardGetInterfaceToRenderFrame(
     const std::string& interface_name,
     mojo::ScopedMessagePipeHandle pipe) {
   GetRemoteInterfaces()->GetInterface(interface_name, std::move(pipe));
 }
 #endif
 
 }  // namespace content