DO NOT COMMIT: Results of running new (proposed) clang-format on Blink

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 <stdint.h>
 #include <memory>
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/Document.h"
@@ skipping 109 matching lines @@
   MockWebSocketHandle* handle() { return m_handle; }
 
   void didConsumeBufferedAmount(unsigned long a) {
     m_sumOfConsumedBufferedAmount += a;
   }
 
   void connect() {
     {
       InSequence s;
       EXPECT_CALL(*handle(), initialize(_));
-      EXPECT_CALL(*handle(), connect(KURL(KURL(), "ws://localhost/"), _, _, _,
-                                     _, handleClient()));
+      EXPECT_CALL(
+          *handle(),
+          connect(KURL(KURL(), "ws://localhost/"), _, _, _, _, handleClient()));
       EXPECT_CALL(*handle(), flowControl(65536));
       EXPECT_CALL(*channelClient(), didConnect(String("a"), String("b")));
     }
     EXPECT_TRUE(channel()->connect(KURL(KURL(), "ws://localhost/"), "x"));
     handleClient()->didConnect(handle(), String("a"), String("b"));
     ::testing::Mock::VerifyAndClearExpectations(this);
   }
 
   std::unique_ptr<DummyPageHolder> m_pageHolder;
   Persistent<MockWebSocketChannelClient> m_channelClient;
@@ skipping 59 matching lines @@
   EXPECT_STREQ("http://example.com", origin->toString().utf8().data());
 
   checkpoint.Call(1);
   handleClient()->didConnect(handle(), String("a"), String("b"));
 }
 
 TEST_F(DocumentWebSocketChannelTest, sendText) {
   connect();
   {
     InSequence s;
-    EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeText,
-                                MemEq("foo", 3), 3));
-    EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeText,
-                                MemEq("bar", 3), 3));
-    EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeText,
-                                MemEq("baz", 3), 3));
+    EXPECT_CALL(
+        *handle(),
+        send(true, WebSocketHandle::MessageTypeText, MemEq("foo", 3), 3));
+    EXPECT_CALL(
+        *handle(),
+        send(true, WebSocketHandle::MessageTypeText, MemEq("bar", 3), 3));
+    EXPECT_CALL(
+        *handle(),
+        send(true, WebSocketHandle::MessageTypeText, MemEq("baz", 3), 3));
   }
 
   handleClient()->didReceiveFlowControl(handle(), 16);
   EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber());
 
   channel()->send("foo");
   channel()->send("bar");
   channel()->send("baz");
 
   EXPECT_EQ(9ul, m_sumOfConsumedBufferedAmount);
 }
 
 TEST_F(DocumentWebSocketChannelTest, sendTextContinuation) {
   connect();
   Checkpoint checkpoint;
   {
     InSequence s;
-    EXPECT_CALL(*handle(), send(false, WebSocketHandle::MessageTypeText,
-                                MemEq("0123456789abcdef", 16), 16));
+    EXPECT_CALL(*handle(),
+                send(false, WebSocketHandle::MessageTypeText,
+                     MemEq("0123456789abcdef", 16), 16));
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeContinuation,
-                                MemEq("g", 1), 1));
-    EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeText,
-                                MemEq("hijk", 4), 4));
-    EXPECT_CALL(*handle(), send(false, WebSocketHandle::MessageTypeText,
-                                MemEq("lmnopqrstuv", 11), 11));
+    EXPECT_CALL(
+        *handle(),
+        send(true, WebSocketHandle::MessageTypeContinuation, MemEq("g", 1), 1));
+    EXPECT_CALL(
+        *handle(),
+        send(true, WebSocketHandle::MessageTypeText, MemEq("hijk", 4), 4));
+    EXPECT_CALL(*handle(),
+                send(false, WebSocketHandle::MessageTypeText,
+                     MemEq("lmnopqrstuv", 11), 11));
     EXPECT_CALL(checkpoint, Call(2));
-    EXPECT_CALL(*handle(), send(false, WebSocketHandle::MessageTypeContinuation,
-                                MemEq("wxyzABCDEFGHIJKL", 16), 16));
+    EXPECT_CALL(*handle(),
+                send(false, WebSocketHandle::MessageTypeContinuation,
+                     MemEq("wxyzABCDEFGHIJKL", 16), 16));
     EXPECT_CALL(checkpoint, Call(3));
