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

chrome/test/chromedriver/chrome_launcher.cc

 // Copyright (c) 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 "chrome/test/chromedriver/chrome_launcher.h"
 
 #include <stddef.h>
 #include <stdint.h>
-
 #include <algorithm>
+#include <utility>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/format_macros.h"
 #include "base/json/json_reader.h"
@@ skipping 168 matching lines @@
     device_metrics.reset(new DeviceMetrics(*capabilities->device_metrics));
 
   scoped_ptr<std::set<WebViewInfo::Type>> window_types;
   if (capabilities && !capabilities->window_types.empty()) {
     window_types.reset(
         new std::set<WebViewInfo::Type>(capabilities->window_types));
   } else {
     window_types.reset(new std::set<WebViewInfo::Type>());
   }
 
-  scoped_ptr<DevToolsHttpClient> client(
-      new DevToolsHttpClient(address, context_getter, socket_factory,
-                             device_metrics.Pass(), window_types.Pass()));
+  scoped_ptr<DevToolsHttpClient> client(new DevToolsHttpClient(
+      address, context_getter, socket_factory, std::move(device_metrics),
+      std::move(window_types)));
   base::TimeTicks deadline =
       base::TimeTicks::Now() + base::TimeDelta::FromSeconds(60);
   Status status = client->Init(deadline - base::TimeTicks::Now());
   if (status.IsError())
     return status;
 
   base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
   if (cmd_line->HasSwitch("disable-build-check")) {
     LOG(WARNING) << "You are using an unsupported command-line switch: "
                     "--disable-build-check. Please don't report bugs that "
                     "cannot be reproduced with this switch removed.";
   } else if (client->browser_info()->build_no <
              kMinimumSupportedChromeBuildNo) {
     return Status(kUnknownError, "Chrome version must be >= " +
         GetMinimumSupportedChromeVersion());
   }
 
   while (base::TimeTicks::Now() < deadline) {
     WebViewsInfo views_info;
     client->GetWebViewsInfo(&views_info);
     for (size_t i = 0; i < views_info.GetSize(); ++i) {
       if (views_info.Get(i).type == WebViewInfo::kPage) {
-        *user_client = client.Pass();
+        *user_client = std::move(client);
         return Status(kOk);
       }
     }
     base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(50));
   }
   return Status(kUnknownError, "unable to discover open pages");
 }
 
 Status CreateBrowserwideDevToolsClientAndConnect(
     const NetAddress& address,
@@ skipping 11 matching lines @@
       ++it) {
     // Only add listeners that subscribe to the browser-wide |DevToolsClient|.
     // Otherwise, listeners will think this client is associated with a webview,
     // and will send unrecognized commands to it.
     if ((*it)->subscribes_to_browser())
       client->AddListener(*it);
   }
   // Provide the client regardless of whether it connects, so that Chrome always
   // has a valid |devtools_websocket_client_|. If not connected, no listeners
   // will be notified, and client will just return kDisconnected errors if used.
-  *browser_client = client.Pass();
+  *browser_client = std::move(client);
   // To avoid unnecessary overhead, only connect if tracing is enabled, since
   // the browser-wide client is currently only used for tracing.
   if (!perf_logging_prefs.trace_categories.empty()) {
     Status status = (*browser_client)->ConnectIfNecessary();
     if (status.IsError())
       return status;
   }
   return Status(kOk);
 }
 
@@ skipping 16 matching lines @@
 
   scoped_ptr<DevToolsClient> devtools_websocket_client;
   status = CreateBrowserwideDevToolsClientAndConnect(
       capabilities.debugger_address, capabilities.perf_logging_prefs,
       socket_factory, *devtools_event_listeners, &devtools_websocket_client);
   if (status.IsError()) {
     LOG(WARNING) << "Browser-wide DevTools client failed to connect: "
                  << status.message();
   }
 
