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

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

 // Copyright 2014 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/websockets/WebSocketChannel.h"
 
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/Document.h"
 #include "core/fileapi/Blob.h"
 #include "core/testing/DummyPageHolder.h"
@@ skipping 259 matching lines @@
     InSequence s;
     EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary,
                                 MemEq("foo", 3), 3));
   }
 
   handleClient()->didReceiveFlowControl(handle(), 16);
   EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber());
 
   Vector<char> fooVector;
   fooVector.append("foo", 3);
-  channel()->sendBinaryAsCharVector(makeUnique<Vector<char>>(fooVector));
+  channel()->sendBinaryAsCharVector(WTF::makeUnique<Vector<char>>(fooVector));
 
   EXPECT_EQ(3ul, m_sumOfConsumedBufferedAmount);
 }
 
 TEST_F(DocumentWebSocketChannelTest, sendBinaryInVectorWithNullBytes) {
   connect();
   {
     InSequence s;
     EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary,
                                 MemEq("\0ar", 3), 3));
     EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary,
                                 MemEq("b\0z", 3), 3));
     EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary,
                                 MemEq("qu\0", 3), 3));
     EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary,
                                 MemEq("\0\0\0", 3), 3));
   }
 
   handleClient()->didReceiveFlowControl(handle(), 16);
   EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber());
 
   {
     Vector<char> v;
     v.append("\0ar", 3);
-    channel()->sendBinaryAsCharVector(makeUnique<Vector<char>>(v));
+    channel()->sendBinaryAsCharVector(WTF::makeUnique<Vector<char>>(v));
   }
   {
     Vector<char> v;
     v.append("b\0z", 3);
-    channel()->sendBinaryAsCharVector(makeUnique<Vector<char>>(v));
+    channel()->sendBinaryAsCharVector(WTF::makeUnique<Vector<char>>(v));
   }
   {
     Vector<char> v;
     v.append("qu\0", 3);
-    channel()->sendBinaryAsCharVector(makeUnique<Vector<char>>(v));
+    channel()->sendBinaryAsCharVector(WTF::makeUnique<Vector<char>>(v));
   }
   {
     Vector<char> v;
     v.append("\0\0\0", 3);
-    channel()->sendBinaryAsCharVector(makeUnique<Vector<char>>(v));
+    channel()->sendBinaryAsCharVector(WTF::makeUnique<Vector<char>>(v));
   }
 
   EXPECT_EQ(12ul, m_sumOfConsumedBufferedAmount);
 }
 
 TEST_F(DocumentWebSocketChannelTest, sendBinaryInVectorNonLatin1UTF8) {
   connect();
   EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary,
                               MemEq("\xe7\x8b\x90", 3), 3));
 
   handleClient()->didReceiveFlowControl(handle(), 16);
   EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber());
 
   Vector<char> v;
   v.append("\xe7\x8b\x90", 3);
-  channel()->sendBinaryAsCharVector(makeUnique<Vector<char>>(v));
+  channel()->sendBinaryAsCharVector(WTF::makeUnique<Vector<char>>(v));
 
   EXPECT_EQ(3ul, m_sumOfConsumedBufferedAmount);
 }
 
 TEST_F(DocumentWebSocketChannelTest, sendBinaryInVectorNonUTF8) {
   connect();
   EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary,
                               MemEq("\x80\xff\xe7", 3), 3));
 
   handleClient()->didReceiveFlowControl(handle(), 16);
   EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber());
 
   Vector<char> v;
   v.append("\x80\xff\xe7", 3);
-  channel()->sendBinaryAsCharVector(makeUnique<Vector<char>>(v));
+  channel()->sendBinaryAsCharVector(WTF::makeUnique<Vector<char>>(v));
 
   EXPECT_EQ(3ul, m_sumOfConsumedBufferedAmount);
 }
 
 TEST_F(DocumentWebSocketChannelTest,
        sendBinaryInVectorNonLatin1UTF8Continuation) {
   connect();
   Checkpoint checkpoint;
   {
     InSequence s;
     EXPECT_CALL(*handle(), send(false, WebSocketHandle::MessageTypeBinary,
                                 MemEq("\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7"
                                       "\x8b\x90\xe7\x8b\x90\xe7",
                                       16),
                                 16));
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeContinuation,
                                 MemEq("\x8b\x90", 2), 2));
   }
 
   handleClient()->didReceiveFlowControl(handle(), 16);
   EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber());
 
   Vector<char> v;
   v.append(
       "\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b"
       "\x90",
       18);
-  channel()->sendBinaryAsCharVector(makeUnique<Vector<char>>(v));
+  channel()->sendBinaryAsCharVector(WTF::makeUnique<Vector<char>>(v));
   checkpoint.Call(1);
 
   handleClient()->didReceiveFlowControl(handle(), 16);
 
   EXPECT_EQ(18ul, m_sumOfConsumedBufferedAmount);
 }
 
 TEST_F(DocumentWebSocketChannelTest, sendBinaryInArrayBuffer) {
   connect();
   {
@@ skipping 375 matching lines @@
                  WebSocketChannel::CloseEventCodeAbnormalClosure, String()));
   }
 
   channel()->fail("fail message from WebSocket", ErrorMessageLevel,
                   SourceLocation::create(String(), 0, 0, nullptr));
 }
 
 }  // namespace
 
 }  // namespace blink