-    EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeContinuation,
-                                MemEq("MNOPQRSTUVWXYZ", 14), 14));
+    EXPECT_CALL(*handle(),
+                send(true, WebSocketHandle::MessageTypeContinuation,
+                     MemEq("MNOPQRSTUVWXYZ", 14), 14));
   }
 
   handleClient()->didReceiveFlowControl(handle(), 16);
   EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber());
 
   channel()->send("0123456789abcdefg");
   channel()->send("hijk");
   channel()->send("lmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
   checkpoint.Call(1);
   handleClient()->didReceiveFlowControl(handle(), 16);
   checkpoint.Call(2);
   handleClient()->didReceiveFlowControl(handle(), 16);
   checkpoint.Call(3);
   handleClient()->didReceiveFlowControl(handle(), 16);
 
   EXPECT_EQ(62ul, m_sumOfConsumedBufferedAmount);
 }
 
 TEST_F(DocumentWebSocketChannelTest, sendBinaryInVector) {
   connect();
   {
     InSequence s;
-    EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary,
-                                MemEq("foo", 3), 3));
+    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(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));
+    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(WTF::makeUnique<Vector<char>>(v));
   }
@@ skipping 11 matching lines @@
     Vector<char> v;
     v.append("\0\0\0", 3);
     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));
+  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(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));
+  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(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(*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));
+    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(WTF::makeUnique<Vector<char>>(v));
   checkpoint.Call(1);
 
   handleClient()->didReceiveFlowControl(handle(), 16);
 
   EXPECT_EQ(18ul, m_sumOfConsumedBufferedAmount);
 }
 
 TEST_F(DocumentWebSocketChannelTest, sendBinaryInArrayBuffer) {
   connect();
   {
     InSequence s;
-    EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary,
-                                MemEq("foo", 3), 3));
+    EXPECT_CALL(
+        *handle(),
+        send(true, WebSocketHandle::MessageTypeBinary, MemEq("foo", 3), 3));
   }
 
   handleClient()->didReceiveFlowControl(handle(), 16);
   EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber());
 
   DOMArrayBuffer* fooBuffer = DOMArrayBuffer::create("foo", 3);
   channel()->send(*fooBuffer, 0, 3);
 
   EXPECT_EQ(3ul, m_sumOfConsumedBufferedAmount);
 }
 
 TEST_F(DocumentWebSocketChannelTest, sendBinaryInArrayBufferPartial) {
   connect();
   {
     InSequence s;
-    EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary,
-                                MemEq("foo", 3), 3));
-    EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary,
-                                MemEq("bar", 3), 3));
-    EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary,
-                                MemEq("baz", 3), 3));
-    EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary,
-                                MemEq("a", 1), 1));
+    EXPECT_CALL(
+        *handle(),
+        send(true, WebSocketHandle::MessageTypeBinary, MemEq("foo", 3), 3));
+    EXPECT_CALL(
+        *handle(),
+        send(true, WebSocketHandle::MessageTypeBinary, MemEq("bar", 3), 3));
+    EXPECT_CALL(
+        *handle(),
+        send(true, WebSocketHandle::MessageTypeBinary, MemEq("baz", 3), 3));
+    EXPECT_CALL(
+        *handle(),
+        send(true, WebSocketHandle::MessageTypeBinary, MemEq("a", 1), 1));
   }
 
   handleClient()->didReceiveFlowControl(handle(), 16);
   EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber());
 
   DOMArrayBuffer* foobarBuffer = DOMArrayBuffer::create("foobar", 6);
   DOMArrayBuffer* qbazuxBuffer = DOMArrayBuffer::create("qbazux", 6);
   channel()->send(*foobarBuffer, 0, 3);
   channel()->send(*foobarBuffer, 3, 3);
   channel()->send(*qbazuxBuffer, 1, 3);
   channel()->send(*qbazuxBuffer, 2, 1);
 
   EXPECT_EQ(10ul, m_sumOfConsumedBufferedAmount);
 }
 
 TEST_F(DocumentWebSocketChannelTest, sendBinaryInArrayBufferWithNullBytes) {
   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));
