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

A mostly-automated change to convert instances of WrapUnique(new Foo(...)) to
MakeUnique<Foo>(...). See the thread at
https://groups.google.com/a/chromium.org/forum/#!topic/chromium-dev/iQgMedVA8-k
for background.

To avoid requiring too many manual fixups, the change skips some cases that are
frequently problematic. In particular, in methods named Foo::Method() it will
not try to change WrapUnique(new Foo()) to MakeUnique<Foo>(). This is because
Foo::Method() may be accessing an internal constructor of Foo.

Cases where MakeUnique<NestedClass>(...) is called within a method of
OuterClass are common but hard to detect automatically, so have been fixed-up
manually.

The only types of manual fix ups applied are:
1) Revert MakeUnique back to WrapUnique
2) Change NULL to nullptr in argument list (MakeUnique cannot forward NULL
   correctly)
3) Add base:: namespace qualifier where missing.

WrapUnique(new Foo) has not been converted to MakeUnique<Foo>() as this might
change behaviour if Foo does not have a user-defined constructor. For example,
WrapUnique(new int) creates an unitialised integer, but MakeUnique<int>()
creates an integer initialised to 0.

git cl format has been been run over the CL. Spot-checking has uncovered no
cases of mis-formatting.

BUG=637812

Review-Url: https://codereview.chromium.org/2254173002
Cr-Commit-Position: refs/heads/master@{#414315}

content/child/child_discardable_shared_memory_manager.cc

@@ -167,8 +167,7 @@ ChildDiscardableSharedMemoryManager::AllocateLockedDiscardableMemory(
     // at least one span from the free lists.
     MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists());
 
-    return base::WrapUnique(
-        new DiscardableMemoryImpl(this, std::move(free_span)));
+    return base::MakeUnique<DiscardableMemoryImpl>(this, std::move(free_span));
   }
 
   // Release purged memory to free up the address space before we attempt to
@@ -210,7 +209,7 @@ ChildDiscardableSharedMemoryManager::AllocateLockedDiscardableMemory(
 
   MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists());
 
-  return base::WrapUnique(new DiscardableMemoryImpl(this, std::move(new_span)));
+  return base::MakeUnique<DiscardableMemoryImpl>(this, std::move(new_span));
 }
 
 bool ChildDiscardableSharedMemoryManager::OnMemoryDump(

content/child/child_shared_bitmap_manager.cc

@@ -117,7 +117,7 @@ ChildSharedBitmapManager::AllocateSharedMemoryBitmap(const gfx::Size& size) {
     // Shutdown path, so use EXIT_SUCCESS. https://crbug.com/615121.
     exit(EXIT_SUCCESS);
   }
-  memory = base::WrapUnique(new base::SharedMemory(handle, false));
+  memory = base::MakeUnique<base::SharedMemory>(handle, false);
   if (!memory->Map(memory_size))
     CollectMemoryUsageAndDie(size, memory_size);
 #else
@@ -142,8 +142,7 @@ ChildSharedBitmapManager::AllocateSharedMemoryBitmap(const gfx::Size& size) {
   sender_->Send(new ChildProcessHostMsg_AllocatedSharedBitmap(
       memory_size, handle_to_send, id));
 #endif
-  return base::WrapUnique(
-      new ChildSharedBitmap(sender_, std::move(memory), id));
+  return base::MakeUnique<ChildSharedBitmap>(sender_, std::move(memory), id);
 }
 
 std::unique_ptr<cc::SharedBitmap>
@@ -164,7 +163,7 @@ ChildSharedBitmapManager::GetBitmapForSharedMemory(base::SharedMemory* mem) {
   sender_->Send(new ChildProcessHostMsg_AllocatedSharedBitmap(
       mem->mapped_size(), handle_to_send, id));
 
-  return base::WrapUnique(new ChildSharedBitmap(sender_, mem, id));
+  return base::MakeUnique<ChildSharedBitmap>(sender_, mem, id);
 }
 
 }  // namespace content

content/child/indexed_db/webidbcursor_impl_unittest.cc

