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

chrome/browser/extensions/api/messaging/message_service.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/messaging/message_service.h"
 
 #include <stdint.h>
-
 #include <limits>
+#include <utility>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/stl_util.h"
@@ skipping 148 matching lines @@
         target_frame_id(target_frame_id),
         receiver(receiver),
         receiver_port_id(receiver_port_id),
         source_extension_id(source_extension_id),
         target_extension_id(target_extension_id),
         source_url(source_url),
         channel_name(channel_name),
         include_tls_channel_id(include_tls_channel_id),
         include_guest_process_info(include_guest_process_info) {
     if (source_tab)
-      this->source_tab = source_tab.Pass();
+      this->source_tab = std::move(source_tab);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(OpenChannelParams);
 };
 
 namespace {
 
 static base::StaticAtomicSequenceNumber g_next_channel_id;
 
@@ skipping 166 matching lines @@
       auto* rfh = content::RenderFrameHost::FromID(source_process_id,
                                                    source_routing_id);
       // Include |source_frame_id| so that we can retrieve the guest's frame
       // routing id in OpenChannelImpl.
       if (rfh)
         source_frame_id = source_routing_id;
     }
   }
 
   scoped_ptr<OpenChannelParams> params(new OpenChannelParams(
-      source_process_id, source_tab.Pass(), source_frame_id, -1,
+      source_process_id, std::move(source_tab), source_frame_id, -1,
       -1,  // no target_tab_id/target_frame_id for connections to extensions
       nullptr, receiver_port_id, source_extension_id, target_extension_id,
       source_url, channel_name, include_tls_channel_id,
       include_guest_process_info));
 
   pending_incognito_channels_[GET_CHANNEL_ID(params->receiver_port_id)] =
       PendingMessagesQueue();
   if (context->IsOffTheRecord() &&
       !util::IsIncognitoEnabled(target_extension_id, context)) {
     // Give the user a chance to accept an incognito connection from the web if
     // they haven't already, with the conditions:
     // - Only for spanning-mode incognito. We don't want the complication of
     //   spinning up an additional process here which might need to do some
     //   setup that we're not expecting.
     // - Only for extensions that can't normally be enabled in incognito, since
     //   that surface (e.g. chrome://extensions) should be the only one for
     //   enabling in incognito. In practice this means platform apps only.
     if (!is_web_connection || IncognitoInfo::IsSplitMode(target_extension) ||
         util::CanBeIncognitoEnabled(target_extension)) {
-      OnOpenChannelAllowed(params.Pass(), false);
+      OnOpenChannelAllowed(std::move(params), false);
       return;
     }
 
     // If the target extension isn't even listening for connect/message events,
     // there is no need to go any further and the connection should be
     // rejected without showing a prompt. See http://crbug.com/442497
     EventRouter* event_router = EventRouter::Get(context);
     const char* const events[] = {"runtime.onConnectExternal",
                                   "runtime.onMessageExternal",
                                   "extension.onRequestExternal",
                                   nullptr};
     bool has_event_listener = false;
     for (const char* const* event = events; *event; event++) {
       has_event_listener |=
           event_router->ExtensionHasEventListener(target_extension_id, *event);
     }
     if (!has_event_listener) {
-      OnOpenChannelAllowed(params.Pass(), false);
+      OnOpenChannelAllowed(std::move(params), false);
       return;
     }
 
     // This check may show a dialog.
     IncognitoConnectability::Get(context)
         ->Query(target_extension, source_contents, source_url,
                 base::Bind(&MessageService::OnOpenChannelAllowed,
                            weak_factory_.GetWeakPtr(), base::Passed(&params)));
     return;
   }
 
-  OnOpenChannelAllowed(params.Pass(), true);
+  OnOpenChannelAllowed(std::move(params), true);
 }
 
 void MessageService::OpenChannelToNativeApp(
     int source_process_id,
     int source_routing_id,
     int receiver_port_id,
     const std::string& source_extension_id,
     const std::string& native_app_name) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
@@ skipping 48 matching lines @@
       policy_permission == ALLOW_ALL,
       &error);
 
   // Abandon the channel.
   if (!native_host.get()) {
     LOG(ERROR) << "Failed to create native process.";
     DispatchOnDisconnect(source, receiver_port_id, error);
     return;
   }
   channel->receiver.reset(new NativeMessagePort(
-      weak_factory_.GetWeakPtr(), receiver_port_id, native_host.Pass()));
+      weak_factory_.GetWeakPtr(), receiver_port_id, std::move(native_host)));
 
   // Keep the opener alive until the channel is closed.
   channel->opener->IncrementLazyKeepaliveCount();
 
   AddChannel(channel.release(), receiver_port_id);
 #else  // !(defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX))
   const char kNativeMessagingNotSupportedError[] =
       "Native Messaging is not supported on this platform.";
   DispatchOnDisconnect(
       source, receiver_port_id, kNativeMessagingNotSupportedError);