+    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());
 
   {
     DOMArrayBuffer* b = DOMArrayBuffer::create("\0ar", 3);
     channel()->send(*b, 0, 3);
   }
   {
     DOMArrayBuffer* b = DOMArrayBuffer::create("b\0z", 3);
     channel()->send(*b, 0, 3);
   }
   {
     DOMArrayBuffer* b = DOMArrayBuffer::create("qu\0", 3);
     channel()->send(*b, 0, 3);
   }
   {
     DOMArrayBuffer* b = DOMArrayBuffer::create("\0\0\0", 3);
     channel()->send(*b, 0, 3);
   }
 
   EXPECT_EQ(12ul, m_sumOfConsumedBufferedAmount);
 }
 
 TEST_F(DocumentWebSocketChannelTest, sendBinaryInArrayBufferNonLatin1UTF8) {
   connect();
-  EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary,
-                              MemEq("\xe7\x8b\x90", 3), 3));
+  EXPECT_CALL(*handle(),
+              send(true, WebSocketHandle::MessageTypeBinary,
+                   MemEq("\xe7\x8b\x90", 3), 3));
 
   handleClient()->didReceiveFlowControl(handle(), 16);
   EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber());
 
   DOMArrayBuffer* b = DOMArrayBuffer::create("\xe7\x8b\x90", 3);
   channel()->send(*b, 0, 3);
 
   EXPECT_EQ(3ul, m_sumOfConsumedBufferedAmount);
 }
 
 TEST_F(DocumentWebSocketChannelTest, sendBinaryInArrayBufferNonUTF8) {
   connect();
-  EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary,
-                              MemEq("\x80\xff\xe7", 3), 3));
+  EXPECT_CALL(*handle(),
+              send(true, WebSocketHandle::MessageTypeBinary,
+                   MemEq("\x80\xff\xe7", 3), 3));
 
   handleClient()->didReceiveFlowControl(handle(), 16);
   EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber());
 
   DOMArrayBuffer* b = DOMArrayBuffer::create("\x80\xff\xe7", 3);
   channel()->send(*b, 0, 3);
 
   EXPECT_EQ(3ul, m_sumOfConsumedBufferedAmount);
 }
 
 TEST_F(DocumentWebSocketChannelTest,
        sendBinaryInArrayBufferNonLatin1UTF8Continuation) {
   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(*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));
+    EXPECT_CALL(*handle(),
+                send(true, WebSocketHandle::MessageTypeContinuation,
+                     MemEq("\x8b\x90", 2), 2));
   }
 
   handleClient()->didReceiveFlowControl(handle(), 16);
   EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber());
 
   DOMArrayBuffer* b = DOMArrayBuffer::create(
       "\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b"
       "\x90",
       18);
   channel()->send(*b, 0, 18);
@@ skipping 156 matching lines @@
 
 TEST_F(DocumentWebSocketChannelTest, closeFromBrowser) {
   connect();
   Checkpoint checkpoint;
   {
     InSequence s;
 
     EXPECT_CALL(*channelClient(), didStartClosingHandshake());
     EXPECT_CALL(checkpoint, Call(1));
 
-    EXPECT_CALL(*handle(), close(WebSocketChannel::CloseEventCodeNormalClosure,
-                                 String("close reason")));
+    EXPECT_CALL(*handle(),
+                close(WebSocketChannel::CloseEventCodeNormalClosure,
+                      String("close reason")));
     EXPECT_CALL(checkpoint, Call(2));
 
     EXPECT_CALL(*channelClient(),
                 didClose(WebSocketChannelClient::ClosingHandshakeComplete,
                          WebSocketChannel::CloseEventCodeNormalClosure,
                          String("close reason")));
     EXPECT_CALL(checkpoint, Call(3));
   }
 
   handleClient()->didStartClosingHandshake(handle());
@@ skipping 10 matching lines @@
 
   channel()->disconnect();
 }
 
 TEST_F(DocumentWebSocketChannelTest, closeFromWebSocket) {
   connect();
   Checkpoint checkpoint;
   {
     InSequence s;
 
-    EXPECT_CALL(*handle(), close(WebSocketChannel::CloseEventCodeNormalClosure,
-                                 String("close reason")));
+    EXPECT_CALL(*handle(),
+                close(WebSocketChannel::CloseEventCodeNormalClosure,
+                      String("close reason")));
     EXPECT_CALL(checkpoint, Call(1));
 
     EXPECT_CALL(*channelClient(),
                 didClose(WebSocketChannelClient::ClosingHandshakeComplete,
                          WebSocketChannel::CloseEventCodeNormalClosure,
                          String("close reason")));
     EXPECT_CALL(checkpoint, Call(2));
   }
 
   channel()->close(WebSocketChannel::CloseEventCodeNormalClosure,
@@ skipping 35 matching lines @@
                  WebSocketChannel::CloseEventCodeAbnormalClosure, String()));
   }
 
   channel()->fail("fail message from WebSocket", ErrorMessageLevel,
                   SourceLocation::create(String(), 0, 0, nullptr));
 }
 
 }  // namespace
 
 }  // namespace blink