Clang format slam.

net/websockets/websocket_channel_test.cc

 // Copyright 2013 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 "net/websockets/websocket_channel.h"
 
 #include <limits.h>
 #include <string.h>
 
 #include <iostream>
@@ skipping 86 matching lines @@
 using ::testing::DefaultValue;
 using ::testing::InSequence;
 using ::testing::MockFunction;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 using ::testing::_;
 
 // A selection of characters that have traditionally been mangled in some
 // environment or other, for testing 8-bit cleanliness.
-const char kBinaryBlob[] = {'\n',   '\r',    // BACKWARDS CRNL
-                            '\0',            // nul
-                            '\x7F',          // DEL
-                            '\x80', '\xFF',  // NOT VALID UTF-8
-                            '\x1A',          // Control-Z, EOF on DOS
-                            '\x03',          // Control-C
-                            '\x04',          // EOT, special for Unix terms
-                            '\x1B',          // ESC, often special
-                            '\b',            // backspace
-                            '\'',            // single-quote, special in PHP
+const char kBinaryBlob[] = {
+    '\n',   '\r',    // BACKWARDS CRNL
+    '\0',            // nul
+    '\x7F',          // DEL
+    '\x80', '\xFF',  // NOT VALID UTF-8
+    '\x1A',          // Control-Z, EOF on DOS
+    '\x03',          // Control-C
+    '\x04',          // EOT, special for Unix terms
+    '\x1B',          // ESC, often special
+    '\b',            // backspace
+    '\'',            // single-quote, special in PHP
 };
 const size_t kBinaryBlobSize = arraysize(kBinaryBlob);
 
 // The amount of quota a new connection gets by default.
 // TODO(ricea): If kDefaultSendQuotaHighWaterMark changes, then this value will
 // need to be updated.
 const size_t kDefaultInitialQuota = 1 << 17;
 // The amount of bytes we need to send after the initial connection to trigger a
 // quota refresh. TODO(ricea): Change this if kDefaultSendQuotaHighWaterMark or
 // kDefaultSendQuotaLowWaterMark change.
 const size_t kDefaultQuotaRefreshTrigger = (1 << 16) + 1;
 
 // TestTimeouts::tiny_timeout() is 100ms! I could run halfway around the world
 // in that time! I would like my tests to run a bit quicker.
 const int kVeryTinyTimeoutMillis = 1;
 
 // Enough quota to pass any test.
 const int64 kPlentyOfQuota = INT_MAX;
 
 typedef WebSocketEventInterface::ChannelState ChannelState;
 const ChannelState CHANNEL_ALIVE = WebSocketEventInterface::CHANNEL_ALIVE;
 const ChannelState CHANNEL_DELETED = WebSocketEventInterface::CHANNEL_DELETED;
 
 // This typedef mainly exists to avoid having to repeat the "NOLINT" incantation
 // all over the place.
-typedef StrictMock< MockFunction<void(int)> > Checkpoint;  // NOLINT
+typedef StrictMock<MockFunction<void(int)> > Checkpoint;  // NOLINT
 
 // This mock is for testing expectations about how the EventInterface is used.
 class MockWebSocketEventInterface : public WebSocketEventInterface {
  public:
   MockWebSocketEventInterface() {}
 
   MOCK_METHOD3(OnAddChannelResponse,
                ChannelState(bool,
                             const std::string&,
                             const std::string&));  // NOLINT
   MOCK_METHOD3(OnDataFrame,
                ChannelState(bool,
                             WebSocketMessageType,
-                            const std::vector<char>&));  // NOLINT
-  MOCK_METHOD1(OnFlowControl, ChannelState(int64));  // NOLINT
-  MOCK_METHOD0(OnClosingHandshake, ChannelState(void));  // NOLINT
+                            const std::vector<char>&));           // NOLINT
+  MOCK_METHOD1(OnFlowControl, ChannelState(int64));               // NOLINT
+  MOCK_METHOD0(OnClosingHandshake, ChannelState(void));           // NOLINT
   MOCK_METHOD1(OnFailChannel, ChannelState(const std::string&));  // NOLINT
   MOCK_METHOD3(OnDropChannel,
                ChannelState(bool, uint16, const std::string&));  // NOLINT
 
   // We can't use GMock with scoped_ptr.
   ChannelState OnStartOpeningHandshake(
       scoped_ptr<WebSocketHandshakeRequestInfo>) OVERRIDE {
     OnStartOpeningHandshakeCalled();
     return CHANNEL_ALIVE;
   }
   ChannelState OnFinishOpeningHandshake(
       scoped_ptr<WebSocketHandshakeResponseInfo>) OVERRIDE {
     OnFinishOpeningHandshakeCalled();
     return CHANNEL_ALIVE;
   }
 
