mus ws: Move 'reset(new' to base::MakeUnique.

services/ui/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 133 matching lines @@
     track_root_bounds_changes_ = value;
   }
 
   // Runs a nested MessageLoop until |count| changes (calls to
   // WindowTreeClient functions) have been received.
   void WaitForChangeCount(size_t count) {
     if (tracker_.changes()->size() >= count)
       return;
 
     ASSERT_TRUE(wait_state_.get() == nullptr);
-    wait_state_.reset(new WaitState);
+    wait_state_ = base::MakeUnique<WaitState>();
     wait_state_->change_count = count;
     wait_state_->run_loop.Run();
     wait_state_.reset();
   }
 
   uint32_t GetAndAdvanceChangeId() { return next_change_id_++; }
 
   // Runs a nested MessageLoop until OnEmbed() has been encountered.
   void WaitForOnEmbed() {
     if (tree_)
       return;
-    embed_run_loop_.reset(new base::RunLoop);
+    embed_run_loop_ = base::MakeUnique<base::RunLoop>();
     embed_run_loop_->Run();
     embed_run_loop_.reset();
   }
 
   bool WaitForChangeCompleted(uint32_t id) {
     waiting_change_id_ = id;
-    change_completed_run_loop_.reset(new base::RunLoop);
+    change_completed_run_loop_ = base::MakeUnique<base::RunLoop>();
     change_completed_run_loop_->Run();
     return on_change_completed_result_;
   }
 
   bool DeleteWindow(Id id) {
     const uint32_t change_id = GetAndAdvanceChangeId();
     tree()->DeleteWindow(change_id, id);
     return WaitForChangeCompleted(change_id);
   }
 
@@ skipping 226 matching lines @@
 
   void OnChangeCompleted(uint32_t change_id, bool success) override {
     if (waiting_change_id_ == change_id && change_completed_run_loop_) {
       on_change_completed_result_ = success;
       change_completed_run_loop_->Quit();
     }
   }
   void RequestClose(uint32_t window_id) override {}
   void GetWindowManager(mojo::AssociatedInterfaceRequest<mojom::WindowManager>
                             internal) override {
-    window_manager_binding_.reset(
-        new mojo::AssociatedBinding<mojom::WindowManager>(this,
-                                                          std::move(internal)));
+    window_manager_binding_ =
+        base::MakeUnique<mojo::AssociatedBinding<mojom::WindowManager>>(
+            this, std::move(internal));
     tree_->GetWindowManagerClient(
         GetProxy(&window_manager_client_, tree_.associated_group()));
   }
 
   // mojom::WindowManager:
   void OnConnect(uint16_t client_id) override {}
   void WmNewDisplayAdded(const display::Display& display,
                          mojom::WindowDataPtr root_data,
                          bool drawn) override {
     NOTIMPLEMENTED();
@@ skipping 66 matching lines @@
 class WindowTreeClientFactory
     : public shell::InterfaceFactory<WindowTreeClient> {
  public:
   WindowTreeClientFactory() {}
   ~WindowTreeClientFactory() override {}
 
   // Runs a nested MessageLoop until a new instance has been created.
   std::unique_ptr<TestWindowTreeClient> WaitForInstance() {
     if (!client_impl_.get()) {
       DCHECK(!run_loop_);
-      run_loop_.reset(new base::RunLoop);
+      run_loop_ = base::MakeUnique<base::RunLoop>();
       run_loop_->Run();
       run_loop_.reset();
     }
     return std::move(client_impl_);
   }
 
  private:
   // InterfaceFactory<WindowTreeClient>:
   void Create(const shell::Identity& remote_identity,
               InterfaceRequest<WindowTreeClient> request) override {
-    client_impl_.reset(new TestWindowTreeClient());
+    client_impl_ = base::MakeUnique<TestWindowTreeClient>();
     client_impl_->Bind(std::move(request));
     if (run_loop_.get())
       run_loop_->Quit();
   }
 
   std::unique_ptr<TestWindowTreeClient> client_impl_;
   std::unique_ptr<base::RunLoop> run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTreeClientFactory);
 };
@@ skipping 93 matching lines @@
   }
 
   // WindowServerServiceTestBase:
   bool OnConnect(const shell::Identity& remote_identity,
                  shell::InterfaceRegistry* registry) override {
     registry->AddInterface(client_factory_.get());
     return true;
   }
 
   void SetUp() override {
-    client_factory_.reset(new WindowTreeClientFactory());
+    client_factory_ = base::MakeUnique<WindowTreeClientFactory>();
 
     WindowServerServiceTestBase::SetUp();
 
     mojom::WindowTreeHostFactoryPtr factory;
     connector()->ConnectToInterface("mojo:ui", &factory);
 
     mojom::WindowTreeClientPtr tree_client_ptr;
-    wt_client1_.reset(new TestWindowTreeClient());
+    wt_client1_ = base::MakeUnique<TestWindowTreeClient>();
     wt_client1_->Bind(GetProxy(&tree_client_ptr));
 
     factory->CreateWindowTreeHost(GetProxy(&host_),
                                   std::move(tree_client_ptr));
 
     // Next we should get an embed call on the "window manager" client.
     wt_client1_->WaitForOnEmbed();
 
     ASSERT_EQ(1u, changes1()->size());
     EXPECT_EQ(CHANGE_TYPE_EMBED, (*changes1())[0].type);
@@ skipping 1465 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 ui