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

content/child/shared_memory_data_consumer_handle_unittest.cc

 // Copyright 2015 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 "content/child/shared_memory_data_consumer_handle.h"
 
 #include <stddef.h>
 #include <string.h>
 
 #include <string>
@@ skipping 185 matching lines @@
 };
 
 class SharedMemoryDataConsumerHandleTest
     : public ::testing::TestWithParam<BackpressureMode> {
  protected:
   void SetUp() override {
     handle_.reset(new SharedMemoryDataConsumerHandle(GetParam(), &writer_));
   }
   std::unique_ptr<FixedReceivedData> NewFixedData(const char* s) {
     auto size = strlen(s);
-    return base::WrapUnique(new FixedReceivedData(s, size, size, size));
+    return base::MakeUnique<FixedReceivedData>(s, size, size, size);
   }
 
   StrictMock<MockClient> client_;
   std::unique_ptr<SharedMemoryDataConsumerHandle> handle_;
   std::unique_ptr<Writer> writer_;
   base::MessageLoop loop_;
 };
 
 void RunPostedTasks() {
   base::RunLoop run_loop;
@@ skipping 683 matching lines @@
   checkpoint.Call(3);
 }
 
 TEST(SharedMemoryDataConsumerHandleBackpressureTest, Read) {
   base::MessageLoop loop;
   char buffer[20];
   Result result;
   size_t size;
 
   std::unique_ptr<Writer> writer;
-  auto handle = base::WrapUnique(
-      new SharedMemoryDataConsumerHandle(kApplyBackpressure, &writer));
+  auto handle = base::MakeUnique<SharedMemoryDataConsumerHandle>(
+      kApplyBackpressure, &writer);
   scoped_refptr<Logger> logger(new Logger);
   writer->AddData(
-      base::WrapUnique(new LoggingFixedReceivedData("data1", "Once ", logger)));
+      base::MakeUnique<LoggingFixedReceivedData>("data1", "Once ", logger));
   writer->AddData(
-      base::WrapUnique(new LoggingFixedReceivedData("data2", "upon ", logger)));
+      base::MakeUnique<LoggingFixedReceivedData>("data2", "upon ", logger));
   writer->AddData(
-      base::WrapUnique(new LoggingFixedReceivedData("data3", "a ", logger)));
+      base::MakeUnique<LoggingFixedReceivedData>("data3", "a ", logger));
   writer->AddData(
-      base::WrapUnique(new LoggingFixedReceivedData("data4", "time ", logger)));
+      base::MakeUnique<LoggingFixedReceivedData>("data4", "time ", logger));
 
   auto reader = handle->obtainReader(nullptr);
   logger->Add("1");
   result = reader->read(buffer, 2, kNone, &size);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(2u, size);
   logger->Add("2");
   result = reader->read(buffer, 5, kNone, &size);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(5u, size);