-  MOCK_METHOD0(OnStartOpeningHandshakeCalled, void());  // NOLINT
+  MOCK_METHOD0(OnStartOpeningHandshakeCalled, void());   // NOLINT
   MOCK_METHOD0(OnFinishOpeningHandshakeCalled, void());  // NOLINT
 };
 
 // This fake EventInterface is for tests which need a WebSocketEventInterface
 // implementation but are not verifying how it is used.
 class FakeWebSocketEventInterface : public WebSocketEventInterface {
   virtual ChannelState OnAddChannelResponse(
       bool fail,
       const std::string& selected_protocol,
       const std::string& extensions) OVERRIDE {
@@ skipping 225 matching lines @@
   base::Closure closure() { return base::Bind(callback_.callback(), OK); }
 
   void WaitForResult() { callback_.WaitForResult(); }
 
  private:
   // Delegate to TestCompletionCallback for the implementation.
   TestCompletionCallback callback_;
 };
 
 // A GoogleMock action to run a Closure.
-ACTION_P(InvokeClosure, closure) { closure.Run(); }
+ACTION_P(InvokeClosure, closure) {
+  closure.Run();
+}
 
 // A GoogleMock action to run a Closure and return CHANNEL_DELETED.
 ACTION_P(InvokeClosureReturnDeleted, closure) {
   closure.Run();
   return WebSocketEventInterface::CHANNEL_DELETED;
 }
 
 // A FakeWebSocketStream whose ReadFrames() function returns data.
 class ReadableFakeWebSocketStream : public FakeWebSocketStream {
  public:
@@ skipping 498 matching lines @@
   virtual void CreateChannelAndConnectSuccessfully() OVERRIDE {
     set_stream(mock_stream_.Pass());
     WebSocketChannelTest::CreateChannelAndConnectSuccessfully();
   }
 
   scoped_ptr<MockWebSocketStream> mock_stream_;
 };
 
 // Fixture for tests which test UTF-8 validation of sent Text frames via the
 // EventInterface.
-class WebSocketChannelSendUtf8Test
-    : public WebSocketChannelEventInterfaceTest {
+class WebSocketChannelSendUtf8Test : public WebSocketChannelEventInterfaceTest {
  public:
   virtual void SetUp() {
     set_stream(make_scoped_ptr(new WriteableFakeWebSocketStream));
     // For the purpose of the tests using this fixture, it doesn't matter
     // whether these methods are called or not.
     EXPECT_CALL(*event_interface_, OnAddChannelResponse(_, _, _))
         .Times(AnyNumber());
-    EXPECT_CALL(*event_interface_, OnFlowControl(_))
-        .Times(AnyNumber());
+    EXPECT_CALL(*event_interface_, OnFlowControl(_)).Times(AnyNumber());
   }
 };
 
 // Fixture for tests which test use of receive quota from the renderer.
 class WebSocketChannelFlowControlTest
     : public WebSocketChannelEventInterfaceTest {
  protected:
   // Tests using this fixture should use CreateChannelAndConnectWithQuota()
   // instead of CreateChannelAndConnectSuccessfully().
   void CreateChannelAndConnectWithQuota(int64 quota) {
@@ skipping 107 matching lines @@
   channel_->SendFrame(true,
                       WebSocketFrameHeader::kOpCodeText,
                       std::vector<char>(kDefaultInitialQuota, 'B'));
   EXPECT_EQ(NULL, channel_.get());
 }
 
 TEST_F(WebSocketChannelDeletingTest, OnClosingHandshakeSync) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
   static const InitFrame frames[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
-       NOT_MASKED,  CLOSE_DATA(NORMAL_CLOSURE, "Success")}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED,
+       CLOSE_DATA(NORMAL_CLOSURE, "Success")}};
   stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, frames);
   set_stream(stream.Pass());
   deleting_ = EVENT_ON_CLOSING_HANDSHAKE;
   CreateChannelAndConnectSuccessfully();
   EXPECT_EQ(NULL, channel_.get());
 }
 
 TEST_F(WebSocketChannelDeletingTest, OnClosingHandshakeAsync) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
   static const InitFrame frames[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
-       NOT_MASKED,  CLOSE_DATA(NORMAL_CLOSURE, "Success")}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED,
+       CLOSE_DATA(NORMAL_CLOSURE, "Success")}};
   stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, frames);
   set_stream(stream.Pass());
   deleting_ = EVENT_ON_CLOSING_HANDSHAKE;
   CreateChannelAndConnectSuccessfully();
   ASSERT_TRUE(channel_);
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(NULL, channel_.get());
 }
 
 TEST_F(WebSocketChannelDeletingTest, OnDropChannelWriteError) {
@@ skipping 93 matching lines @@
   set_stream(stream.Pass());
   deleting_ = EVENT_ON_FAIL_CHANNEL;
 
   CreateChannelAndConnectSuccessfully();
   EXPECT_EQ(NULL, channel_.get());
 }
 
 TEST_F(WebSocketChannelDeletingTest, FailChannelDueToBadControlFrame) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
-  static const InitFrame frames[] = {
-      {FINAL_FRAME, 0xF, NOT_MASKED, ""}};
+  static const InitFrame frames[] = {{FINAL_FRAME, 0xF, NOT_MASKED, ""}};
   stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, frames);
   set_stream(stream.Pass());
   deleting_ = EVENT_ON_FAIL_CHANNEL;
 
   CreateChannelAndConnectSuccessfully();
   EXPECT_EQ(NULL, channel_.get());
 }
 
 // Version of above test with NULL data.
 TEST_F(WebSocketChannelDeletingTest, FailChannelDueToBadControlFrameNull) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
-  static const InitFrame frames[] = {
-      {FINAL_FRAME, 0xF, NOT_MASKED, NULL}};
+  static const InitFrame frames[] = {{FINAL_FRAME, 0xF, NOT_MASKED, NULL}};
   stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, frames);
   set_stream(stream.Pass());
   deleting_ = EVENT_ON_FAIL_CHANNEL;
 
   CreateChannelAndConnectSuccessfully();
   EXPECT_EQ(NULL, channel_.get());
 }
 
 TEST_F(WebSocketChannelDeletingTest, FailChannelDueToPongAfterClose) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
