Remove ScopedVector from chrome/browser/.

chrome/browser/apps/app_shim/app_shim_host_mac_unittest.cc

 // Copyright 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/browser/apps/app_shim/app_shim_host_mac.h"
 
+#include <memory>
 #include <tuple>
 #include <vector>
 
 #include "base/macros.h"
-#include "base/memory/scoped_vector.h"
+#include "base/memory/ptr_util.h"
 #include "chrome/common/mac/app_shim_messages.h"
 #include "ipc/ipc_message.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 class TestingAppShimHost : public AppShimHost {
  public:
   TestingAppShimHost() {}
   ~TestingAppShimHost() override {}
 
   bool ReceiveMessage(IPC::Message* message);
 
-  const std::vector<IPC::Message*>& sent_messages() {
-    return sent_messages_.get();
+  const std::vector<std::unique_ptr<IPC::Message>>& sent_messages() {
+    return sent_messages_;
   }
 
  protected:
   bool Send(IPC::Message* message) override;
 
  private:
-  ScopedVector<IPC::Message> sent_messages_;
+  std::vector<std::unique_ptr<IPC::Message>> sent_messages_;
 
   DISALLOW_COPY_AND_ASSIGN(TestingAppShimHost);
 };
 
 bool TestingAppShimHost::ReceiveMessage(IPC::Message* message) {
   bool handled = OnMessageReceived(*message);
   delete message;
   return handled;
 }
 
 bool TestingAppShimHost::Send(IPC::Message* message) {
-  sent_messages_.push_back(message);
+  sent_messages_.push_back(base::WrapUnique(message));
   return true;
 }
 
 const char kTestAppId[] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
 const char kTestProfileDir[] = "Profile 1";
 
 class AppShimHostTest : public testing::Test,
                         public apps::AppShimHandler {
  public:
   AppShimHostTest() : launch_result_(apps::APP_SHIM_LAUNCH_SUCCESS),
                       launch_count_(0),
                       launch_now_count_(0),
                       close_count_(0),
                       focus_count_(0),
                       quit_count_(0) {}
 
   TestingAppShimHost* host() { return host_.get(); }
 
   void LaunchApp(apps::AppShimLaunchType launch_type) {
     EXPECT_TRUE(host()->ReceiveMessage(
         new AppShimHostMsg_LaunchApp(base::FilePath(kTestProfileDir),
                                      kTestAppId,
                                      launch_type,
                                      std::vector<base::FilePath>())));
   }
 
   apps::AppShimLaunchResult GetLaunchResult() {
     EXPECT_EQ(1u, host()->sent_messages().size());
-    IPC::Message* message = host()->sent_messages()[0];
+    IPC::Message* message = host()->sent_messages()[0].get();
     EXPECT_EQ(AppShimMsg_LaunchApp_Done::ID, message->type());
     AppShimMsg_LaunchApp_Done::Param param;
     AppShimMsg_LaunchApp_Done::Read(message, &param);
     return std::get<0>(param);
   }
 
   void SimulateDisconnect() {
     static_cast<IPC::Listener*>(host_.release())->OnChannelError();
   }
 
@@ skipping 82 matching lines @@
   apps::AppShimHandler::RemoveHandler(kTestAppId);
 }
 
 TEST_F(AppShimHostTest, TestFailLaunch) {
   apps::AppShimHandler::RegisterHandler(kTestAppId, this);
   launch_result_ = apps::APP_SHIM_LAUNCH_APP_NOT_FOUND;
   LaunchApp(apps::APP_SHIM_LAUNCH_NORMAL);
   EXPECT_EQ(apps::APP_SHIM_LAUNCH_APP_NOT_FOUND, GetLaunchResult());
   apps::AppShimHandler::RemoveHandler(kTestAppId);
 }