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

content/child/web_url_loader_impl.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 "content/child/web_url_loader_impl.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 540 matching lines @@
     resource_dispatcher_->StartSync(
         request_info, request_body.get(), sync_load_response,
         request.getLoadingIPCType(), url_loader_factory_);
     return;
   }
 
   TRACE_EVENT_WITH_FLOW0("loading", "WebURLLoaderImpl::Context::Start", this,
                          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)
     resource_dispatcher_->SetDefersLoading(request_id_, true);
 }
 
 void WebURLLoaderImpl::Context::SetTaskRunner(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) {
   task_runner_ = task_runner;
 }
@@ skipping 94 matching lines @@
   }
 
   if (request_.useStreamOnResponse()) {
     SharedMemoryDataConsumerHandle::BackpressureMode mode =
         SharedMemoryDataConsumerHandle::kDoNotApplyBackpressure;
     if (info.headers &&
         info.headers->HasHeaderValue("Cache-Control", "no-store")) {
       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
     // will break if one of the following happens:
     //  1) The body data transfer is done (with or without an error).
     //  2) |read_handle| (and its reader) is detached.
 
     // The client takes |read_handle|'s ownership.
     client_->didReceiveResponse(loader_, response, read_handle.release());
     // TODO(yhirano): Support ftp listening and multipart
@@ skipping 175 matching lines @@
   ResourceResponseInfo info;
   std::string data;
 
   int error_code = GetInfoFromDataURL(request_.url(), &info, &data);
 
   if (error_code == net::OK) {
     OnReceivedResponse(info);
     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,
                      base::TimeTicks::Now(), 0);
 }
 
 // WebURLLoaderImpl::RequestPeerImpl ------------------------------------------
 
 WebURLLoaderImpl::RequestPeerImpl::RequestPeerImpl(Context* context)
     : context_(context) {}
@@ skipping 327 matching lines @@
     response->clearHTTPHeaderField(webStringName);
     while (response_headers->EnumerateHeader(&iterator, name, &value)) {
       response->addHTTPHeaderField(webStringName,
                                    WebString::fromLatin1(value));
     }
   }
   return true;
 }
 
 }  // namespace content