Convert //components/mus from scoped_ptr to std::unique_ptr

components/mus/ws/window_tree_client_unittest.cc

 // Copyright 2014 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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 400 matching lines @@
   }
   void OnAccelerator(uint32_t id, mojom::EventPtr event) override {
     NOTIMPLEMENTED();
   }
 
   TestChangeTracker tracker_;
 
   mojom::WindowTreePtr tree_;
 
   // If non-null we're waiting for OnEmbed() using this RunLoop.
-  scoped_ptr<base::RunLoop> embed_run_loop_;
+  std::unique_ptr<base::RunLoop> embed_run_loop_;
 
   // If non-null we're waiting for a certain number of change notifications to
   // be encountered.
-  scoped_ptr<WaitState> wait_state_;
+  std::unique_ptr<WaitState> wait_state_;
 
   mojo::Binding<WindowTreeClient> binding_;
   Id connection_id_;
   Id root_window_id_;
   uint32_t next_change_id_;
   uint32_t waiting_change_id_;
   bool on_change_completed_result_;
   bool track_root_bounds_changes_;
-  scoped_ptr<base::RunLoop> change_completed_run_loop_;
+  std::unique_ptr<base::RunLoop> change_completed_run_loop_;
 
-  scoped_ptr<mojo::AssociatedBinding<mojom::WindowManager>>
+  std::unique_ptr<mojo::AssociatedBinding<mojom::WindowManager>>
       window_manager_binding_;
   mojom::WindowManagerClientAssociatedPtr window_manager_client_;
 
   DISALLOW_COPY_AND_ASSIGN(TestWindowTreeClientImpl);
 };
 
 // -----------------------------------------------------------------------------
 
 // InterfaceFactory for vending TestWindowTreeClientImpls.
 class WindowTreeClientFactory
     : public shell::InterfaceFactory<WindowTreeClient> {
  public:
   WindowTreeClientFactory() {}
   ~WindowTreeClientFactory() override {}
 
   // Runs a nested MessageLoop until a new instance has been created.
-  scoped_ptr<TestWindowTreeClientImpl> WaitForInstance() {
+  std::unique_ptr<TestWindowTreeClientImpl> WaitForInstance() {
     if (!client_impl_.get()) {
       DCHECK(!run_loop_);
       run_loop_.reset(new base::RunLoop);
       run_loop_->Run();
       run_loop_.reset();
     }
     return std::move(client_impl_);
   }
 
  private:
   // InterfaceFactory<WindowTreeClient>:
   void Create(Connection* connection,
               InterfaceRequest<WindowTreeClient> request) override {
     client_impl_.reset(new TestWindowTreeClientImpl());
     client_impl_->Bind(std::move(request));
     if (run_loop_.get())
       run_loop_->Quit();
   }
 
-  scoped_ptr<TestWindowTreeClientImpl> client_impl_;
-  scoped_ptr<base::RunLoop> run_loop_;
+  std::unique_ptr<TestWindowTreeClientImpl> client_impl_;
+  std::unique_ptr<base::RunLoop> run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTreeClientFactory);
 };
 
 }  // namespace
 
 class WindowTreeClientTest : public WindowServerShellTestBase {
  public:
   WindowTreeClientTest()
       : connection_id_1_(0), connection_id_2_(0), root_window_id_(0) {}
@@ skipping 43 matching lines @@
                 ChangeWindowDescription(*changes2()));
     }
   }
 
   void EstablishThirdConnection(WindowTree* owner, Id root_id) {
     ASSERT_TRUE(wt_client3_.get() == nullptr);
     wt_client3_ = EstablishConnectionViaEmbed(owner, root_id, nullptr);
     ASSERT_TRUE(wt_client3_.get() != nullptr);
   }
 
