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

third_party/WebKit/Source/modules/websockets/WorkerWebSocketChannel.cpp

 /*
  * Copyright (C) 2011, 2012 Google Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 263 matching lines @@
   DCHECK(context->isWorkerGlobalScope());
   if (bridge && bridge->client())
     bridge->client()->didReceiveBinaryMessage(std::move(payload));
 }
 
 void Peer::didReceiveBinaryMessage(std::unique_ptr<Vector<char>> payload) {
   DCHECK(isMainThread());
   m_loaderProxy->postTaskToWorkerGlobalScope(
       BLINK_FROM_HERE,
       createCrossThreadTask(&workerGlobalScopeDidReceiveBinaryMessage, m_bridge,
-                            passed(std::move(payload))));
+                            WTF::passed(std::move(payload))));
 }
 
 static void workerGlobalScopeDidConsumeBufferedAmount(
     Bridge* bridge,
     uint64_t consumed,
     ExecutionContext* context) {
   DCHECK(context->isWorkerGlobalScope());
   if (bridge && bridge->client())
     bridge->client()->didConsumeBufferedAmount(consumed);
 }
@@ skipping 107 matching lines @@
 bool Bridge::connect(std::unique_ptr<SourceLocation> location,
                      const KURL& url,
                      const String& protocol) {
   // Wait for completion of the task on the main thread because the mixed
   // content check must synchronously be conducted.
   WebSocketChannelSyncHelper syncHelper;
   m_loaderProxy->postTaskToLoader(
       BLINK_FROM_HERE,
       createCrossThreadTask(
           &Bridge::connectOnMainThread, wrapCrossThreadPersistent(this),
-          passed(location->clone()),
+          WTF::passed(location->clone()),
           wrapCrossThreadPersistent(
               m_workerGlobalScope->thread()->getWorkerThreadLifecycleContext()),
           url, protocol, crossThreadUnretained(&syncHelper)));
   syncHelper.wait();
   return syncHelper.connectRequestResult();
 }
 
 void Bridge::send(const CString& message) {
   DCHECK(m_peer);
   std::unique_ptr<Vector<char>> data =
-      wrapUnique(new Vector<char>(message.length()));
+      WTF::wrapUnique(new Vector<char>(message.length()));
   if (message.length())
     memcpy(data->data(), static_cast<const char*>(message.data()),
            message.length());
 
   m_loaderProxy->postTaskToLoader(
-      BLINK_FROM_HERE, createCrossThreadTask(&Peer::sendTextAsCharVector,
-                                             m_peer, passed(std::move(data))));
+      BLINK_FROM_HERE,
+      createCrossThreadTask(&Peer::sendTextAsCharVector, m_peer,
+                            WTF::passed(std::move(data))));
 }
 
 void Bridge::send(const DOMArrayBuffer& binaryData,
                   unsigned byteOffset,
                   unsigned byteLength) {
   DCHECK(m_peer);
   // ArrayBuffer isn't thread-safe, hence the content of ArrayBuffer is copied
   // into Vector<char>.
-  std::unique_ptr<Vector<char>> data = makeUnique<Vector<char>>(byteLength);
+  std::unique_ptr<Vector<char>> data =
+      WTF::makeUnique<Vector<char>>(byteLength);
   if (binaryData.byteLength())
     memcpy(data->data(),
            static_cast<const char*>(binaryData.data()) + byteOffset,
            byteLength);
 
   m_loaderProxy->postTaskToLoader(
-      BLINK_FROM_HERE, createCrossThreadTask(&Peer::sendBinaryAsCharVector,
-                                             m_peer, passed(std::move(data))));
+      BLINK_FROM_HERE,
+      createCrossThreadTask(&Peer::sendBinaryAsCharVector, m_peer,
+                            WTF::passed(std::move(data))));
 }
 
 void Bridge::send(PassRefPtr<BlobDataHandle> data) {
   DCHECK(m_peer);
   m_loaderProxy->postTaskToLoader(
       BLINK_FROM_HERE,
       createCrossThreadTask(&Peer::sendBlob, m_peer, std::move(data)));
 }
 
 void Bridge::close(int code, const String& reason) {
   DCHECK(m_peer);
   m_loaderProxy->postTaskToLoader(
       BLINK_FROM_HERE,
       createCrossThreadTask(&Peer::close, m_peer, code, reason));
 }
 
 void Bridge::fail(const String& reason,
                   MessageLevel level,
                   std::unique_ptr<SourceLocation> location) {
   DCHECK(m_peer);
   m_loaderProxy->postTaskToLoader(
       BLINK_FROM_HERE, createCrossThreadTask(&Peer::fail, m_peer, reason, level,
-                                             passed(location->clone())));
+                                             WTF::passed(location->clone())));
 }
 
 void Bridge::disconnect() {
   if (!m_peer)
     return;
 
   m_loaderProxy->postTaskToLoader(
       BLINK_FROM_HERE, createCrossThreadTask(&Peer::disconnect, m_peer));
 
   m_client = nullptr;
   m_peer = nullptr;
   m_workerGlobalScope.clear();
 }
 
 DEFINE_TRACE(Bridge) {
   visitor->trace(m_client);
   visitor->trace(m_workerGlobalScope);
 }
 
 }  // namespace blink