Remove ScopedVector from chrome/test/chromedriver/

chrome/test/chromedriver/commands_unittest.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/test/chromedriver/commands.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
+#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "base/values.h"
 #include "chrome/test/chromedriver/chrome/status.h"
 #include "chrome/test/chromedriver/chrome/stub_chrome.h"
 #include "chrome/test/chromedriver/chrome/stub_web_view.h"
 #include "chrome/test/chromedriver/chrome/web_view.h"
 #include "chrome/test/chromedriver/command_listener_proxy.h"
@@ skipping 649 matching lines @@
 
   void VerifyNotCalled() {
     EXPECT_FALSE(called_);
   }
 
  private:
   bool called_;
 };
 
 Status ExecuteAddListenerToSessionCommand(
-    CommandListener* listener,
+    std::unique_ptr<CommandListener> listener,
     Session* session,
     const base::DictionaryValue& params,
     std::unique_ptr<base::Value>* return_value) {
-  session->command_listeners.push_back(listener);
+  session->command_listeners.push_back(std::move(listener));
   return Status(kOk);
 }
 
 Status ExecuteQuitSessionCommand(Session* session,
                                  const base::DictionaryValue& params,
                                  std::unique_ptr<base::Value>* return_value) {
   session->quit = true;
   return Status(kOk);
 }
 
@@ skipping 13 matching lines @@
   linked_ptr<base::Thread> thread(new base::Thread("1"));
   ASSERT_TRUE(thread->Start());
   std::string id("id");
   thread->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&internal::CreateSessionOnSessionThreadForTesting, id));
 
   map[id] = thread;
 
   base::DictionaryValue params;
-  std::unique_ptr<MockCommandListener> listener(new MockCommandListener());
-  CommandListenerProxy* proxy = new CommandListenerProxy(listener.get());
+  auto listener = base::MakeUnique<MockCommandListener>();
+  auto proxy = base::MakeUnique<CommandListenerProxy>(listener.get());
   // We add |proxy| to the session instead of adding |listener| directly so that
   // after the session is destroyed by ExecuteQuitSessionCommand, we can still
   // verify the listener was called. The session owns and will destroy |proxy|.
-  SessionCommand cmd = base::Bind(&ExecuteAddListenerToSessionCommand, proxy);
+  SessionCommand cmd =
+      base::Bind(&ExecuteAddListenerToSessionCommand, base::Passed(&proxy));
   base::MessageLoop loop;
   base::RunLoop run_loop_addlistener;
 
   // |CommandListener|s are notified immediately before commands are run.
   // Here, the command adds |listener| to the session, so |listener|
   // should not be notified since it will not have been added yet.
   ExecuteSessionCommand(
       &map,
       "cmd",
       cmd,
@@ skipping 28 matching lines @@
 class FailingCommandListener : public CommandListener {
  public:
   FailingCommandListener() {}
   ~FailingCommandListener() override {}
 
   Status BeforeCommand(const std::string& command_name) override {
     return Status(kUnknownError);
   }
 };
 
-void AddListenerToSessionIfSessionExists(CommandListener* listener) {
+void AddListenerToSessionIfSessionExists(
+    std::unique_ptr<CommandListener> listener) {
   Session* session = GetThreadLocalSession();
   if (session) {
-    session->command_listeners.push_back(listener);
+    session->command_listeners.push_back(std::move(listener));
   }
 }
 
 void OnFailBecauseErrorNotifyingListeners(base::RunLoop* run_loop,
                                           const Status& status,
                                           std::unique_ptr<base::Value> value,
                                           const std::string& session_id,
                                           bool w3c_compliant) {
   EXPECT_EQ(kUnknownError, status.code());
   EXPECT_FALSE(value.get());
@@ skipping 12 matching lines @@
   ASSERT_TRUE(thread->Start());
   std::string id("id");
   thread->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&internal::CreateSessionOnSessionThreadForTesting, id));
   map[id] = thread;
 
   // In SuccessNotifyingCommandListenersBeforeCommand, we verified BeforeCommand
   // was called before (as opposed to after) command execution. We don't need to
   // verify this again, so we can just add |listener| with PostTask.
-  CommandListener* listener = new FailingCommandListener();
+  auto listener = base::MakeUnique<FailingCommandListener>();
   thread->task_runner()->PostTask(
-      FROM_HERE, base::Bind(&AddListenerToSessionIfSessionExists, listener));
+      FROM_HERE, base::Bind(&AddListenerToSessionIfSessionExists,
+                            base::Passed(&listener)));
 
   base::DictionaryValue params;
   // The command should never be executed if BeforeCommand fails for a listener.
   SessionCommand cmd = base::Bind(&ShouldNotBeCalled);
   base::MessageLoop loop;
   base::RunLoop run_loop;
 
   ExecuteSessionCommand(
       &map,
       "cmd",
       cmd,
       false,
       params,
       id,
       base::Bind(&OnFailBecauseErrorNotifyingListeners, &run_loop));
   run_loop.Run();
 
   thread->task_runner()->PostTask(FROM_HERE,
                                   base::Bind(&VerifySessionWasDeleted));
 }