@@ -139,8 +139,7 @@ class WebIDBCursorImplTest : public testing::Test {
     null_key_.assignNull();
     thread_safe_sender_ = new ThreadSafeSender(
         base::ThreadTaskRunnerHandle::Get(), new MockSyncMessageFilter);
-    dispatcher_ =
-        base::WrapUnique(new MockDispatcher(thread_safe_sender_.get()));
+    dispatcher_ = base::MakeUnique<MockDispatcher>(thread_safe_sender_.get());
   }
 
  protected:

content/child/push_messaging/push_provider.cc

@@ -167,9 +167,9 @@ void PushProvider::OnSubscribeFromWorkerSuccess(
   if (!callbacks)
     return;
 
-  callbacks->onSuccess(base::WrapUnique(new blink::WebPushSubscription(
+  callbacks->onSuccess(base::MakeUnique<blink::WebPushSubscription>(
       endpoint, options.user_visible_only,
-      blink::WebString::fromLatin1(options.sender_info), p256dh, auth)));
+      blink::WebString::fromLatin1(options.sender_info), p256dh, auth));
 
   subscription_callbacks_.Remove(request_id);
 }
@@ -229,9 +229,9 @@ void PushProvider::OnGetSubscriptionSuccess(
   if (!callbacks)
     return;
 
-  callbacks->onSuccess(base::WrapUnique(new blink::WebPushSubscription(
+  callbacks->onSuccess(base::MakeUnique<blink::WebPushSubscription>(
       endpoint, options.user_visible_only,
-      blink::WebString::fromLatin1(options.sender_info), p256dh, auth)));
+      blink::WebString::fromLatin1(options.sender_info), p256dh, auth));
 
   subscription_callbacks_.Remove(request_id);
 }

content/child/resource_dispatcher.cc

