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

third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.h

 // 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.
 
 #ifndef DataConsumerHandleTestUtil_h
 #define DataConsumerHandleTestUtil_h
 
 #include "bindings/core/v8/ScriptState.h"
 #include "core/testing/NullExecutionContext.h"
 #include "gin/public/isolate_holder.h"
@@ skipping 201 matching lines @@
           const String& name,
           PassRefPtr<Context> context) {
         return wrapUnique(new DataConsumerHandle(name, std::move(context)));
       }
 
      private:
       DataConsumerHandle(const String& name, PassRefPtr<Context> context)
           : m_name(name.isolatedCopy()), m_context(context) {}
 
       std::unique_ptr<Reader> obtainReader(Client*) {
-        return WTF::wrapUnique(new ReaderImpl(m_name, m_context));
+        return makeUnique<ReaderImpl>(m_name, m_context);
       }
       const char* debugName() const override {
         return "ThreadingTestBase::DataConsumerHandle";
       }
 
       const String m_name;
       RefPtr<Context> m_context;
     };
 
     void resetReader() { m_reader = nullptr; }
@@ skipping 30 matching lines @@
   };
 
   class ThreadingHandleNotificationTest : public ThreadingTestBase,
                                           public WebDataConsumerHandle::Client {
    public:
     using Self = ThreadingHandleNotificationTest;
     static PassRefPtr<Self> create() { return adoptRef(new Self); }
 
     void run(std::unique_ptr<WebDataConsumerHandle> handle) {
       ThreadHolder holder(this);
-      m_waitableEvent = wrapUnique(new WaitableEvent());
+      m_waitableEvent = makeUnique<WaitableEvent>();
       m_handle = std::move(handle);
 
       postTaskToReadingThreadAndWait(
           BLINK_FROM_HERE,
           crossThreadBind(&Self::obtainReader, wrapPassRefPtr(this)));
     }
 
    private:
     ThreadingHandleNotificationTest() = default;
     void obtainReader() { m_reader = m_handle->obtainReader(this); }
@@ skipping 11 matching lines @@
 
   class ThreadingHandleNoNotificationTest
       : public ThreadingTestBase,
         public WebDataConsumerHandle::Client {
    public:
     using Self = ThreadingHandleNoNotificationTest;
     static PassRefPtr<Self> create() { return adoptRef(new Self); }
 
     void run(std::unique_ptr<WebDataConsumerHandle> handle) {
       ThreadHolder holder(this);
-      m_waitableEvent = wrapUnique(new WaitableEvent());
+      m_waitableEvent = makeUnique<WaitableEvent>();
       m_handle = std::move(handle);
 
       postTaskToReadingThreadAndWait(
           BLINK_FROM_HERE,
           crossThreadBind(&Self::obtainReader, wrapPassRefPtr(this)));
     }
 
    private:
     ThreadingHandleNoNotificationTest() = default;
     void obtainReader() {
@@ skipping 153 matching lines @@
 
   // HandleReaderRunner<T> creates a dedicated thread and run T on the thread
   // where T is one of HandleReader and HandleTwophaseReader.
   template <typename T>
   class HandleReaderRunner final {
     STACK_ALLOCATED();
 
    public:
     explicit HandleReaderRunner(std::unique_ptr<WebDataConsumerHandle> handle)
         : m_thread(wrapUnique(new Thread("reading thread"))),
-          m_event(wrapUnique(new WaitableEvent())),
+          m_event(makeUnique<WaitableEvent>()),
           m_isDone(false) {
       m_thread->thread()->postTask(BLINK_FROM_HERE,
                                    crossThreadBind(&HandleReaderRunner::start,
                                                    crossThreadUnretained(this),
                                                    passed(std::move(handle))));
     }
     ~HandleReaderRunner() { wait(); }
 
     std::unique_ptr<HandleReadResult> wait() {
       if (m_isDone)
@@ skipping 24 matching lines @@
     std::unique_ptr<T> m_handleReader;
   };
 
   static std::unique_ptr<WebDataConsumerHandle>
   createWaitingDataConsumerHandle();
 };
 
 }  // namespace blink
 
 #endif  // DataConsumerHandleTestUtil_h