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

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

 // 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.
 
 #include "modules/fetch/DataConsumerHandleTestUtil.h"
 
 #include "bindings/core/v8/DOMWrapperWorld.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
@@ skipping 24 matching lines @@
 };
 
 }  // namespace
 
 DataConsumerHandleTestUtil::Thread::Thread(
     const char* name,
     InitializationPolicy initializationPolicy)
     : m_thread(
           WebThreadSupportingGC::create(name, BlinkGC::MainThreadHeapMode)),
       m_initializationPolicy(initializationPolicy),
-      m_waitableEvent(makeUnique<WaitableEvent>()) {
+      m_waitableEvent(WTF::makeUnique<WaitableEvent>()) {
   m_thread->postTask(
       BLINK_FROM_HERE,
       crossThreadBind(&Thread::initialize, crossThreadUnretained(this)));
   m_waitableEvent->wait();
 }
 
 DataConsumerHandleTestUtil::Thread::~Thread() {
   m_thread->postTask(
       BLINK_FROM_HERE,
       crossThreadBind(&Thread::shutdown, crossThreadUnretained(this)));
   m_waitableEvent->wait();
 }
 
 void DataConsumerHandleTestUtil::Thread::initialize() {
   if (m_initializationPolicy >= ScriptExecution) {
-    m_isolateHolder = makeUnique<gin::IsolateHolder>();
+    m_isolateHolder = WTF::makeUnique<gin::IsolateHolder>();
     isolate()->Enter();
   }
   m_thread->initialize();
   if (m_initializationPolicy >= ScriptExecution) {
     v8::HandleScope handleScope(isolate());
     m_scriptState = ScriptState::create(v8::Context::New(isolate()),
                                         DOMWrapperWorld::create(isolate()));
   }
   if (m_initializationPolicy >= WithExecutionContext) {
     m_executionContext = new NullExecutionContext();
@@ skipping 116 matching lines @@
   consume(readSize);
   return Ok;
 }
 
 DataConsumerHandleTestUtil::ReplayingHandle::Context::Context()
     : m_offset(0),
       m_readerThread(nullptr),
       m_client(nullptr),
       m_result(ShouldWait),
       m_isHandleAttached(true),
-      m_detached(makeUnique<WaitableEvent>()) {}
+      m_detached(WTF::makeUnique<WaitableEvent>()) {}
 
 const DataConsumerHandleTestUtil::Command&
 DataConsumerHandleTestUtil::ReplayingHandle::Context::top() {
   DCHECK(!isEmpty());
   return m_commands.first();
 }
 
 void DataConsumerHandleTestUtil::ReplayingHandle::Context::consume(
     size_t size) {
   DCHECK(!isEmpty());
@@ skipping 30 matching lines @@
 
 DataConsumerHandleTestUtil::ReplayingHandle::ReplayingHandle()
     : m_context(Context::create()) {}
 
 DataConsumerHandleTestUtil::ReplayingHandle::~ReplayingHandle() {
   m_context->detachHandle();
 }
 
 std::unique_ptr<WebDataConsumerHandle::Reader>
 DataConsumerHandleTestUtil::ReplayingHandle::obtainReader(Client* client) {
-  return makeUnique<ReaderImpl>(m_context, client);
+  return WTF::makeUnique<ReaderImpl>(m_context, client);
 }
 
 void DataConsumerHandleTestUtil::ReplayingHandle::add(const Command& command) {
   m_context->add(command);
 }
 
 DataConsumerHandleTestUtil::HandleReader::HandleReader(
     std::unique_ptr<WebDataConsumerHandle> handle,
     std::unique_ptr<OnFinishedReading> onFinishedReading)
     : m_reader(handle->obtainReader(this)),
       m_onFinishedReading(std::move(onFinishedReading)) {}
 
 void DataConsumerHandleTestUtil::HandleReader::didGetReadable() {
   WebDataConsumerHandle::Result r = WebDataConsumerHandle::UnexpectedError;
   char buffer[3];
   while (true) {
     size_t size;
     r = m_reader->read(buffer, sizeof(buffer), WebDataConsumerHandle::FlagNone,
                        &size);
     if (r == WebDataConsumerHandle::ShouldWait)
       return;
     if (r != WebDataConsumerHandle::Ok)
       break;
     m_data.append(buffer, size);
   }
   std::unique_ptr<HandleReadResult> result =
-      makeUnique<HandleReadResult>(r, m_data);
+      WTF::makeUnique<HandleReadResult>(r, m_data);
   m_data.clear();
   Platform::current()->currentThread()->getWebTaskRunner()->postTask(
       BLINK_FROM_HERE,
       WTF::bind(&HandleReader::runOnFinishedReading, WTF::unretained(this),
-                passed(std::move(result))));
+                WTF::passed(std::move(result))));
   m_reader = nullptr;
 }
 
 void DataConsumerHandleTestUtil::HandleReader::runOnFinishedReading(
     std::unique_ptr<HandleReadResult> result) {
   DCHECK(m_onFinishedReading);
   std::unique_ptr<OnFinishedReading> onFinishedReading(
       std::move(m_onFinishedReading));
   (*onFinishedReading)(std::move(result));
 }
@@ skipping 14 matching lines @@
       return;
     if (r != WebDataConsumerHandle::Ok)
       break;
     // Read smaller than available in order to test |endRead|.
     size_t readSize =
         std::min(size, std::max(size * 2 / 3, static_cast<size_t>(1)));
     m_data.append(static_cast<const char*>(buffer), readSize);
     m_reader->endRead(readSize);
   }
   std::unique_ptr<HandleReadResult> result =
-      makeUnique<HandleReadResult>(r, m_data);
+      WTF::makeUnique<HandleReadResult>(r, m_data);
   m_data.clear();
   Platform::current()->currentThread()->getWebTaskRunner()->postTask(
       BLINK_FROM_HERE,
       WTF::bind(&HandleTwoPhaseReader::runOnFinishedReading,
-                WTF::unretained(this), passed(std::move(result))));
+                WTF::unretained(this), WTF::passed(std::move(result))));
   m_reader = nullptr;
 }
 
 void DataConsumerHandleTestUtil::HandleTwoPhaseReader::runOnFinishedReading(
     std::unique_ptr<HandleReadResult> result) {
   DCHECK(m_onFinishedReading);
   std::unique_ptr<OnFinishedReading> onFinishedReading(
       std::move(m_onFinishedReading));
   (*onFinishedReading)(std::move(result));
 }
 
 std::unique_ptr<WebDataConsumerHandle>
 DataConsumerHandleTestUtil::createWaitingDataConsumerHandle() {
-  return wrapUnique(new WaitingHandle);
+  return WTF::wrapUnique(new WaitingHandle);
 }
 
 }  // namespace blink