Replace wrapUnique(new T(args)) by makeUnique<T>(args) in Blink

third_party/WebKit/Source/core/loader/ThreadableLoaderTest.cpp

 // 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 "core/loader/ThreadableLoader.h"
 
 #include "core/dom/ExecutionContextTask.h"
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/ResourceLoaderOptions.h"
 #include "core/loader/DocumentThreadableLoader.h"
@@ skipping 158 matching lines @@
  public:
   explicit WorkerThreadableLoaderTestHelper(
       BlinkGC::ThreadHeapMode threadHeapMode)
       : m_dummyPageHolder(DummyPageHolder::create(IntSize(1, 1))),
         m_threadHeapMode(threadHeapMode) {}
 
   void createLoader(
       ThreadableLoaderClient* client,
       CrossOriginRequestPolicy crossOriginRequestPolicy) override {
     std::unique_ptr<WaitableEvent> completionEvent =
-        wrapUnique(new WaitableEvent());
+        makeUnique<WaitableEvent>();
     postTaskToWorkerGlobalScope(
         BLINK_FROM_HERE,
         createCrossThreadTask(
             &WorkerThreadableLoaderTestHelper::workerCreateLoader,
             crossThreadUnretained(this), crossThreadUnretained(client),
             crossThreadUnretained(completionEvent.get()),
             crossOriginRequestPolicy));
     completionEvent->wait();
   }
 
   void startLoader(const ResourceRequest& request) override {
     std::unique_ptr<WaitableEvent> completionEvent =
-        wrapUnique(new WaitableEvent());
+        makeUnique<WaitableEvent>();
     postTaskToWorkerGlobalScope(
         BLINK_FROM_HERE,
         createCrossThreadTask(
             &WorkerThreadableLoaderTestHelper::workerStartLoader,
             crossThreadUnretained(this),
             crossThreadUnretained(completionEvent.get()), request));
     completionEvent->wait();
   }
 
   // Must be called on the worker thread.
@@ skipping 16 matching lines @@
     DCHECK(m_workerThread->isCurrentThread());
     m_loader = nullptr;
   }
 
   Checkpoint& checkpoint() override { return m_checkpoint; }
 
   void callCheckpoint(int n) override {
     testing::runPendingTasks();
 
     std::unique_ptr<WaitableEvent> completionEvent =
-        wrapUnique(new WaitableEvent());
+        makeUnique<WaitableEvent>();
     postTaskToWorkerGlobalScope(
         BLINK_FROM_HERE,
         createCrossThreadTask(
             &WorkerThreadableLoaderTestHelper::workerCallCheckpoint,
             crossThreadUnretained(this),
             crossThreadUnretained(completionEvent.get()), n));
     completionEvent->wait();
   }
 
   void onSetUp() override {
-    m_mockWorkerReportingProxy = wrapUnique(new MockWorkerReportingProxy());
+    m_mockWorkerReportingProxy = makeUnique<MockWorkerReportingProxy>();
     m_securityOrigin = document().getSecurityOrigin();
     m_workerThread = wrapUnique(new WorkerThreadForTest(
         this, *m_mockWorkerReportingProxy, m_threadHeapMode));
 
     expectWorkerLifetimeReportingCalls();
     m_workerThread->startWithSourceCode(m_securityOrigin.get(),
                                         "//fake source code");
     m_workerThread->waitForInit();
   }
 
@@ skipping 635 matching lines @@
   // test is not saying that didFailAccessControlCheck should be dispatched
   // synchronously, but is saying that even when a response is served
   // synchronously it should not lead to a crash.
   startLoader(KURL(KURL(), "about:blank"));
   callCheckpoint(2);
 }
 
 }  // namespace
 
 }  // namespace blink