@@ skipping 14 matching lines @@
       logger->log());
 }
 
 TEST(SharedMemoryDataConsumerHandleBackpressureTest, CloseAndReset) {
   base::MessageLoop loop;
   char buffer[20];
   Result result;
   size_t size;
 
   std::unique_ptr<Writer> writer;
-  auto handle = base::WrapUnique(
-      new SharedMemoryDataConsumerHandle(kApplyBackpressure, &writer));
+  auto handle = base::MakeUnique<SharedMemoryDataConsumerHandle>(
+      kApplyBackpressure, &writer);
   scoped_refptr<Logger> logger(new Logger);
   writer->AddData(
-      base::WrapUnique(new LoggingFixedReceivedData("data1", "Once ", logger)));
+      base::MakeUnique<LoggingFixedReceivedData>("data1", "Once ", logger));
   writer->AddData(
-      base::WrapUnique(new LoggingFixedReceivedData("data2", "upon ", logger)));
+      base::MakeUnique<LoggingFixedReceivedData>("data2", "upon ", logger));
   writer->AddData(
-      base::WrapUnique(new LoggingFixedReceivedData("data3", "a ", logger)));
+      base::MakeUnique<LoggingFixedReceivedData>("data3", "a ", logger));
 
   auto reader = handle->obtainReader(nullptr);
   logger->Add("1");
   result = reader->read(buffer, 2, kNone, &size);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(2u, size);
   logger->Add("2");
   writer->Close();
   logger->Add("3");
   handle.reset();
   reader.reset();
   logger->Add("4");
 
   EXPECT_EQ(
       "1\n"
       "2\n"
       "3\n"
       "data1 is destructed.\n"
       "data2 is destructed.\n"
       "data3 is destructed.\n"
       "4\n",
       logger->log());
 }
 
 TEST(SharedMemoryDataConsumerHandleWithoutBackpressureTest, AddData) {
   base::MessageLoop loop;
   std::unique_ptr<Writer> writer;
-  auto handle = base::WrapUnique(
-      new SharedMemoryDataConsumerHandle(kDoNotApplyBackpressure, &writer));
+  auto handle = base::MakeUnique<SharedMemoryDataConsumerHandle>(
+      kDoNotApplyBackpressure, &writer);
   scoped_refptr<Logger> logger(new Logger);
 
   logger->Add("1");
   writer->AddData(
-      base::WrapUnique(new LoggingFixedReceivedData("data1", "Once ", logger)));
+      base::MakeUnique<LoggingFixedReceivedData>("data1", "Once ", logger));
   logger->Add("2");
   writer->AddData(
-      base::WrapUnique(new LoggingFixedReceivedData("data2", "upon ", logger)));
+      base::MakeUnique<LoggingFixedReceivedData>("data2", "upon ", logger));
   logger->Add("3");
 
   EXPECT_EQ(
       "1\n"
       "data1 is destructed.\n"
       "2\n"
       "data2 is destructed.\n"
       "3\n",
       logger->log());
 }
 
 TEST_F(ThreadedSharedMemoryDataConsumerHandleTest, Read) {
   base::RunLoop run_loop;
-  auto operation = base::WrapUnique(new ReadDataOperation(
-      std::move(handle_), &loop_, run_loop.QuitClosure()));
+  auto operation = base::MakeUnique<ReadDataOperation>(
+      std::move(handle_), &loop_, run_loop.QuitClosure());
   scoped_refptr<Logger> logger(new Logger);
 
   base::Thread t("DataConsumerHandle test thread");
   ASSERT_TRUE(t.Start());
 
   t.task_runner()->PostTask(FROM_HERE,
                             base::Bind(&ReadDataOperation::ReadData,
                                        base::Unretained(operation.get())));
 
   logger->Add("1");
   writer_->AddData(
-      base::WrapUnique(new LoggingFixedReceivedData("data1", "Once ", logger)));
+      base::MakeUnique<LoggingFixedReceivedData>("data1", "Once ", logger));
   writer_->AddData(
-      base::WrapUnique(new LoggingFixedReceivedData("data2", "upon ", logger)));
-  writer_->AddData(base::WrapUnique(
-      new LoggingFixedReceivedData("data3", "a time ", logger)));
-  writer_->AddData(base::WrapUnique(
-      new LoggingFixedReceivedData("data4", "there ", logger)));
+      base::MakeUnique<LoggingFixedReceivedData>("data2", "upon ", logger));
   writer_->AddData(
-      base::WrapUnique(new LoggingFixedReceivedData("data5", "was ", logger)));
+      base::MakeUnique<LoggingFixedReceivedData>("data3", "a time ", logger));
+  writer_->AddData(
+      base::MakeUnique<LoggingFixedReceivedData>("data4", "there ", logger));
+  writer_->AddData(
+      base::MakeUnique<LoggingFixedReceivedData>("data5", "was ", logger));
   writer_->Close();
   logger->Add("2");
 
   run_loop.Run();
   t.Stop();
 
   EXPECT_EQ("Once upon a time there was ", operation->result());
   EXPECT_EQ(
       "1\n"
       "2\n"
       "data1 is destructed.\n"
       "data2 is destructed.\n"
       "data3 is destructed.\n"
       "data4 is destructed.\n"
       "data5 is destructed.\n",
       logger->log());
 }
 
 INSTANTIATE_TEST_CASE_P(SharedMemoryDataConsumerHandleTest,
                         SharedMemoryDataConsumerHandleTest,
                         ::testing::Values(kApplyBackpressure,
                                           kDoNotApplyBackpressure));
 }  // namespace
 
 }  // namespace content