@@ skipping 46 matching lines @@
   deleting_ = EVENT_ON_FAIL_CHANNEL;
 
   CreateChannelAndConnectSuccessfully();
   EXPECT_EQ(NULL, channel_.get());
 }
 
 TEST_F(WebSocketChannelDeletingTest, FailChannelDueInvalidCloseReason) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
   static const InitFrame frames[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
-       NOT_MASKED,  CLOSE_DATA(NORMAL_CLOSURE, "\xFF")}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED,
+       CLOSE_DATA(NORMAL_CLOSURE, "\xFF")}};
   stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, frames);
   set_stream(stream.Pass());
   deleting_ = EVENT_ON_FAIL_CHANNEL;
 
   CreateChannelAndConnectSuccessfully();
   EXPECT_EQ(NULL, channel_.get());
 }
 
 TEST_F(WebSocketChannelEventInterfaceTest, ConnectSuccessReported) {
   // false means success.
@@ skipping 64 matching lines @@
 
   CreateChannelAndConnectSuccessfully();
 }
 
 // A remote server could accept the handshake, but then immediately send a
 // Close frame.
 TEST_F(WebSocketChannelEventInterfaceTest, CloseAfterHandshake) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
   static const InitFrame frames[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
-       NOT_MASKED,  CLOSE_DATA(SERVER_ERROR, "Internal Server Error")}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED,
+       CLOSE_DATA(SERVER_ERROR, "Internal Server Error")}};
   stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, frames);
   stream->PrepareReadFramesError(ReadableFakeWebSocketStream::SYNC,
                                  ERR_CONNECTION_CLOSED);
   set_stream(stream.Pass());
   {
     InSequence s;
     EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, _, _));
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
     EXPECT_CALL(*event_interface_, OnClosingHandshake());
     EXPECT_CALL(
@@ skipping 85 matching lines @@
 // Data frames are delivered the same regardless of how many reads they arrive
 // as.
 TEST_F(WebSocketChannelEventInterfaceTest, FragmentedMessage) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
   // Here we have one message which arrived in five frames split across three
   // reads. It may have been reframed on arrival, but this class doesn't care
   // about that.
   static const InitFrame frames1[] = {
       {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, "THREE"},
-      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation,
-       NOT_MASKED,      " "}};
+      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation, NOT_MASKED,
+       " "}};
   static const InitFrame frames2[] = {
-      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation,
-       NOT_MASKED,      "SMALL"}};
+      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation, NOT_MASKED,
+       "SMALL"}};
   static const InitFrame frames3[] = {
-      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation,
-       NOT_MASKED,      " "},
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation,
-       NOT_MASKED,  "FRAMES"}};
+      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation, NOT_MASKED,
+       " "},
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation, NOT_MASKED,
+       "FRAMES"}};
   stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, frames1);
   stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, frames2);
   stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, frames3);
   set_stream(stream.Pass());
   {
     InSequence s;
     EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, _, _));
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
     EXPECT_CALL(
         *event_interface_,
@@ skipping 119 matching lines @@
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 // RFC6455 5.4 "Control frames ... MAY be injected in the middle of a
 // fragmented message."
 TEST_F(WebSocketChannelEventInterfaceTest, ControlFrameInDataMessage) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
   // We have one message of type Text split into two frames. In the middle is a
   // control message of type Pong.
-  static const InitFrame frames1[] = {
-      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeText,
-       NOT_MASKED,      "SPLIT "}};
+  static const InitFrame frames1[] = {{NOT_FINAL_FRAME,
+                                       WebSocketFrameHeader::kOpCodeText,
+                                       NOT_MASKED, "SPLIT "}};
   static const InitFrame frames2[] = {
       {FINAL_FRAME, WebSocketFrameHeader::kOpCodePong, NOT_MASKED, ""}};
   static const InitFrame frames3[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation,
-       NOT_MASKED,  "MESSAGE"}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation, NOT_MASKED,
+       "MESSAGE"}};
   stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, frames1);
   stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, frames2);
   stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, frames3);
   set_stream(stream.Pass());
   {
     InSequence s;
     EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, _, _));
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
     EXPECT_CALL(
         *event_interface_,
@@ skipping 325 matching lines @@
   CreateChannelAndConnect();
 
   WebSocketStream::ConnectDelegate* connect_delegate =
       connect_data_.creator.connect_delegate.get();
   GURL url("ws://www.example.com/");
   scoped_ptr<WebSocketHandshakeRequestInfo> request_info(
       new WebSocketHandshakeRequestInfo(url, base::Time()));
   scoped_refptr<HttpResponseHeaders> response_headers(
       new HttpResponseHeaders(""));
   scoped_ptr<WebSocketHandshakeResponseInfo> response_info(
-      new WebSocketHandshakeResponseInfo(url,
-                                         200,
-                                         "OK",
-                                         response_headers,
-                                         base::Time()));
+      new WebSocketHandshakeResponseInfo(
+          url, 200, "OK", response_headers, base::Time()));
   connect_delegate->OnStartOpeningHandshake(request_info.Pass());
   connect_delegate->OnFinishOpeningHandshake(response_info.Pass());
 
   connect_delegate->OnFailure("bye");
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 // Any frame after close is invalid. This test uses a Text frame. See also
 // test "PingAfterCloseIfRejected".
 TEST_F(WebSocketChannelEventInterfaceTest, DataAfterCloseIsRejected) {
@@ skipping 36 matching lines @@
 
   CreateChannelAndConnectSuccessfully();
 }
 
 // A Close frame with a reserved status code also elicits a specific console
 // error message.
 TEST_F(WebSocketChannelEventInterfaceTest, ClosePayloadReservedStatusMessage) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
   static const InitFrame frames[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
-       NOT_MASKED,  CLOSE_DATA(ABNORMAL_CLOSURE, "Not valid on wire")}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED,
+       CLOSE_DATA(ABNORMAL_CLOSURE, "Not valid on wire")}};
   stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, frames);
   set_stream(stream.Pass());
   EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, _, _));
   EXPECT_CALL(*event_interface_, OnFlowControl(_));
   EXPECT_CALL(
       *event_interface_,
       OnFailChannel(
           "Received a broken close frame containing a reserved status code."));
 
   CreateChannelAndConnectSuccessfully();
 }
 
 // A Close frame with invalid UTF-8 also elicits a specific console error
 // message.
 TEST_F(WebSocketChannelEventInterfaceTest, ClosePayloadInvalidReason) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
   static const InitFrame frames[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
-       NOT_MASKED,  CLOSE_DATA(NORMAL_CLOSURE, "\xFF")}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED,
+       CLOSE_DATA(NORMAL_CLOSURE, "\xFF")}};
   stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, frames);
   set_stream(stream.Pass());
   EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, _, _));
   EXPECT_CALL(*event_interface_, OnFlowControl(_));
   EXPECT_CALL(
       *event_interface_,
-      OnFailChannel(
-          "Received a broken close frame containing invalid UTF-8."));
+      OnFailChannel("Received a broken close frame containing invalid UTF-8."));
 
   CreateChannelAndConnectSuccessfully();
 }
 
 // The reserved bits must all be clear on received frames. Extensions should
 // clear the bits when they are set correctly before passing on the frame.
 TEST_F(WebSocketChannelEventInterfaceTest, ReservedBitsMustNotBeSet) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
   static const InitFrame frames[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText,
-       NOT_MASKED,  "sakana"}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, "sakana"}};
   // It is not worth adding support for reserved bits to InitFrame just for this
   // one test, so set the bit manually.
   ScopedVector<WebSocketFrame> raw_frames = CreateFrameVector(frames);
   raw_frames[0]->header.reserved1 = true;
   stream->PrepareRawReadFrames(
       ReadableFakeWebSocketStream::SYNC, OK, raw_frames.Pass());
   set_stream(stream.Pass());
   EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, _, _));
   EXPECT_CALL(*event_interface_, OnFlowControl(_));
   EXPECT_CALL(*event_interface_,
@@ skipping 37 matching lines @@
   completion.WaitForResult();
 }
 
 // The closing handshake times out and sends an OnDropChannel event if a Close
 // message is received but the connection isn't closed by the remote host.
 TEST_F(WebSocketChannelEventInterfaceTest,
        ServerInitiatedClosingHandshakeTimesOut) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
   static const InitFrame frames[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
-       NOT_MASKED,  CLOSE_DATA(NORMAL_CLOSURE, "OK")}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED,
+       CLOSE_DATA(NORMAL_CLOSURE, "OK")}};
   stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, frames);
   set_stream(stream.Pass());
   EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, _, _));
   EXPECT_CALL(*event_interface_, OnFlowControl(_));
   Checkpoint checkpoint;
   TestClosure completion;
   {
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*event_interface_, OnClosingHandshake());
@@ skipping 55 matching lines @@
   checkpoint.Call(2);
 }
 
 // We should stop calling ReadFrames() when all quota is used.
 TEST_F(WebSocketChannelStreamTest, FlowControlStopsReadFrames) {
   static const InitFrame frames[] = {
       {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, "FOUR"}};
 
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, GetExtensions()).Times(AnyNumber());
-  EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
-      .WillOnce(ReturnFrames(&frames));
+  EXPECT_CALL(*mock_stream_, ReadFrames(_, _)).WillOnce(ReturnFrames(&frames));
 
   set_stream(mock_stream_.Pass());
   CreateChannelAndConnect();
   channel_->SendFlowControl(4);
   connect_data_.creator.connect_delegate->OnSuccess(stream_.Pass());
 }
 
 // Providing extra quota causes ReadFrames() to be called again.
 TEST_F(WebSocketChannelStreamTest, FlowControlStartsWithMoreQuota) {
   static const InitFrame frames[] = {
@@ skipping 120 matching lines @@
 
 // A message split into multiple frames which is further split due to quota
 // restrictions should stil be correct.
 // TODO(ricea): The message ends up split into more frames than are strictly
 // necessary. The complexity/performance tradeoffs here need further
 // examination.
 TEST_F(WebSocketChannelFlowControlTest, MultipleFrameSplit) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
   static const InitFrame frames[] = {
-      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeText,
-       NOT_MASKED,      "FIRST FRAME IS 25 BYTES. "},
-      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation,
-       NOT_MASKED,      "SECOND FRAME IS 26 BYTES. "},
-      {FINAL_FRAME,     WebSocketFrameHeader::kOpCodeContinuation,
-       NOT_MASKED,      "FINAL FRAME IS 24 BYTES."}};
+      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED,
+       "FIRST FRAME IS 25 BYTES. "},
+      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation, NOT_MASKED,
+       "SECOND FRAME IS 26 BYTES. "},
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation, NOT_MASKED,
+       "FINAL FRAME IS 24 BYTES."}};
   stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, frames);
   set_stream(stream.Pass());
   {
     InSequence s;
     EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, _, _));
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
     EXPECT_CALL(*event_interface_,
                 OnDataFrame(false,
                             WebSocketFrameHeader::kOpCodeText,
                             AsVector("FIRST FRAME IS")));
