s/ passed(...) / WTF::passed(...) / to avoid future ambiguity w/ base::Passed.

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 144 matching lines @@
       ThreadHolder* m_holder;
     };
 
     // The reading/updating threads are alive while ThreadHolder is alive.
     class ThreadHolder {
       DISALLOW_NEW();
 
      public:
       ThreadHolder(ThreadingTestBase* test)
           : m_context(test->m_context),
-            m_readingThread(wrapUnique(new Thread("reading thread"))),
-            m_updatingThread(wrapUnique(new Thread("updating thread"))) {
+            m_readingThread(WTF::wrapUnique(new Thread("reading thread"))),
+            m_updatingThread(WTF::wrapUnique(new Thread("updating thread"))) {
         m_context->registerThreadHolder(this);
       }
       ~ThreadHolder() { m_context->unregisterThreadHolder(); }
 
       WebThreadSupportingGC* readingThread() {
         return m_readingThread->thread();
       }
       WebThreadSupportingGC* updatingThread() {
         return m_updatingThread->thread();
       }
@@ skipping 27 matching lines @@
       const String m_name;
       RefPtr<Context> m_context;
     };
     class DataConsumerHandle final : public WebDataConsumerHandle {
       USING_FAST_MALLOC(DataConsumerHandle);
 
      public:
       static std::unique_ptr<WebDataConsumerHandle> create(
           const String& name,
           PassRefPtr<Context> context) {
-        return wrapUnique(new DataConsumerHandle(name, std::move(context)));
+        return WTF::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 makeUnique<ReaderImpl>(m_name, m_context);
+        return WTF::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 = makeUnique<WaitableEvent>();
+      m_waitableEvent = WTF::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 = makeUnique<WaitableEvent>();
+      m_waitableEvent = WTF::makeUnique<WaitableEvent>();
       m_handle = std::move(handle);
 
       postTaskToReadingThreadAndWait(
           BLINK_FROM_HERE,
           crossThreadBind(&Self::obtainReader, wrapPassRefPtr(this)));
     }
 
    private:
     ThreadingHandleNoNotificationTest() = default;
     void obtainReader() {
@@ skipping 33 matching lines @@
     Vector<char> m_body;
   };
 
   // ReplayingHandle stores commands via |add| and replays the stored commends
   // when read.
   class ReplayingHandle final : public WebDataConsumerHandle {
     USING_FAST_MALLOC(ReplayingHandle);
 
    public:
     static std::unique_ptr<ReplayingHandle> create() {
-      return wrapUnique(new ReplayingHandle());
+      return WTF::wrapUnique(new ReplayingHandle());
     }
     ~ReplayingHandle();
 
     // Add a command to this handle. This function must be called on the
     // creator thread. This function must be called BEFORE any reader is
     // obtained.
     void add(const Command&);
 
     class Context final : public ThreadSafeRefCounted<Context> {
      public:
@@ skipping 98 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(makeUnique<WaitableEvent>()),
+        : m_thread(WTF::wrapUnique(new Thread("reading thread"))),
+          m_event(WTF::makeUnique<WaitableEvent>()),
           m_isDone(false) {
-      m_thread->thread()->postTask(BLINK_FROM_HERE,
-                                   crossThreadBind(&HandleReaderRunner::start,
-                                                   crossThreadUnretained(this),
-                                                   passed(std::move(handle))));
+      m_thread->thread()->postTask(
+          BLINK_FROM_HERE, crossThreadBind(&HandleReaderRunner::start,
+                                           crossThreadUnretained(this),
+                                           WTF::passed(std::move(handle))));
     }
     ~HandleReaderRunner() { wait(); }
 
     std::unique_ptr<HandleReadResult> wait() {
       if (m_isDone)
         return nullptr;
       m_event->wait();
       m_isDone = true;
       return std::move(m_result);
     }
 
    private:
     void start(std::unique_ptr<WebDataConsumerHandle> handle) {
-      m_handleReader = wrapUnique(new T(
+      m_handleReader = WTF::wrapUnique(new T(
           std::move(handle),
           WTF::bind(&HandleReaderRunner::onFinished, WTF::unretained(this))));
     }
 
     void onFinished(std::unique_ptr<HandleReadResult> result) {
       m_handleReader = nullptr;
       m_result = std::move(result);
       m_event->signal();
     }
 
     std::unique_ptr<Thread> m_thread;
     std::unique_ptr<WaitableEvent> m_event;
     std::unique_ptr<HandleReadResult> m_result;
     bool m_isDone;
 
     std::unique_ptr<T> m_handleReader;
   };
 
   static std::unique_ptr<WebDataConsumerHandle>
   createWaitingDataConsumerHandle();
 };
 
 }  // namespace blink
 
 #endif  // DataConsumerHandleTestUtil_h