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

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 30 matching lines @@
 using ::testing::_;
 using ::testing::InSequence;
 using ::testing::InvokeWithoutArgs;
 using ::testing::StrEq;
 using ::testing::Truly;
 using Checkpoint = ::testing::StrictMock<::testing::MockFunction<void(int)>>;
 
 class MockThreadableLoaderClient : public ThreadableLoaderClient {
  public:
   static std::unique_ptr<MockThreadableLoaderClient> create() {
-    return wrapUnique(new ::testing::StrictMock<MockThreadableLoaderClient>);
+    return WTF::wrapUnique(
+        new ::testing::StrictMock<MockThreadableLoaderClient>);
   }
   MOCK_METHOD2(didSendData, void(unsigned long long, unsigned long long));
   MOCK_METHOD3(didReceiveResponseMock,
                void(unsigned long,
                     const ResourceResponse&,
                     WebDataConsumerHandle*));
   void didReceiveResponse(unsigned long identifier,
                           const ResourceResponse& response,
                           std::unique_ptr<WebDataConsumerHandle> handle) {
     didReceiveResponseMock(identifier, response, handle.get());
@@ skipping 107 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 =
-        makeUnique<WaitableEvent>();
+        WTF::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 =
-        makeUnique<WaitableEvent>();
+        WTF::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 =
-        makeUnique<WaitableEvent>();
+        WTF::makeUnique<WaitableEvent>();
     postTaskToWorkerGlobalScope(
         BLINK_FROM_HERE,
         createCrossThreadTask(
             &WorkerThreadableLoaderTestHelper::workerCallCheckpoint,
             crossThreadUnretained(this),
             crossThreadUnretained(completionEvent.get()), n));
     completionEvent->wait();
   }
 
   void onSetUp() override {
-    m_mockWorkerReportingProxy = makeUnique<MockWorkerReportingProxy>();
+    m_mockWorkerReportingProxy = WTF::makeUnique<MockWorkerReportingProxy>();
     m_securityOrigin = document().getSecurityOrigin();
-    m_workerThread = wrapUnique(new WorkerThreadForTest(
+    m_workerThread = WTF::wrapUnique(new WorkerThreadForTest(
         this, *m_mockWorkerReportingProxy, m_threadHeapMode));
 
     expectWorkerLifetimeReportingCalls();
     m_workerThread->startWithSourceCode(m_securityOrigin.get(),
                                         "//fake source code");
     m_workerThread->waitForInit();
   }
 
   void onServeRequests() override { testing::runPendingTasks(); }
 
@@ skipping 95 matching lines @@
   CrossThreadPersistent<ThreadableLoader> m_loader;
   const BlinkGC::ThreadHeapMode m_threadHeapMode;
 };
 
 class ThreadableLoaderTest
     : public ::testing::TestWithParam<ThreadableLoaderToTest> {
  public:
   ThreadableLoaderTest() {
     switch (GetParam()) {
       case DocumentThreadableLoaderTest:
-        m_helper = wrapUnique(new DocumentThreadableLoaderTestHelper);
+        m_helper = WTF::wrapUnique(new DocumentThreadableLoaderTestHelper);
         break;
       case WorkerThreadableLoaderTest:
-        m_helper = wrapUnique(
+        m_helper = WTF::wrapUnique(
             new WorkerThreadableLoaderTestHelper(BlinkGC::MainThreadHeapMode));
         break;
       case PerThreadHeapEnabledWorkerThreadableLoaderTest:
-        m_helper = wrapUnique(
+        m_helper = WTF::wrapUnique(
             new WorkerThreadableLoaderTestHelper(BlinkGC::PerThreadHeapMode));
         break;
     }
   }
 
   void startLoader(const KURL& url) {
     ResourceRequest request(url);
     request.setRequestContext(WebURLRequest::RequestContextObject);
     m_helper->startLoader(request);
   }
@@ skipping 510 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