-  chrome->reset(new ChromeRemoteImpl(devtools_http_client.Pass(),
-                                     devtools_websocket_client.Pass(),
+  chrome->reset(new ChromeRemoteImpl(std::move(devtools_http_client),
+                                     std::move(devtools_websocket_client),
                                      *devtools_event_listeners));
   return Status(kOk);
 }
 
 Status LaunchDesktopChrome(
     URLRequestContextGetter* context_getter,
     uint16_t port,
     scoped_ptr<PortReservation> port_reservation,
     const SyncWebSocketFactory& socket_factory,
     const Capabilities& capabilities,
@@ skipping 114 matching lines @@
 
   scoped_ptr<DevToolsClient> devtools_websocket_client;
   status = CreateBrowserwideDevToolsClientAndConnect(
       NetAddress(port), capabilities.perf_logging_prefs, socket_factory,
       *devtools_event_listeners, &devtools_websocket_client);
   if (status.IsError()) {
     LOG(WARNING) << "Browser-wide DevTools client failed to connect: "
                  << status.message();
   }
 
-  scoped_ptr<ChromeDesktopImpl> chrome_desktop(
-      new ChromeDesktopImpl(devtools_http_client.Pass(),
-                            devtools_websocket_client.Pass(),
-                            *devtools_event_listeners,
-                            port_reservation.Pass(),
-                            process.Pass(),
-                            command,
-                            &user_data_dir,
-                            &extension_dir));
+  scoped_ptr<ChromeDesktopImpl> chrome_desktop(new ChromeDesktopImpl(
+      std::move(devtools_http_client), std::move(devtools_websocket_client),
+      *devtools_event_listeners, std::move(port_reservation),
+      std::move(process), command, &user_data_dir, &extension_dir));
   for (size_t i = 0; i < extension_bg_pages.size(); ++i) {
     VLOG(0) << "Waiting for extension bg page load: " << extension_bg_pages[i];
     scoped_ptr<WebView> web_view;
     Status status = chrome_desktop->WaitForPageToLoad(
         extension_bg_pages[i], base::TimeDelta::FromSeconds(10), &web_view);
     if (status.IsError()) {
       return Status(kUnknownError,
                     "failed to wait for extension background page to load: " +
                         extension_bg_pages[i],
                     status);
     }
   }
-  *chrome = chrome_desktop.Pass();
+  *chrome = std::move(chrome_desktop);
   return Status(kOk);
 }
 
 Status LaunchAndroidChrome(
     URLRequestContextGetter* context_getter,
     uint16_t port,
     scoped_ptr<PortReservation> port_reservation,
     const SyncWebSocketFactory& socket_factory,
     const Capabilities& capabilities,
     ScopedVector<DevToolsEventListener>* devtools_event_listeners,
@@ skipping 39 matching lines @@
 
   scoped_ptr<DevToolsClient> devtools_websocket_client;
   status = CreateBrowserwideDevToolsClientAndConnect(
       NetAddress(port), capabilities.perf_logging_prefs, socket_factory,
       *devtools_event_listeners, &devtools_websocket_client);
   if (status.IsError()) {
     LOG(WARNING) << "Browser-wide DevTools client failed to connect: "
                  << status.message();
   }
 
-  chrome->reset(new ChromeAndroidImpl(devtools_http_client.Pass(),
-                                      devtools_websocket_client.Pass(),
-                                      *devtools_event_listeners,
-                                      port_reservation.Pass(),
-                                      device.Pass()));
+  chrome->reset(new ChromeAndroidImpl(
+      std::move(devtools_http_client), std::move(devtools_websocket_client),
+      *devtools_event_listeners, std::move(port_reservation),
+      std::move(device)));
   return Status(kOk);
 }
 
 }  // namespace
 
 Status LaunchChrome(
     URLRequestContextGetter* context_getter,
     const SyncWebSocketFactory& socket_factory,
     DeviceManager* device_manager,
     PortServer* port_server,
@@ skipping 12 matching lines @@
   Status port_status(kOk);
 
   if (capabilities.IsAndroid()) {
     if (port_server)
       port_status = port_server->ReservePort(&port, &port_reservation);
     else
       port_status = port_manager->ReservePortFromPool(&port, &port_reservation);
     if (port_status.IsError())
       return Status(kUnknownError, "cannot reserve port for Chrome",
                     port_status);
-    return LaunchAndroidChrome(context_getter,
-                               port,
-                               port_reservation.Pass(),
-                               socket_factory,
-                               capabilities,
-                               devtools_event_listeners,
-                               device_manager,
-                               chrome);
+    return LaunchAndroidChrome(
+        context_getter, port, std::move(port_reservation), socket_factory,
+        capabilities, devtools_event_listeners, device_manager, chrome);
   } else {
     if (port_server)
       port_status = port_server->ReservePort(&port, &port_reservation);
     else
       port_status = port_manager->ReservePort(&port, &port_reservation);
     if (port_status.IsError())
       return Status(kUnknownError, "cannot reserve port for Chrome",
                     port_status);
-    return LaunchDesktopChrome(context_getter,
-                               port,
-                               port_reservation.Pass(),
-                               socket_factory,
-                               capabilities,
-                               devtools_event_listeners,
-                               chrome);
+    return LaunchDesktopChrome(context_getter, port,
+                               std::move(port_reservation), socket_factory,
+                               capabilities, devtools_event_listeners, chrome);
   }
 }
 
 namespace internal {
 
 void ConvertHexadecimalToIDAlphabet(std::string* id) {
   for (size_t i = 0; i < id->size(); ++i) {
     int val;
     if (base::HexStringToInt(base::StringPiece(id->begin() + i,
                                                id->begin() + i + 1),
@@ skipping 276 matching lines @@
   // Write empty "First Run" file, otherwise Chrome will wipe the default
   // profile that was written.
   if (base::WriteFile(
           user_data_dir.Append(chrome::kFirstRunSentinel), "", 0) != 0) {
     return Status(kUnknownError, "failed to write first run file");
   }
   return Status(kOk);
 }
 
 }  // namespace internal