@@ skipping 18 matching lines @@
   channel_->SendFlowControl(43);
   channel_->SendFlowControl(32);
 }
 
 // An empty message handled when we are out of quota must not be delivered
 // out-of-order with respect to other messages.
 TEST_F(WebSocketChannelFlowControlTest, EmptyMessageNoQuota) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
   static const InitFrame frames[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText,
-       NOT_MASKED,  "FIRST MESSAGE"},
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText,
-       NOT_MASKED,  NULL},
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText,
-       NOT_MASKED,  "THIRD MESSAGE"}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED,
+       "FIRST MESSAGE"},
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, NULL},
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED,
+       "THIRD MESSAGE"}};
   stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, frames);
   set_stream(stream.Pass());
   {
     InSequence s;
     EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, _, _));
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
-    EXPECT_CALL(*event_interface_,
-                OnDataFrame(false,
-                            WebSocketFrameHeader::kOpCodeText,
-                            AsVector("FIRST ")));
+    EXPECT_CALL(
+        *event_interface_,
+        OnDataFrame(
+            false, WebSocketFrameHeader::kOpCodeText, AsVector("FIRST ")));
     EXPECT_CALL(*event_interface_,
                 OnDataFrame(true,
                             WebSocketFrameHeader::kOpCodeContinuation,
                             AsVector("MESSAGE")));
