Remove ScopedVector from chrome/test/chromedriver/

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 <memory>
 #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"
@@ skipping 217 matching lines @@
     }
     base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(50));
   }
   return Status(kUnknownError, "unable to discover open pages");
 }
 
 Status CreateBrowserwideDevToolsClientAndConnect(
     const NetAddress& address,
     const PerfLoggingPrefs& perf_logging_prefs,
     const SyncWebSocketFactory& socket_factory,
-    const ScopedVector<DevToolsEventListener>& devtools_event_listeners,
+    const std::vector<std::unique_ptr<DevToolsEventListener>>&
+        devtools_event_listeners,
     std::unique_ptr<DevToolsClient>* browser_client) {
   std::unique_ptr<DevToolsClient> client(new DevToolsClientImpl(
       socket_factory, base::StringPrintf("ws://%s/devtools/browser/",
                                          address.ToString().c_str()),
       DevToolsClientImpl::kBrowserwideDevToolsClientId));
-  for (ScopedVector<DevToolsEventListener>::const_iterator it =
-          devtools_event_listeners.begin();
-      it != devtools_event_listeners.end();
-      ++it) {
+  for (const auto& listener : devtools_event_listeners) {
     // 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);
+    if (listener->subscribes_to_browser())
+      client->AddListener(listener.get());
   }
   // 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 = 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);
 }
 
 Status LaunchRemoteChromeSession(
     URLRequestContextGetter* context_getter,
     const SyncWebSocketFactory& socket_factory,
     const Capabilities& capabilities,
-    ScopedVector<DevToolsEventListener>* devtools_event_listeners,
+    std::vector<std::unique_ptr<DevToolsEventListener>>
+        devtools_event_listeners,
     std::unique_ptr<Chrome>* chrome) {
   Status status(kOk);
   std::unique_ptr<DevToolsHttpClient> devtools_http_client;
   status = WaitForDevToolsAndCheckVersion(
       capabilities.debugger_address, context_getter, socket_factory,
       &capabilities, &devtools_http_client);
   if (status.IsError()) {
     return Status(kUnknownError, "cannot connect to chrome at " +
                       capabilities.debugger_address.ToString(),
                   status);
   }
 
   std::unique_ptr<DevToolsClient> devtools_websocket_client;
   status = CreateBrowserwideDevToolsClientAndConnect(
       capabilities.debugger_address, capabilities.perf_logging_prefs,
-      socket_factory, *devtools_event_listeners, &devtools_websocket_client);
+      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(std::move(devtools_http_client),
-                                     std::move(devtools_websocket_client),
-                                     *devtools_event_listeners,
-                                     capabilities.page_load_strategy));
+  chrome->reset(new ChromeRemoteImpl(
+      std::move(devtools_http_client), std::move(devtools_websocket_client),
+      std::move(devtools_event_listeners), capabilities.page_load_strategy));
   return Status(kOk);
 }
 
-Status LaunchDesktopChrome(
-    URLRequestContextGetter* context_getter,
-    uint16_t port,
-    std::unique_ptr<PortReservation> port_reservation,
-    const SyncWebSocketFactory& socket_factory,
-    const Capabilities& capabilities,
-    ScopedVector<DevToolsEventListener>* devtools_event_listeners,
-    std::unique_ptr<Chrome>* chrome,
-    bool w3c_compliant) {
+Status LaunchDesktopChrome(URLRequestContextGetter* context_getter,
+                           uint16_t port,
+                           std::unique_ptr<PortReservation> port_reservation,
+                           const SyncWebSocketFactory& socket_factory,
+                           const Capabilities& capabilities,
+                           std::vector<std::unique_ptr<DevToolsEventListener>>
+                               devtools_event_listeners,
+                           std::unique_ptr<Chrome>* chrome,
+                           bool w3c_compliant) {
   base::CommandLine command(base::CommandLine::NO_PROGRAM);
   base::ScopedTempDir user_data_dir;
   base::ScopedTempDir extension_dir;
   std::vector<std::string> extension_bg_pages;
   Status status = PrepareCommandLine(port,
                                      capabilities,
                                      &command,
                                      &user_data_dir,
                                      &extension_dir,
                                      &extension_bg_pages);
@@ skipping 96 matching lines @@
       if (base::GetTerminationStatus(process.Handle(), &exit_code) ==
           base::TERMINATION_STATUS_STILL_RUNNING)
         return Status(kUnknownError, "cannot kill Chrome", status);
     }
     return status;
   }
 
   std::unique_ptr<DevToolsClient> devtools_websocket_client;
   status = CreateBrowserwideDevToolsClientAndConnect(
       NetAddress(port), capabilities.perf_logging_prefs, socket_factory,
-      *devtools_event_listeners, &devtools_websocket_client);
+      devtools_event_listeners, &devtools_websocket_client);
   if (status.IsError()) {
     LOG(WARNING) << "Browser-wide DevTools client failed to connect: "
                  << status.message();
   }
 
