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,

[Avi (use Gerrit), 2017/03/29 03:26:55]

This is passed by pointer, yes, but down on line 297 is passed into the "new
ChromeRemoteImpl" call which steals it.

If we could also turn this one into a pass-by-value and use moving, that would
be cleaner.

[leonhsl(Using Gerrit), 2017/03/29 09:22:30]

Done.

     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);
   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));
   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 130 matching lines @@
       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 40 matching lines @@
                                       std::move(devtools_websocket_client),
                                       *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);
   }
 
   uint16_t port = 0;
   std::unique_ptr<PortReservation> port_reservation;
   Status port_status(kOk);
 
@@ skipping 323 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