+    EXPECT_CALL(
+        *event_interface_,
+        OnDataFrame(true, WebSocketFrameHeader::kOpCodeText, AsVector("")));
     EXPECT_CALL(*event_interface_,
                 OnDataFrame(true,
                             WebSocketFrameHeader::kOpCodeText,
-                            AsVector("")));
-    EXPECT_CALL(*event_interface_,
-                OnDataFrame(true,
-                            WebSocketFrameHeader::kOpCodeText,
                             AsVector("THIRD MESSAGE")));
   }
 
   CreateChannelAndConnectWithQuota(6);
   channel_->SendFlowControl(128);
 }
 
 // RFC6455 5.1 "a client MUST mask all frames that it sends to the server".
 // WebSocketChannel actually only sets the mask bit in the header, it doesn't
 // perform masking itself (not all transports actually use masking).
 TEST_F(WebSocketChannelStreamTest, SentFramesAreMasked) {
-  static const InitFrame expected[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText,
-       MASKED,      "NEEDS MASKING"}};
+  static const InitFrame expected[] = {{FINAL_FRAME,
+                                        WebSocketFrameHeader::kOpCodeText,
+                                        MASKED, "NEEDS MASKING"}};
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, GetExtensions()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _)).WillOnce(Return(ERR_IO_PENDING));
   EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
       .WillOnce(Return(OK));
 
   CreateChannelAndConnectSuccessfully();
   channel_->SendFrame(
       true, WebSocketFrameHeader::kOpCodeText, AsVector("NEEDS MASKING"));
 }
 
 // RFC6455 5.5.1 "The application MUST NOT send any more data frames after
 // sending a Close frame."
 TEST_F(WebSocketChannelStreamTest, NothingIsSentAfterClose) {
   static const InitFrame expected[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
-       MASKED,      CLOSE_DATA(NORMAL_CLOSURE, "Success")}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, MASKED,
+       CLOSE_DATA(NORMAL_CLOSURE, "Success")}};
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, GetExtensions()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _)).WillOnce(Return(ERR_IO_PENDING));
   EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
       .WillOnce(Return(OK));
 
   CreateChannelAndConnectSuccessfully();
   channel_->StartClosingHandshake(1000, "Success");
   channel_->SendFrame(
       true, WebSocketFrameHeader::kOpCodeText, AsVector("SHOULD  BE IGNORED"));
 }
 
 // RFC6455 5.5.1 "If an endpoint receives a Close frame and did not previously
 // send a Close frame, the endpoint MUST send a Close frame in response."
 TEST_F(WebSocketChannelStreamTest, CloseIsEchoedBack) {
   static const InitFrame frames[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
-       NOT_MASKED,  CLOSE_DATA(NORMAL_CLOSURE, "Close")}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED,
+       CLOSE_DATA(NORMAL_CLOSURE, "Close")}};
   static const InitFrame expected[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
-       MASKED,      CLOSE_DATA(NORMAL_CLOSURE, "Close")}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, MASKED,
+       CLOSE_DATA(NORMAL_CLOSURE, "Close")}};
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, GetExtensions()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
       .WillOnce(ReturnFrames(&frames))
       .WillRepeatedly(Return(ERR_IO_PENDING));
   EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
       .WillOnce(Return(OK));
 
   CreateChannelAndConnectSuccessfully();
 }
 
 // The converse of the above case; after sending a Close frame, we should not
 // send another one.
 TEST_F(WebSocketChannelStreamTest, CloseOnlySentOnce) {
   static const InitFrame expected[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
-       MASKED,      CLOSE_DATA(NORMAL_CLOSURE, "Close")}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, MASKED,
+       CLOSE_DATA(NORMAL_CLOSURE, "Close")}};
   static const InitFrame frames_init[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
-       NOT_MASKED,  CLOSE_DATA(NORMAL_CLOSURE, "Close")}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED,
+       CLOSE_DATA(NORMAL_CLOSURE, "Close")}};
 
   // We store the parameters that were passed to ReadFrames() so that we can
   // call them explicitly later.
   CompletionCallback read_callback;
   ScopedVector<WebSocketFrame>* frames = NULL;
 
   // These are not interesting.
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, GetExtensions()).Times(AnyNumber());
 
@@ skipping 21 matching lines @@
   channel_->StartClosingHandshake(kWebSocketNormalClosure, "Close");
   checkpoint.Call(2);
 
   *frames = CreateFrameVector(frames_init);
   read_callback.Run(OK);
   checkpoint.Call(3);
 }
 
 // Invalid close status codes should not be sent on the network.
 TEST_F(WebSocketChannelStreamTest, InvalidCloseStatusCodeNotSent) {
-  static const InitFrame expected[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
-       MASKED,      CLOSE_DATA(SERVER_ERROR, "")}};
+  static const InitFrame expected[] = {{FINAL_FRAME,
+                                        WebSocketFrameHeader::kOpCodeClose,
+                                        MASKED, CLOSE_DATA(SERVER_ERROR, "")}};
 
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, GetExtensions()).Times(AnyNumber());
-  EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
-      .WillOnce(Return(ERR_IO_PENDING));
+  EXPECT_CALL(*mock_stream_, ReadFrames(_, _)).WillOnce(Return(ERR_IO_PENDING));
 
   EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _));
 
   CreateChannelAndConnectSuccessfully();
   channel_->StartClosingHandshake(999, "");
 }
 
 // A Close frame with a reason longer than 123 bytes cannot be sent on the
 // network.
 TEST_F(WebSocketChannelStreamTest, LongCloseReasonNotSent) {
-  static const InitFrame expected[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
-       MASKED,      CLOSE_DATA(SERVER_ERROR, "")}};
+  static const InitFrame expected[] = {{FINAL_FRAME,
+                                        WebSocketFrameHeader::kOpCodeClose,
+                                        MASKED, CLOSE_DATA(SERVER_ERROR, "")}};
 
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, GetExtensions()).Times(AnyNumber());
-  EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
-      .WillOnce(Return(ERR_IO_PENDING));
+  EXPECT_CALL(*mock_stream_, ReadFrames(_, _)).WillOnce(Return(ERR_IO_PENDING));
 
   EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _));
 
   CreateChannelAndConnectSuccessfully();
   channel_->StartClosingHandshake(1000, std::string(124, 'A'));
 }
 
 // We generate code 1005, kWebSocketErrorNoStatusReceived, when there is no
 // status in the Close message from the other side. Code 1005 is not allowed to
 // appear on the wire, so we should not echo it back. See test