-  std::unique_ptr<ChromeDesktopImpl> chrome_desktop(
-      new ChromeDesktopImpl(std::move(devtools_http_client),
-                            std::move(devtools_websocket_client),
-                            *devtools_event_listeners,
-                            std::move(port_reservation),
-                            capabilities.page_load_strategy,
-                            std::move(process),
-                            command,
-                            &user_data_dir,
-                            &extension_dir,
-                            capabilities.network_emulation_enabled));
+  std::unique_ptr<ChromeDesktopImpl> chrome_desktop(new ChromeDesktopImpl(
+      std::move(devtools_http_client), std::move(devtools_websocket_client),
+      std::move(devtools_event_listeners), std::move(port_reservation),
+      capabilities.page_load_strategy, std::move(process), command,
+      &user_data_dir, &extension_dir, capabilities.network_emulation_enabled));
   for (size_t i = 0; i < extension_bg_pages.size(); ++i) {
     VLOG(0) << "Waiting for extension bg page load: " << extension_bg_pages[i];
     std::unique_ptr<WebView> web_view;
     Status status = chrome_desktop->WaitForPageToLoad(
         extension_bg_pages[i], base::TimeDelta::FromSeconds(10),
         &web_view, w3c_compliant);
     if (status.IsError()) {
       return Status(kUnknownError,
                     "failed to wait for extension background page to load: " +
                         extension_bg_pages[i],
                     status);
     }
   }
   *chrome = std::move(chrome_desktop);
   return Status(kOk);
 }
 
-Status LaunchAndroidChrome(
-    URLRequestContextGetter* context_getter,
-    uint16_t port,
-    std::unique_ptr<PortReservation> port_reservation,
-    const SyncWebSocketFactory& socket_factory,
-    const Capabilities& capabilities,
-    ScopedVector<DevToolsEventListener>* devtools_event_listeners,
-    DeviceManager* device_manager,
-    std::unique_ptr<Chrome>* chrome) {
+Status LaunchAndroidChrome(URLRequestContextGetter* context_getter,
+                           uint16_t port,
+                           std::unique_ptr<PortReservation> port_reservation,
+                           const SyncWebSocketFactory& socket_factory,
+                           const Capabilities& capabilities,
+                           std::vector<std::unique_ptr<DevToolsEventListener>>
+                               devtools_event_listeners,
+                           DeviceManager* device_manager,
+                           std::unique_ptr<Chrome>* chrome) {
   Status status(kOk);
   std::unique_ptr<Device> device;
   if (capabilities.android_device_serial.empty()) {
     status = device_manager->AcquireDevice(&device);
   } else {
     status = device_manager->AcquireSpecificDevice(
         capabilities.android_device_serial, &device);
   }
   if (status.IsError())
     return status;
@@ skipping 23 matching lines @@
                                           &capabilities,
                                           &devtools_http_client);
   if (status.IsError()) {
     device->TearDown();
     return status;
   }
 
   std::unique_ptr<DevToolsClient> devtools_websocket_client;
   status = CreateBrowserwideDevToolsClientAndConnect(
       NetAddress(port), capabilities.perf_logging_prefs, socket_factory,
-      *devtools_event_listeners, &devtools_websocket_client);
+      devtools_event_listeners, &devtools_websocket_client);
   if (status.IsError()) {
     LOG(WARNING) << "Browser-wide DevTools client failed to connect: "
                  << status.message();
   }
 
-  chrome->reset(new ChromeAndroidImpl(std::move(devtools_http_client),
-                                      std::move(devtools_websocket_client),
-                                      *devtools_event_listeners,
-                                      std::move(port_reservation),
-                                      capabilities.page_load_strategy,
-                                      std::move(device)));
+  chrome->reset(new ChromeAndroidImpl(
+      std::move(devtools_http_client), std::move(devtools_websocket_client),
+      std::move(devtools_event_listeners), std::move(port_reservation),
+      capabilities.page_load_strategy, std::move(device)));
   return Status(kOk);
 }
 
 }  // namespace
 
-Status LaunchChrome(
-    URLRequestContextGetter* context_getter,
-    const SyncWebSocketFactory& socket_factory,
-    DeviceManager* device_manager,
-    PortServer* port_server,
-    PortManager* port_manager,
-    const Capabilities& capabilities,
-    ScopedVector<DevToolsEventListener>* devtools_event_listeners,
-    std::unique_ptr<Chrome>* chrome,
-    bool w3c_compliant) {
+Status LaunchChrome(URLRequestContextGetter* context_getter,
+                    const SyncWebSocketFactory& socket_factory,
+                    DeviceManager* device_manager,
+                    PortServer* port_server,
+                    PortManager* port_manager,
+                    const Capabilities& capabilities,
+                    std::vector<std::unique_ptr<DevToolsEventListener>>
+                        devtools_event_listeners,
+                    std::unique_ptr<Chrome>* chrome,
+                    bool w3c_compliant) {
   if (capabilities.IsRemoteBrowser()) {
     return LaunchRemoteChromeSession(
-        context_getter, socket_factory,
-        capabilities, devtools_event_listeners, chrome);
+        context_getter, socket_factory, capabilities,
+        std::move(devtools_event_listeners), chrome);
   }
 
   uint16_t port = 0;
   std::unique_ptr<PortReservation> port_reservation;
   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, std::move(port_reservation), socket_factory,
-        capabilities, devtools_event_listeners, device_manager, chrome);
+        capabilities, std::move(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,
-                               std::move(port_reservation), socket_factory,
-                               capabilities, devtools_event_listeners, chrome,
-                               w3c_compliant);
+    return LaunchDesktopChrome(
+        context_getter, port, std::move(port_reservation), socket_factory,
+        capabilities, std::move(devtools_event_listeners), chrome,
+        w3c_compliant);
   }
 }
 
 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 290 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