Re-write many calls to WrapUnique() with MakeUnique()

blimp/net/thread_pipe_manager_unittest.cc

 // Copyright 2016 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 "blimp/net/thread_pipe_manager.h"
 
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 81 matching lines @@
 // with one it just sent.
 class FakeBrowserConnectionHandler : public BrowserConnectionHandler {
  public:
   FakeBrowserConnectionHandler(
       const scoped_refptr<base::SequencedTaskRunner>& task_runner)
       : task_runner_(task_runner) {}
   std::unique_ptr<BlimpMessageProcessor> RegisterFeature(
       BlimpMessage::FeatureCase feature_case,
       BlimpMessageProcessor* incoming_processor) override {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
-    return base::WrapUnique(
-        new FakeFeaturePeer(feature_case, incoming_processor, task_runner_));
+    return base::MakeUnique<FakeFeaturePeer>(feature_case, incoming_processor,
+                                             task_runner_);
   }
 
  private:
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 };
 
 }  // namespace
 
 class ThreadPipeManagerTest : public testing::Test {
  public:
   ThreadPipeManagerTest() : thread_("IoThread") {}
 
   ~ThreadPipeManagerTest() override {}
 
   void SetUp() override {
     ASSERT_TRUE(thread_.Start());
-    connection_handler_ = base::WrapUnique(
-        new FakeBrowserConnectionHandler(thread_.task_runner()));
-    pipe_manager_ = base::WrapUnique(new ThreadPipeManager(
-        thread_.task_runner(), connection_handler_.get()));
+    connection_handler_ =
+        base::MakeUnique<FakeBrowserConnectionHandler>(thread_.task_runner());
+    pipe_manager_ = base::MakeUnique<ThreadPipeManager>(
+        thread_.task_runner(), connection_handler_.get());
 
     input_feature_.reset(
         new FakeFeature(BlimpMessage::kInput, pipe_manager_.get()));
     tab_control_feature_.reset(
         new FakeFeature(BlimpMessage::kTabControl, pipe_manager_.get()));
   }
 
   void TearDown() override { SynchronizeWithThread(); }
 
   // Synchronize with |thread_| to ensure that any pending work is done.
@@ skipping 36 matching lines @@
       std::move(input_message), cb1.callback());
   net::TestCompletionCallback cb2;
   tab_control_feature_->outgoing_message_processor()->ProcessMessage(
       std::move(tab_control_message), cb2.callback());
 
   EXPECT_EQ(net::OK, cb1.WaitForResult());
   EXPECT_EQ(net::OK, cb2.WaitForResult());
 }
 
 }  // namespace blimp