@@ skipping 28 matching lines @@
   EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
       .WillOnce(Return(OK));
 
   CreateChannelAndConnectSuccessfully();
 }
 
 // Receiving an invalid UTF-8 payload in a Close frame causes us to fail the
 // connection.
 TEST_F(WebSocketChannelStreamTest, CloseFrameInvalidUtf8) {
   static const InitFrame frames[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
-       NOT_MASKED, CLOSE_DATA(NORMAL_CLOSURE, "\xFF")}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED,
+       CLOSE_DATA(NORMAL_CLOSURE, "\xFF")}};
   static const InitFrame expected[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
-       MASKED, CLOSE_DATA(PROTOCOL_ERROR, "Invalid UTF-8 in Close frame")}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, MASKED,
+       CLOSE_DATA(PROTOCOL_ERROR, "Invalid UTF-8 in Close frame")}};
 
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, GetExtensions()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
       .WillOnce(ReturnFrames(&frames))
       .WillRepeatedly(Return(ERR_IO_PENDING));
   EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
       .WillOnce(Return(OK));
   EXPECT_CALL(*mock_stream_, Close());
 
   CreateChannelAndConnectSuccessfully();
 }
 
 // RFC6455 5.5.2 "Upon receipt of a Ping frame, an endpoint MUST send a Pong
 // frame in response"
 // 5.5.3 "A Pong frame sent in response to a Ping frame must have identical
 // "Application data" as found in the message body of the Ping frame being
 // replied to."
 TEST_F(WebSocketChannelStreamTest, PingRepliedWithPong) {
-  static const InitFrame frames[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodePing,
-       NOT_MASKED,  "Application data"}};
-  static const InitFrame expected[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodePong,
-       MASKED,      "Application data"}};
+  static const InitFrame frames[] = {{FINAL_FRAME,
+                                      WebSocketFrameHeader::kOpCodePing,
+                                      NOT_MASKED, "Application data"}};
+  static const InitFrame expected[] = {{FINAL_FRAME,
+                                        WebSocketFrameHeader::kOpCodePong,
+                                        MASKED, "Application data"}};
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, GetExtensions()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
       .WillOnce(ReturnFrames(&frames))
       .WillRepeatedly(Return(ERR_IO_PENDING));
   EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
       .WillOnce(Return(OK));
 
   CreateChannelAndConnectSuccessfully();
 }
@@ skipping 10 matching lines @@
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
       .WillOnce(ReturnFrames(&frames))
       .WillRepeatedly(Return(ERR_IO_PENDING));
   EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
       .WillOnce(Return(OK));
 
   CreateChannelAndConnectSuccessfully();
 }
 
 TEST_F(WebSocketChannelStreamTest, PongInTheMiddleOfDataMessage) {
-  static const InitFrame frames[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodePing,
-       NOT_MASKED,  "Application data"}};
+  static const InitFrame frames[] = {{FINAL_FRAME,
+                                      WebSocketFrameHeader::kOpCodePing,
+                                      NOT_MASKED, "Application data"}};
   static const InitFrame expected1[] = {
       {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, MASKED, "Hello "}};