@@ -639,9 +639,9 @@ int ResourceDispatcher::StartAsync(
 
   // Compute a unique request_id for this renderer process.
   int request_id = MakeRequestID();
-  pending_requests_[request_id] = base::WrapUnique(new PendingRequestInfo(
+  pending_requests_[request_id] = base::MakeUnique<PendingRequestInfo>(
       std::move(peer), request->resource_type, request->origin_pid,
-      frame_origin, request->url, request_info.download_to_file));
+      frame_origin, request->url, request_info.download_to_file);
 
   if (resource_scheduling_filter_.get() && request_info.loading_task_runner) {
     resource_scheduling_filter_->SetRequestIdTaskRunner(

content/child/resource_dispatcher_unittest.cc

@@ -519,7 +519,7 @@ class TestResourceDispatcherDelegate : public ResourceDispatcherDelegate {
       std::unique_ptr<RequestPeer> current_peer,
       const std::string& mime_type,
       const GURL& url) override {
-    return base::WrapUnique(new WrapperPeer(std::move(current_peer)));
+    return base::MakeUnique<WrapperPeer>(std::move(current_peer));
   }
 
   class WrapperPeer : public RequestPeer {
@@ -552,8 +552,8 @@ class TestResourceDispatcherDelegate : public ResourceDispatcherDelegate {
                             int64_t total_transfer_size) override {
       original_peer_->OnReceivedResponse(response_info_);
       if (!data_.empty()) {
-        original_peer_->OnReceivedData(base::WrapUnique(new FixedReceivedData(
-            data_.data(), data_.size(), -1, data_.size())));
+        original_peer_->OnReceivedData(base::MakeUnique<FixedReceivedData>(
+            data_.data(), data_.size(), -1, data_.size()));
       }
       original_peer_->OnCompletedRequest(error_code, was_ignored_by_handler,
                                          stale_copy_in_cache, security_info,

content/child/service_worker/web_service_worker_impl.cc

@@ -135,7 +135,7 @@ WebServiceWorkerImpl::CreateHandle(
     const scoped_refptr<WebServiceWorkerImpl>& worker) {
   if (!worker)
     return nullptr;
-  return base::WrapUnique(new HandleImpl(worker));
+  return base::MakeUnique<HandleImpl>(worker);
 }
 
 WebServiceWorkerImpl::~WebServiceWorkerImpl() {

content/child/service_worker/web_service_worker_registration_impl.cc

@@ -155,7 +155,7 @@ WebServiceWorkerRegistrationImpl::CreateHandle(
     const scoped_refptr<WebServiceWorkerRegistrationImpl>& registration) {
   if (!registration)
     return nullptr;
-  return base::WrapUnique(new HandleImpl(registration));
+  return base::MakeUnique<HandleImpl>(registration);
 }
 
 blink::WebServiceWorkerRegistration::Handle*

content/child/shared_memory_data_consumer_handle.cc

@@ -311,9 +311,9 @@ void SharedMemoryDataConsumerHandle::Writer::AddData(
     std::unique_ptr<RequestPeer::ThreadSafeReceivedData> data_to_pass;
     if (mode_ == kApplyBackpressure) {
       data_to_pass =
-          base::WrapUnique(new DelegateThreadSafeReceivedData(std::move(data)));
+          base::MakeUnique<DelegateThreadSafeReceivedData>(std::move(data));
     } else {
-      data_to_pass = base::WrapUnique(new FixedReceivedData(data.get()));
+      data_to_pass = base::MakeUnique<FixedReceivedData>(data.get());
     }
     context_->Push(std::move(data_to_pass));
   }

content/child/shared_memory_data_consumer_handle_unittest.cc

@@ -203,7 +203,7 @@ class SharedMemoryDataConsumerHandleTest
   }
   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_;
@@ -907,17 +907,17 @@ TEST(SharedMemoryDataConsumerHandleBackpressureTest, Read) {
   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");
@@ -952,15 +952,15 @@ TEST(SharedMemoryDataConsumerHandleBackpressureTest, CloseAndReset) {
   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");
@@ -988,16 +988,16 @@ TEST(SharedMemoryDataConsumerHandleBackpressureTest, CloseAndReset) {
 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(
@@ -1011,8 +1011,8 @@ TEST(SharedMemoryDataConsumerHandleWithoutBackpressureTest, AddData) {
 
 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");
@@ -1024,15 +1024,15 @@ TEST_F(ThreadedSharedMemoryDataConsumerHandleTest, Read) {
 
   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");
 

content/child/shared_memory_received_data_factory.cc

@@ -75,8 +75,8 @@ SharedMemoryReceivedDataFactory::Create(int offset,
   const char* payload = start + offset;
   TicketId id = id_++;
 
-  return base::WrapUnique(new SharedMemoryReceivedData(
-      payload, length, encoded_data_length, encoded_body_length, this, id));
+  return base::MakeUnique<SharedMemoryReceivedData>(
+      payload, length, encoded_data_length, encoded_body_length, this, id);
 }
 
 void SharedMemoryReceivedDataFactory::Stop() {

content/child/url_response_body_consumer.cc

@@ -106,8 +106,8 @@ void URLResponseBodyConsumer::OnReadable(MojoResult unused) {
     ResourceDispatcher::PendingRequestInfo* request_info =
         resource_dispatcher_->GetPendingRequestInfo(request_id_);
     DCHECK(request_info);
-    request_info->peer->OnReceivedData(base::WrapUnique(
-        new ReceivedData(static_cast<const char*>(buffer), available, this)));
+    request_info->peer->OnReceivedData(base::MakeUnique<ReceivedData>(
+        static_cast<const char*>(buffer), available, this));
   }
 }
 

content/child/url_response_body_consumer_unittest.cc

@@ -112,7 +112,7 @@ class URLResponseBodyConsumerTest : public ::testing::Test,
   int SetUpRequestPeer(const RequestInfo& request_info,
                        TestRequestPeer::Context* context) {
     return dispatcher_->StartAsync(
-        request_info, nullptr, base::WrapUnique(new TestRequestPeer(context)),
+        request_info, nullptr, base::MakeUnique<TestRequestPeer>(context),
         blink::WebURLRequest::LoadingIPCType::ChromeIPC, nullptr);
   }
 

content/child/web_data_consumer_handle_impl_unittest.cc

@@ -236,8 +236,8 @@ class WebDataConsumerHandleImplTest : public ::testing::Test {
 
 TEST_F(WebDataConsumerHandleImplTest, ReadData) {
   base::RunLoop run_loop;
-  auto operation = base::WrapUnique(new ReadDataOperation(
-      std::move(consumer_), &message_loop_, run_loop.QuitClosure()));
+  auto operation = base::MakeUnique<ReadDataOperation>(
+      std::move(consumer_), &message_loop_, run_loop.QuitClosure());
 
   base::Thread t("DataConsumerHandle test thread");
   ASSERT_TRUE(t.Start());
@@ -257,8 +257,8 @@ TEST_F(WebDataConsumerHandleImplTest, ReadData) {
 
 TEST_F(WebDataConsumerHandleImplTest, TwoPhaseReadData) {
   base::RunLoop run_loop;
-  auto operation = base::WrapUnique(new TwoPhaseReadDataOperation(
-      std::move(consumer_), &message_loop_, run_loop.QuitClosure()));
+  auto operation = base::MakeUnique<TwoPhaseReadDataOperation>(
+      std::move(consumer_), &message_loop_, run_loop.QuitClosure());
 
   base::Thread t("DataConsumerHandle test thread");
   ASSERT_TRUE(t.Start());

content/child/web_url_loader_impl.cc

@@ -558,7 +558,7 @@ void WebURLLoaderImpl::Context::Start(const WebURLRequest& request,
                          TRACE_EVENT_FLAG_FLOW_OUT);
   request_id_ = resource_dispatcher_->StartAsync(
       request_info, request_body.get(),
-      base::WrapUnique(new WebURLLoaderImpl::RequestPeerImpl(this)),
+      base::MakeUnique<WebURLLoaderImpl::RequestPeerImpl>(this),
       request.getLoadingIPCType(), url_loader_factory_);
 
   if (defers_loading_ != NOT_DEFERRING)
@@ -673,9 +673,9 @@ void WebURLLoaderImpl::Context::OnReceivedResponse(
       mode = SharedMemoryDataConsumerHandle::kApplyBackpressure;
     }
 
-    auto read_handle = base::WrapUnique(new SharedMemoryDataConsumerHandle(
+    auto read_handle = base::MakeUnique<SharedMemoryDataConsumerHandle>(
         mode, base::Bind(&Context::CancelBodyStreaming, this),
-        &body_stream_writer_));
+        &body_stream_writer_);
 
     // Here |body_stream_writer_| has an indirect reference to |this| and that
     // creates a reference cycle, but it is not a problem because the cycle
@@ -871,7 +871,7 @@ void WebURLLoaderImpl::Context::HandleDataURL() {
     auto size = data.size();
     if (size != 0)
       OnReceivedData(
-          base::WrapUnique(new FixedReceivedData(data.data(), size, 0, size)));
+          base::MakeUnique<FixedReceivedData>(data.data(), size, 0, size));
   }
 
   OnCompletedRequest(error_code, false, false, info.security_info,

content/child/web_url_loader_impl_unittest.cc

@@ -320,7 +320,7 @@ class WebURLLoaderImplTest : public testing::Test {
     EXPECT_EQ("", client()->received_data());
     auto size = strlen(kTestData);
     peer()->OnReceivedData(
-        base::WrapUnique(new FixedReceivedData(kTestData, size, size, size)));
+        base::MakeUnique<FixedReceivedData>(kTestData, size, size, size));
     EXPECT_EQ(kTestData, client()->received_data());
   }
 
@@ -353,8 +353,8 @@ class WebURLLoaderImplTest : public testing::Test {
 
   void DoReceiveDataFtp() {
     auto size = strlen(kFtpDirListing);
-    peer()->OnReceivedData(base::WrapUnique(
-        new FixedReceivedData(kFtpDirListing, size, size, size)));
+    peer()->OnReceivedData(
+        base::MakeUnique<FixedReceivedData>(kFtpDirListing, size, size, size));
     // The FTP delegate should modify the data the client sees.
     EXPECT_NE(kFtpDirListing, client()->received_data());
   }