@@ skipping 63 matching lines @@
       source_process_id,
       scoped_ptr<base::DictionaryValue>(),  // Source tab doesn't make sense
                                             // for opening to tabs.
       -1,  // If there is no tab, then there is no frame either.
       tab_id, frame_id, receiver.release(), receiver_port_id, extension_id,
       extension_id,
       GURL(),  // Source URL doesn't make sense for opening to tabs.
       channel_name,
       false,    // Connections to tabs don't get TLS channel IDs.
       false));  // Connections to tabs aren't webview guests.
-  OpenChannelImpl(contents->GetBrowserContext(), params.Pass(), extension,
+  OpenChannelImpl(contents->GetBrowserContext(), std::move(params), extension,
                   false /* did_enqueue */);
 }
 
 void MessageService::OpenChannelImpl(BrowserContext* browser_context,
                                      scoped_ptr<OpenChannelParams> params,
                                      const Extension* target_extension,
                                      bool did_enqueue) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(target_extension != nullptr, !params->target_extension_id.empty());
 
@@ skipping 25 matching lines @@
     params->source_frame_id = -1;
 
     DCHECK(guest_rfh == nullptr ||
            WebViewGuest::FromWebContents(
                WebContents::FromRenderFrameHost(guest_rfh)) != nullptr);
   }
 
   // Send the connect event to the receiver.  Give it the opener's port ID (the
   // opener has the opposite port ID).
   channel->receiver->DispatchOnConnect(
-      params->receiver_port_id, params->channel_name, params->source_tab.Pass(),
-      params->source_frame_id, params->target_tab_id, params->target_frame_id,
-      guest_process_id, guest_render_frame_routing_id,
-      params->source_extension_id, params->target_extension_id,
-      params->source_url, params->tls_channel_id);
+      params->receiver_port_id, params->channel_name,
+      std::move(params->source_tab), params->source_frame_id,
+      params->target_tab_id, params->target_frame_id, guest_process_id,
+      guest_render_frame_routing_id, params->source_extension_id,
+      params->target_extension_id, params->source_url, params->tls_channel_id);
 
   // Report the event to the event router, if the target is an extension.
   //
   // First, determine what event this will be (runtime.onConnect vs
   // runtime.onMessage etc), and what the event target is (view vs background
   // page etc).
   //
   // Yes - even though this is opening a channel, they may actually be
   // runtime.onRequest/onMessage events because those single-use events are
   // built using the connect framework (see messaging.js).
@@ skipping 297 matching lines @@
     DispatchOnDisconnect(source, params->receiver_port_id,
                          kReceivingEndDoesntExistError);
     return;
   }
 
   // The target might be a lazy background page. In that case, we have to check
   // if it is loaded and ready, and if not, queue up the task and load the
   // page.
   if (!MaybeAddPendingLazyBackgroundPageOpenChannelTask(
           context, target_extension, &params, pending_messages)) {
-    OpenChannelImpl(context, params.Pass(), target_extension,
+    OpenChannelImpl(context, std::move(params), target_extension,
                     false /* did_enqueue */);
     DispatchPendingMessages(pending_messages, channel_id);
   }
 }
 
 void MessageService::GotChannelID(scoped_ptr<OpenChannelParams> params,
                                   const std::string& tls_channel_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   params->tls_channel_id.assign(tls_channel_id);
@@ skipping 21 matching lines @@
   const Extension* target_extension =
       registry->enabled_extensions().GetByID(params->target_extension_id);
   if (!target_extension) {
     DispatchOnDisconnect(source, params->receiver_port_id,
                          kReceivingEndDoesntExistError);
     return;
   }
 
   if (!MaybeAddPendingLazyBackgroundPageOpenChannelTask(
           context, target_extension, &params, pending_messages)) {
-    OpenChannelImpl(context, params.Pass(), target_extension,
+    OpenChannelImpl(context, std::move(params), target_extension,
                     false /* did_enqueue */);
     DispatchPendingMessages(pending_messages, channel_id);
   }
 }
 
 void MessageService::PendingLazyBackgroundPageOpenChannel(
     scoped_ptr<OpenChannelParams> params,
     int source_process_id,
     ExtensionHost* host) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!host)
     return;  // TODO(mpcomplete): notify source of disconnect?
 
   params->receiver.reset(new ExtensionMessagePort(host->render_process_host(),
                                                   MSG_ROUTING_CONTROL,
                                                   params->target_extension_id));
-  OpenChannelImpl(host->browser_context(), params.Pass(), host->extension(),
+  OpenChannelImpl(host->browser_context(), std::move(params), host->extension(),
                   true /* did_enqueue */);
 }
 
 void MessageService::DispatchOnDisconnect(content::RenderProcessHost* source,
                                           int port_id,
                                           const std::string& error_message) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   ExtensionMessagePort port(source, MSG_ROUTING_CONTROL, "");
   port.DispatchOnDisconnect(GET_OPPOSITE_PORT_ID(port_id), error_message);
 }
 
 void MessageService::DispatchPendingMessages(const PendingMessagesQueue& queue,
                                              int channel_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   MessageChannelMap::iterator channel_iter = channels_.find(channel_id);
   if (channel_iter != channels_.end()) {
     for (const PendingMessage& message : queue) {
       DispatchMessage(message.first, channel_iter->second, message.second);
     }
   }
 }
 
 }  // namespace extensions