-  static const InitFrame expected2[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodePong,
-       MASKED,      "Application data"}};
+  static const InitFrame expected2[] = {{FINAL_FRAME,
+                                         WebSocketFrameHeader::kOpCodePong,
+                                         MASKED, "Application data"}};
   static const InitFrame expected3[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation,
-       MASKED,      "World"}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation, MASKED,
+       "World"}};
   ScopedVector<WebSocketFrame>* read_frames;
   CompletionCallback read_callback;
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, GetExtensions()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
       .WillOnce(DoAll(SaveArg<0>(&read_frames),
                       SaveArg<1>(&read_callback),
                       Return(ERR_IO_PENDING)))
       .WillRepeatedly(Return(ERR_IO_PENDING));
   {
@@ skipping 81 matching lines @@
     channel_->SendFrame(true,
                         WebSocketFrameHeader::kOpCodeText,
                         std::vector<char>(1, input_letters[i]));
   }
   write_callback.Run(OK);
 }
 
 // When the renderer sends more on a channel than it has quota for, we send the
 // remote server a kWebSocketErrorGoingAway error code.
 TEST_F(WebSocketChannelStreamTest, SendGoingAwayOnRendererQuotaExceeded) {
-  static const InitFrame expected[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
-       MASKED,      CLOSE_DATA(GOING_AWAY, "")}};
+  static const InitFrame expected[] = {{FINAL_FRAME,
+                                        WebSocketFrameHeader::kOpCodeClose,
+                                        MASKED, CLOSE_DATA(GOING_AWAY, "")}};
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, GetExtensions()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _)).WillOnce(Return(ERR_IO_PENDING));
   EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
       .WillOnce(Return(OK));
   EXPECT_CALL(*mock_stream_, Close());
 
   CreateChannelAndConnectSuccessfully();
   channel_->SendFrame(true,
                       WebSocketFrameHeader::kOpCodeText,
@@ skipping 255 matching lines @@
   EXPECT_CALL(*mock_stream_, Close()).Times(1);
 
   CreateChannelAndConnectSuccessfully();
 }
 
 // UTF-8 parsing context must be retained between received frames of the same
 // message.
 TEST_F(WebSocketChannelReceiveUtf8Test, ReceivedParsingContextRetained) {
   static const InitFrame frames[] = {
       {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, "\xf1"},
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation,
-       NOT_MASKED,  "\x80\xa0\xbf"}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation, NOT_MASKED,
+       "\x80\xa0\xbf"}};
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
       .WillOnce(ReturnFrames(&frames))
       .WillRepeatedly(Return(ERR_IO_PENDING));
 
   CreateChannelAndConnectSuccessfully();
 }
 
 // An invalid character must be detected even if split between frames.
 TEST_F(WebSocketChannelReceiveUtf8Test, SplitInvalidCharacterReceived) {
   static const InitFrame frames[] = {
       {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, "\xe1"},
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation,
-       NOT_MASKED,  "\x80\xa0\xbf"}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation, NOT_MASKED,
+       "\x80\xa0\xbf"}};
   static const InitFrame expected[] = {
       {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, MASKED,
        CLOSE_DATA(PROTOCOL_ERROR, "Invalid UTF-8 in text frame")}};
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
       .WillOnce(ReturnFrames(&frames))
       .WillRepeatedly(Return(ERR_IO_PENDING));
   EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
       .WillOnce(Return(OK));
   EXPECT_CALL(*mock_stream_, Close()).Times(1);
 
   CreateChannelAndConnectSuccessfully();
 }
 
 // An invalid character received in a continuation frame must be detected.
 TEST_F(WebSocketChannelReceiveUtf8Test, InvalidReceivedIncontinuation) {
   static const InitFrame frames[] = {
       {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, "foo"},
-      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation,
-       NOT_MASKED,      "bar"},
-      {FINAL_FRAME,     WebSocketFrameHeader::kOpCodeContinuation,
-       NOT_MASKED,      "\xff"}};
+      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation, NOT_MASKED,
+       "bar"},
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation, NOT_MASKED,
+       "\xff"}};
   static const InitFrame expected[] = {
       {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, MASKED,
        CLOSE_DATA(PROTOCOL_ERROR, "Invalid UTF-8 in text frame")}};
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
       .WillOnce(ReturnFrames(&frames))
       .WillRepeatedly(Return(ERR_IO_PENDING));
   EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
       .WillOnce(Return(OK));
   EXPECT_CALL(*mock_stream_, Close()).Times(1);
 
   CreateChannelAndConnectSuccessfully();
 }
 
 // Continuations of binary frames must not be tested for UTF-8 validity.
 TEST_F(WebSocketChannelReceiveUtf8Test, ReceivedBinaryNotUtf8Tested) {
   static const InitFrame frames[] = {
       {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeBinary, NOT_MASKED, "foo"},
-      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation,
-       NOT_MASKED,      "bar"},
-      {FINAL_FRAME,     WebSocketFrameHeader::kOpCodeContinuation,
-       NOT_MASKED,      "\xff"}};
+      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation, NOT_MASKED,
+       "bar"},
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation, NOT_MASKED,
+       "\xff"}};
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
       .WillOnce(ReturnFrames(&frames))
       .WillRepeatedly(Return(ERR_IO_PENDING));
 
   CreateChannelAndConnectSuccessfully();
 }
 
 // Multiple Text messages can be validated.
 TEST_F(WebSocketChannelReceiveUtf8Test, ValidateMultipleReceived) {
   static const InitFrame frames[] = {
       {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, "foo"},
       {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, "bar"}};
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
       .WillOnce(ReturnFrames(&frames))
       .WillRepeatedly(Return(ERR_IO_PENDING));
 
   CreateChannelAndConnectSuccessfully();
 }
 
 // A new data message cannot start in the middle of another data message.
 TEST_F(WebSocketChannelEventInterfaceTest, BogusContinuation) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
   static const InitFrame frames[] = {
-      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeBinary,
-       NOT_MASKED, "frame1"},
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText,
-       NOT_MASKED, "frame2"}};
+      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeBinary, NOT_MASKED,
+       "frame1"},
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, "frame2"}};
   stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, frames);
   set_stream(stream.Pass());
 
   EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, _, _));
   EXPECT_CALL(*event_interface_, OnFlowControl(kDefaultInitialQuota));
   EXPECT_CALL(
       *event_interface_,
       OnDataFrame(
           false, WebSocketFrameHeader::kOpCodeBinary, AsVector("frame1")));
   EXPECT_CALL(
       *event_interface_,
       OnFailChannel(
           "Received start of new message but previous message is unfinished."));
 
   CreateChannelAndConnectSuccessfully();
 }
 
 // A new message cannot start with a Continuation frame.
 TEST_F(WebSocketChannelEventInterfaceTest, MessageStartingWithContinuation) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