-  scoped_ptr<TestWindowTreeClientImpl> WaitForWindowTreeClient() {
+  std::unique_ptr<TestWindowTreeClientImpl> WaitForWindowTreeClient() {
     return client_factory_->WaitForInstance();
   }
 
   // Establishes a new connection by way of Embed() on the specified
   // WindowTree.
-  scoped_ptr<TestWindowTreeClientImpl> EstablishConnectionViaEmbed(
+  std::unique_ptr<TestWindowTreeClientImpl> EstablishConnectionViaEmbed(
       WindowTree* owner,
       Id root_id,
       int* connection_id) {
     return EstablishConnectionViaEmbedWithPolicyBitmask(owner, root_id,
                                                         connection_id);
   }
 
-  scoped_ptr<TestWindowTreeClientImpl>
+  std::unique_ptr<TestWindowTreeClientImpl>
   EstablishConnectionViaEmbedWithPolicyBitmask(WindowTree* owner,
                                                Id root_id,
                                                int* connection_id) {
     if (!EmbedUrl(connector(), owner, test_name(), root_id)) {
       ADD_FAILURE() << "Embed() failed";
       return nullptr;
     }
-    scoped_ptr<TestWindowTreeClientImpl> client =
+    std::unique_ptr<TestWindowTreeClientImpl> client =
         client_factory_->WaitForInstance();
     if (!client.get()) {
       ADD_FAILURE() << "WaitForInstance failed";
       return nullptr;
     }
     client->WaitForOnEmbed();
 
     EXPECT_EQ("OnEmbed",
               SingleChangeToDescription(*client->tracker()->changes()));
     if (connection_id)
@@ skipping 41 matching lines @@
   void TearDown() override {
     // Destroy these before the message loop is destroyed (happens in
     // WindowServerShellTestBase::TearDown).
     wt_client1_.reset();
     wt_client2_.reset();
     wt_client3_.reset();
     client_factory_.reset();
     WindowServerShellTestBase::TearDown();
   }
 
-  scoped_ptr<TestWindowTreeClientImpl> wt_client1_;
-  scoped_ptr<TestWindowTreeClientImpl> wt_client2_;
-  scoped_ptr<TestWindowTreeClientImpl> wt_client3_;
+  std::unique_ptr<TestWindowTreeClientImpl> wt_client1_;
+  std::unique_ptr<TestWindowTreeClientImpl> wt_client2_;
+  std::unique_ptr<TestWindowTreeClientImpl> wt_client3_;
 
   mojom::WindowTreeHostPtr host_;
 
  private:
-  scoped_ptr<WindowTreeClientFactory> client_factory_;
+  std::unique_ptr<WindowTreeClientFactory> client_factory_;
   int connection_id_1_;
   int connection_id_2_;
   Id root_window_id_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTreeClientTest);
 };
 
 // Verifies two clients/connections get different ids.
 TEST_F(WindowTreeClientTest, TwoClientsGetDifferentConnectionIds) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
@@ skipping 723 matching lines @@
     EXPECT_EQ("HierarchyChanged window=" + IdToString(window_3_1) +
                   " old_parent=null new_parent=" + IdToString(window_1_1),
               SingleChangeToDescription(*changes1()));
   }
 
   // Embed 1,1 again.
   {
     changes3()->clear();
 
     // We should get a new connection for the new embedding.
-    scoped_ptr<TestWindowTreeClientImpl> connection4(
+    std::unique_ptr<TestWindowTreeClientImpl> connection4(
         EstablishConnectionViaEmbed(wt1(), window_1_1, nullptr));
     ASSERT_TRUE(connection4.get());
     EXPECT_EQ("[" + WindowParentToString(window_1_1, kNullParentId) + "]",
               ChangeWindowDescription(*connection4->tracker()->changes()));
 
     // And 3 should get an unembed and delete.
     wt_client3_->WaitForChangeCount(2);
     EXPECT_EQ("OnUnembed window=" + IdToString(window_1_1),
               ChangesToDescription1(*changes3())[0]);
     EXPECT_EQ("WindowDeleted window=" + IdToString(window_1_1),
@@ skipping 649 matching lines @@
 
 // TODO(sky): make sure coverage of what was
 // WindowManagerTest.SecondEmbedRoot_InitService and
 // WindowManagerTest.MultipleEmbedRootsBeforeWTHReady gets added to window
 // manager
 // tests.
 
 }  // namespace test
 }  // namespace ws
 }  // namespace mus