-  static const InitFrame frames[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation,
-       NOT_MASKED, "continuation"}};
+  static const InitFrame frames[] = {{FINAL_FRAME,
+                                      WebSocketFrameHeader::kOpCodeContinuation,
+                                      NOT_MASKED, "continuation"}};
   stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, frames);
   set_stream(stream.Pass());
 
   EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, _, _));
   EXPECT_CALL(*event_interface_, OnFlowControl(kDefaultInitialQuota));
   EXPECT_CALL(*event_interface_,
               OnFailChannel("Received unexpected continuation frame."));
 
   CreateChannelAndConnectSuccessfully();
 }
 
 // A frame passed to the renderer must be either non-empty or have the final bit
 // set.
 TEST_F(WebSocketChannelEventInterfaceTest, DataFramesNonEmptyOrFinal) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
   static const InitFrame frames[] = {
       {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, ""},
-      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation,
-       NOT_MASKED, ""},
+      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation, NOT_MASKED,
+       ""},
       {FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation, NOT_MASKED, ""}};
   stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, frames);
   set_stream(stream.Pass());
 
   EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, _, _));
   EXPECT_CALL(*event_interface_, OnFlowControl(kDefaultInitialQuota));
   EXPECT_CALL(
       *event_interface_,
       OnDataFrame(true, WebSocketFrameHeader::kOpCodeText, AsVector("")));
 
   CreateChannelAndConnectSuccessfully();
 }
 
 // If we receive another frame after Close, it is not valid. It is not
 // completely clear what behaviour is required from the standard in this case,
 // but the current implementation fails the connection. Since a Close has
 // already been sent, this just means closing the connection.
 TEST_F(WebSocketChannelStreamTest, PingAfterCloseIsRejected) {
   static const InitFrame frames[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
-       NOT_MASKED,  CLOSE_DATA(NORMAL_CLOSURE, "OK")},
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodePing,
-       NOT_MASKED,  "Ping body"}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED,
+       CLOSE_DATA(NORMAL_CLOSURE, "OK")},
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodePing, NOT_MASKED,
+       "Ping body"}};
   static const InitFrame expected[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
-       MASKED,      CLOSE_DATA(NORMAL_CLOSURE, "OK")}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, MASKED,
+       CLOSE_DATA(NORMAL_CLOSURE, "OK")}};
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, GetExtensions()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
       .WillOnce(ReturnFrames(&frames))
       .WillRepeatedly(Return(ERR_IO_PENDING));
   {
     // We only need to verify the relative order of WriteFrames() and
     // Close(). The current implementation calls WriteFrames() for the Close
     // frame before calling ReadFrames() again, but that is an implementation
     // detail and better not to consider required behaviour.
     InSequence s;
     EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
         .WillOnce(Return(OK));
     EXPECT_CALL(*mock_stream_, Close()).Times(1);
   }
 
   CreateChannelAndConnectSuccessfully();
 }
 
 // A protocol error from the remote server should result in a close frame with
 // status 1002, followed by the connection closing.
 TEST_F(WebSocketChannelStreamTest, ProtocolError) {
   static const InitFrame expected[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
-       MASKED,      CLOSE_DATA(PROTOCOL_ERROR, "WebSocket Protocol Error")}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, MASKED,
+       CLOSE_DATA(PROTOCOL_ERROR, "WebSocket Protocol Error")}};
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, GetExtensions()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
       .WillOnce(Return(ERR_WS_PROTOCOL_ERROR));
   EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
       .WillOnce(Return(OK));
   EXPECT_CALL(*mock_stream_, Close());
 
   CreateChannelAndConnectSuccessfully();
 }
@@ skipping 13 matching lines @@
   }
 };
 
 // In this case the server initiates the closing handshake with a Close
 // message. WebSocketChannel responds with a matching Close message, and waits
 // for the server to close the TCP/IP connection. The server never closes the
 // connection, so the closing handshake times out and WebSocketChannel closes
 // the connection itself.
 TEST_F(WebSocketChannelStreamTimeoutTest, ServerInitiatedCloseTimesOut) {
   static const InitFrame frames[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
-       NOT_MASKED,  CLOSE_DATA(NORMAL_CLOSURE, "OK")}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED,
+       CLOSE_DATA(NORMAL_CLOSURE, "OK")}};
   static const InitFrame expected[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
-       MASKED,      CLOSE_DATA(NORMAL_CLOSURE, "OK")}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, MASKED,
+       CLOSE_DATA(NORMAL_CLOSURE, "OK")}};
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, GetExtensions()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
       .WillOnce(ReturnFrames(&frames))
       .WillRepeatedly(Return(ERR_IO_PENDING));
   Checkpoint checkpoint;
   TestClosure completion;
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
         .WillOnce(Return(OK));
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*mock_stream_, Close())
         .WillOnce(InvokeClosure(completion.closure()));
   }
 
   CreateChannelAndConnectSuccessfully();
   checkpoint.Call(1);
   completion.WaitForResult();
 }
 
 // In this case the client initiates the closing handshake by sending a Close
 // message. WebSocketChannel waits for a Close message in response from the
 // server. The server never responds to the Close message, so the closing
 // handshake times out and WebSocketChannel closes the connection.
 TEST_F(WebSocketChannelStreamTimeoutTest, ClientInitiatedCloseTimesOut) {
   static const InitFrame expected[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
-       MASKED,      CLOSE_DATA(NORMAL_CLOSURE, "OK")}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, MASKED,
+       CLOSE_DATA(NORMAL_CLOSURE, "OK")}};
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, GetExtensions()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
       .WillRepeatedly(Return(ERR_IO_PENDING));
   TestClosure completion;
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
         .WillOnce(Return(OK));
     EXPECT_CALL(*mock_stream_, Close())
         .WillOnce(InvokeClosure(completion.closure()));
   }
 
   CreateChannelAndConnectSuccessfully();
   channel_->StartClosingHandshake(kWebSocketNormalClosure, "OK");
   completion.WaitForResult();
 }
 
 // In this case the client initiates the closing handshake and the server
 // responds with a matching Close message. WebSocketChannel waits for the server
 // to close the TCP/IP connection, but it never does. The closing handshake
 // times out and WebSocketChannel closes the connection.
 TEST_F(WebSocketChannelStreamTimeoutTest, ConnectionCloseTimesOut) {
   static const InitFrame expected[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
-       MASKED,      CLOSE_DATA(NORMAL_CLOSURE, "OK")}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, MASKED,
+       CLOSE_DATA(NORMAL_CLOSURE, "OK")}};
   static const InitFrame frames[] = {
-      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
-       NOT_MASKED,  CLOSE_DATA(NORMAL_CLOSURE, "OK")}};
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED,
+       CLOSE_DATA(NORMAL_CLOSURE, "OK")}};
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, GetExtensions()).Times(AnyNumber());
   TestClosure completion;
   ScopedVector<WebSocketFrame>* read_frames = NULL;
   CompletionCallback read_callback;
   {
     InSequence s;
     // Copy the arguments to ReadFrames so that the test can call the callback
     // after it has send the close message.
     EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
@@ skipping 18 matching lines @@
   channel_->StartClosingHandshake(kWebSocketNormalClosure, "OK");
   ASSERT_TRUE(read_frames);
   // Provide the "Close" message from the server.
   *read_frames = CreateFrameVector(frames);
   read_callback.Run(OK);
   completion.WaitForResult();
 }
 
 }  // namespace
 }  // namespace net