Clang format slam.

net/websockets/websocket_deflate_stream_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_deflate_stream.h"
 
 #include <stdint.h>
 #include <deque>
 #include <string>
 
@@ skipping 76 matching lines @@
               WebSocketFrameHeader::OpCode opcode,
               FrameFlag flag) {
   scoped_ptr<WebSocketFrame> frame(new WebSocketFrame(opcode));
   frame->header.final = (flag & kFinal);
   frame->header.reserved1 = (flag & kReserved1);
   frames->push_back(frame.release());
 }
 
 class MockWebSocketStream : public WebSocketStream {
  public:
-  MOCK_METHOD2(ReadFrames, int(ScopedVector<WebSocketFrame>*,
-                               const CompletionCallback&));
-  MOCK_METHOD2(WriteFrames, int(ScopedVector<WebSocketFrame>*,
-                                const CompletionCallback&));
+  MOCK_METHOD2(ReadFrames,
+               int(ScopedVector<WebSocketFrame>*, const CompletionCallback&));
+  MOCK_METHOD2(WriteFrames,
+               int(ScopedVector<WebSocketFrame>*, const CompletionCallback&));
   MOCK_METHOD0(Close, void());
   MOCK_CONST_METHOD0(GetSubProtocol, std::string());
   MOCK_CONST_METHOD0(GetExtensions, std::string());
 };
 
 // This mock class relies on some assumptions.
 //  - RecordInputDataFrame is called after the corresponding WriteFrames
 //    call.
 //  - RecordWrittenDataFrame is called before writing the frame.
 class WebSocketDeflatePredictorMock : public WebSocketDeflatePredictor {
@@ skipping 90 matching lines @@
   // Data frames recorded by |RecordWrittenFrames|.
   // Pushed by |RecordWrittenFrames| and popped and verified by
   // |VerifySentFrame|.
   std::deque<const WebSocketFrame*> frames_written_;
 
   DISALLOW_COPY_AND_ASSIGN(WebSocketDeflatePredictorMock);
 };
 
 class WebSocketDeflateStreamTest : public ::testing::Test {
  public:
-  WebSocketDeflateStreamTest()
-      : mock_stream_(NULL),
-        predictor_(NULL) {}
+  WebSocketDeflateStreamTest() : mock_stream_(NULL), predictor_(NULL) {}
   virtual ~WebSocketDeflateStreamTest() {}
 
   virtual void SetUp() {
     Initialize(WebSocketDeflater::TAKE_OVER_CONTEXT, kWindowBits);
   }
 
  protected:
   // Initialize deflate_stream_ with the given parameters.
   void Initialize(WebSocketDeflater::ContextTakeOverMode mode,
                   int window_bits) {
@@ skipping 70 matching lines @@
            const CompletionCallback& callback) {
     DCHECK(frames->empty());
     frames_passed_ = frames;
     callback_ = callback;
     frames->swap(frames_to_output_);
     return result_;
   }
 
   int result() const { return result_; }
   const CompletionCallback callback() const { return callback_; }
-  ScopedVector<WebSocketFrame>* frames_passed() {
-    return frames_passed_;
-  }
+  ScopedVector<WebSocketFrame>* frames_passed() { return frames_passed_; }
 
  private:
   int result_;
   CompletionCallback callback_;
   ScopedVector<WebSocketFrame> frames_to_output_;
   ScopedVector<WebSocketFrame>* frames_passed_;
 };
 
 // WriteFramesStub is a stub for WebSocketStream::WriteFrames.
 // It returns |result_| and |frames_| to the caller and
 // saves |callback| parameter to |callback_|.
 class WriteFramesStub {
  public:
-  explicit WriteFramesStub(WebSocketDeflatePredictorMock* predictor,
-                           int result)
+  explicit WriteFramesStub(WebSocketDeflatePredictorMock* predictor, int result)
       : result_(result), predictor_(predictor) {}
 
   int Call(ScopedVector<WebSocketFrame>* frames,
            const CompletionCallback& callback) {
     frames_.insert(frames_.end(), frames->begin(), frames->end());
     frames->weak_clear();
     callback_ = callback;
     predictor_->VerifySentFrames(frames_);
     return result_;
   }
@@ skipping 15 matching lines @@
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Return(ERR_FAILED));
   }
   EXPECT_EQ(ERR_FAILED, deflate_stream_->ReadFrames(&frames, callback));
 }
 
 TEST_F(WebSocketDeflateStreamTest, ReadUncompressedFrameImmediately) {
   ScopedVector<WebSocketFrame> frames_to_output;
-  AppendTo(&frames_to_output,
-           WebSocketFrameHeader::kOpCodeText,
-           kFinal,
-           "hello");
+  AppendTo(
+      &frames_to_output, WebSocketFrameHeader::kOpCodeText, kFinal, "hello");
   ReadFramesStub stub(OK, &frames_to_output);
   ScopedVector<WebSocketFrame> frames;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
   }
   CompletionCallback callback;
   ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
@@ skipping 16 matching lines @@
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
     EXPECT_CALL(checkpoint, Call(0));
     EXPECT_CALL(mock_callback, Call(OK));
   }
   ASSERT_EQ(ERR_IO_PENDING, deflate_stream_->ReadFrames(&frames, callback));
   ASSERT_EQ(0u, frames.size());
 
   checkpoint.Call(0);
 
-  AppendTo(stub.frames_passed(),
-           WebSocketFrameHeader::kOpCodeText,
-           kFinal,
-           "hello");
+  AppendTo(
+      stub.frames_passed(), WebSocketFrameHeader::kOpCodeText, kFinal, "hello");
   stub.callback().Run(OK);
   ASSERT_EQ(1u, frames.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
   EXPECT_TRUE(frames[0]->header.final);
   EXPECT_FALSE(frames[0]->header.reserved1);
   EXPECT_EQ("hello", ToString(frames[0]));
 }
 
 TEST_F(WebSocketDeflateStreamTest, ReadFailedAsync) {
   ReadFramesStub stub(ERR_IO_PENDING);
   ScopedVector<WebSocketFrame> frames;
   MockCallback mock_callback, checkpoint;
   CompletionCallback callback =
       base::Bind(&MockCallback::Call, base::Unretained(&mock_callback));
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
     EXPECT_CALL(checkpoint, Call(0));
     EXPECT_CALL(mock_callback, Call(ERR_FAILED));
   }
   ASSERT_EQ(ERR_IO_PENDING, deflate_stream_->ReadFrames(&frames, callback));
   ASSERT_EQ(0u, frames.size());
 
   checkpoint.Call(0);
 
-  AppendTo(stub.frames_passed(),
-           WebSocketFrameHeader::kOpCodeText,
-           kFinal,
-           "hello");
+  AppendTo(
+      stub.frames_passed(), WebSocketFrameHeader::kOpCodeText, kFinal, "hello");
   stub.callback().Run(ERR_FAILED);
   ASSERT_EQ(0u, frames.size());
 }
 
 TEST_F(WebSocketDeflateStreamTest, ReadCompressedFrameImmediately) {
   ScopedVector<WebSocketFrame> frames_to_output;
   AppendTo(&frames_to_output,
            WebSocketFrameHeader::kOpCodeText,
            kFinal | kReserved1,
            std::string("\xf2\x48\xcd\xc9\xc9\x07\x00", 7));
@@ skipping 41 matching lines @@
   EXPECT_TRUE(frames[0]->header.final);
   EXPECT_FALSE(frames[0]->header.reserved1);
   EXPECT_EQ("Hello", ToString(frames[0]));
 }
 
 TEST_F(WebSocketDeflateStreamTest,
        ReadCompressedFrameFragmentImmediatelyButInflaterReturnsPending) {
   ScopedVector<WebSocketFrame> frames_to_output;
   const std::string data1("\xf2", 1);
   const std::string data2("\x48\xcd\xc9\xc9\x07\x00", 6);
-  AppendTo(&frames_to_output,
-           WebSocketFrameHeader::kOpCodeText,
-           kReserved1,
-           data1);
+  AppendTo(
+      &frames_to_output, WebSocketFrameHeader::kOpCodeText, kReserved1, data1);
   ReadFramesStub stub1(OK, &frames_to_output), stub2(ERR_IO_PENDING);
   MockCallback mock_callback, checkpoint;
   CompletionCallback callback =
       base::Bind(&MockCallback::Call, base::Unretained(&mock_callback));
   ScopedVector<WebSocketFrame> frames;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub1, &ReadFramesStub::Call))
         .WillOnce(Invoke(&stub2, &ReadFramesStub::Call));
     EXPECT_CALL(checkpoint, Call(0));
     EXPECT_CALL(mock_callback, Call(OK));
   }
   ASSERT_EQ(ERR_IO_PENDING, deflate_stream_->ReadFrames(&frames, callback));
   ASSERT_EQ(0u, frames.size());
 
-  AppendTo(stub2.frames_passed(),
-           WebSocketFrameHeader::kOpCodeText,
-           kFinal,
-           data2);
+  AppendTo(
+      stub2.frames_passed(), WebSocketFrameHeader::kOpCodeText, kFinal, data2);
 
   checkpoint.Call(0);
   stub2.callback().Run(OK);
 
   ASSERT_EQ(1u, frames.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
   EXPECT_TRUE(frames[0]->header.final);
   EXPECT_FALSE(frames[0]->header.reserved1);
   EXPECT_EQ("Hello", ToString(frames[0]));
 }
@@ skipping 16 matching lines @@
   }
   ASSERT_EQ(ERR_WS_PROTOCOL_ERROR,
             deflate_stream_->ReadFrames(&frames, callback));
   ASSERT_EQ(0u, frames.size());
 }
 
 TEST_F(WebSocketDeflateStreamTest, MergeMultipleFramesInReadFrames) {
   const std::string data1("\xf2\x48\xcd", 3);
   const std::string data2("\xc9\xc9\x07\x00", 4);
   ScopedVector<WebSocketFrame> frames_to_output;
-  AppendTo(&frames_to_output,
-           WebSocketFrameHeader::kOpCodeText,
-           kReserved1,
-           data1);
+  AppendTo(
+      &frames_to_output, WebSocketFrameHeader::kOpCodeText, kReserved1, data1);
   AppendTo(&frames_to_output,
            WebSocketFrameHeader::kOpCodeContinuation,
            kFinal,
            data2);
   ReadFramesStub stub(OK, &frames_to_output);
   CompletionCallback callback;
   ScopedVector<WebSocketFrame> frames;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
   }
   ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
   ASSERT_EQ(1u, frames.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
   EXPECT_TRUE(frames[0]->header.final);
   EXPECT_FALSE(frames[0]->header.reserved1);
   EXPECT_EQ("Hello", ToString(frames[0]));
 }
 
 TEST_F(WebSocketDeflateStreamTest, ReadUncompressedEmptyFrames) {
   ScopedVector<WebSocketFrame> frames_to_output;
-  AppendTo(&frames_to_output,
-           WebSocketFrameHeader::kOpCodeText,
-           kNoFlag);
-  AppendTo(&frames_to_output,
-           WebSocketFrameHeader::kOpCodeContinuation,
-           kFinal);
+  AppendTo(&frames_to_output, WebSocketFrameHeader::kOpCodeText, kNoFlag);
+  AppendTo(
+      &frames_to_output, WebSocketFrameHeader::kOpCodeContinuation, kFinal);
   ReadFramesStub stub(OK, &frames_to_output);
   CompletionCallback callback;
   ScopedVector<WebSocketFrame> frames;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
   }
   ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
   ASSERT_EQ(2u, frames.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
   EXPECT_FALSE(frames[0]->header.final);
   EXPECT_FALSE(frames[0]->header.reserved1);
   EXPECT_EQ("", ToString(frames[0]));
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeContinuation,
             frames[1]->header.opcode);
   EXPECT_TRUE(frames[1]->header.final);
   EXPECT_FALSE(frames[1]->header.reserved1);
   EXPECT_EQ("", ToString(frames[1]));
 }
 
 TEST_F(WebSocketDeflateStreamTest, ReadCompressedEmptyFrames) {
   ScopedVector<WebSocketFrame> frames_to_output;
   AppendTo(&frames_to_output,
            WebSocketFrameHeader::kOpCodeText,
            kReserved1,
            std::string("\x02\x00", 1));
-  AppendTo(&frames_to_output,
-           WebSocketFrameHeader::kOpCodeContinuation,
-           kFinal);
+  AppendTo(
+      &frames_to_output, WebSocketFrameHeader::kOpCodeContinuation, kFinal);
   ReadFramesStub stub(OK, &frames_to_output);
   CompletionCallback callback;
   ScopedVector<WebSocketFrame> frames;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
   }
   ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
   ASSERT_EQ(1u, frames.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
   EXPECT_TRUE(frames[0]->header.final);
   EXPECT_FALSE(frames[0]->header.reserved1);
   EXPECT_EQ("", ToString(frames[0]));
 }
 
-TEST_F(WebSocketDeflateStreamTest,
-       ReadCompressedFrameFollowedByEmptyFrame) {
+TEST_F(WebSocketDeflateStreamTest, ReadCompressedFrameFollowedByEmptyFrame) {
   const std::string data("\xf2\x48\xcd\xc9\xc9\x07\x00", 7);
   ScopedVector<WebSocketFrame> frames_to_output;
-  AppendTo(&frames_to_output,
-           WebSocketFrameHeader::kOpCodeText,
-           kReserved1,
-           data);
-  AppendTo(&frames_to_output,
-           WebSocketFrameHeader::kOpCodeContinuation,
-           kFinal);
+  AppendTo(
+      &frames_to_output, WebSocketFrameHeader::kOpCodeText, kReserved1, data);
+  AppendTo(
+      &frames_to_output, WebSocketFrameHeader::kOpCodeContinuation, kFinal);
   ReadFramesStub stub(OK, &frames_to_output);
   CompletionCallback callback;
   ScopedVector<WebSocketFrame> frames;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
   }
   ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
   ASSERT_EQ(1u, frames.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
   EXPECT_TRUE(frames[0]->header.final);
   EXPECT_FALSE(frames[0]->header.reserved1);
   EXPECT_EQ("Hello", ToString(frames[0]));
 }
 
 TEST_F(WebSocketDeflateStreamTest, ReadControlFrameBetweenDataFrames) {
   const std::string data1("\xf2\x48\xcd", 3);
   const std::string data2("\xc9\xc9\x07\x00", 4);
   ScopedVector<WebSocketFrame> frames_to_output;
-  AppendTo(&frames_to_output,
-           WebSocketFrameHeader::kOpCodeText,
-           kReserved1,
-           data1);
+  AppendTo(
+      &frames_to_output, WebSocketFrameHeader::kOpCodeText, kReserved1, data1);
   AppendTo(&frames_to_output, WebSocketFrameHeader::kOpCodePing, kFinal);
   AppendTo(&frames_to_output, WebSocketFrameHeader::kOpCodeText, kFinal, data2);
   ReadFramesStub stub(OK, &frames_to_output);
   CompletionCallback callback;
   ScopedVector<WebSocketFrame> frames;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
@@ skipping 57 matching lines @@
   deflater.Initialize(kWindowBits);
   const std::string original_data(kChunkSize, 'a');
   deflater.AddBytes(original_data.data(), original_data.size());
   deflater.Finish();
 
   ScopedVector<WebSocketFrame> frames_to_output;
   AppendTo(&frames_to_output,
            WebSocketFrameHeader::kOpCodeBinary,
            kReserved1,
            ToString(deflater.GetOutput(deflater.CurrentOutputSize())));
-  AppendTo(&frames_to_output,
-           WebSocketFrameHeader::kOpCodeBinary,
-           kFinal,
-           "");
+  AppendTo(&frames_to_output, WebSocketFrameHeader::kOpCodeBinary, kFinal, "");
 
   ReadFramesStub stub(OK, &frames_to_output);
   CompletionCallback callback;
   ScopedVector<WebSocketFrame> frames;
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
   }
 
@@ skipping 10 matching lines @@
   EXPECT_FALSE(frames[1]->header.reserved1);
   EXPECT_EQ(0u, static_cast<size_t>(frames[1]->header.payload_length));
   EXPECT_EQ(original_data, ToString(frames[0]) + ToString(frames[1]));
 }
 
 TEST_F(WebSocketDeflateStreamTest,
        Reserved1TurnsOnDuringReadingCompressedContinuationFrame) {
   const std::string data1("\xf2\x48\xcd", 3);
   const std::string data2("\xc9\xc9\x07\x00", 4);
   ScopedVector<WebSocketFrame> frames_to_output;
-  AppendTo(&frames_to_output,
-           WebSocketFrameHeader::kOpCodeText,
-           kReserved1,
-           data1);
+  AppendTo(
+      &frames_to_output, WebSocketFrameHeader::kOpCodeText, kReserved1, data1);
   AppendTo(&frames_to_output,
            WebSocketFrameHeader::kOpCodeContinuation,
            kFinal | kReserved1,
            data2);
   ReadFramesStub stub(OK, &frames_to_output);
   CompletionCallback callback;
   ScopedVector<WebSocketFrame> frames;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
   }
   ASSERT_EQ(ERR_WS_PROTOCOL_ERROR,
             deflate_stream_->ReadFrames(&frames, callback));
 }
 
 TEST_F(WebSocketDeflateStreamTest,
        Reserved1TurnsOnDuringReadingUncompressedContinuationFrame) {
   ScopedVector<WebSocketFrame> frames_to_output;
-  AppendTo(&frames_to_output,
-           WebSocketFrameHeader::kOpCodeText,
-           kNoFlag,
-           "hello");
+  AppendTo(
+      &frames_to_output, WebSocketFrameHeader::kOpCodeText, kNoFlag, "hello");
   AppendTo(&frames_to_output,
            WebSocketFrameHeader::kOpCodeContinuation,
            kFinal | kReserved1,
            "world");
   ReadFramesStub stub(OK, &frames_to_output);
   CompletionCallback callback;
   ScopedVector<WebSocketFrame> frames;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
   }
   ASSERT_EQ(ERR_WS_PROTOCOL_ERROR,
             deflate_stream_->ReadFrames(&frames, callback));
 }
 
 TEST_F(WebSocketDeflateStreamTest, ReadCompressedMessages) {
   ScopedVector<WebSocketFrame> frames_to_output;
+  AppendTo(
+      &frames_to_output,
+      WebSocketFrameHeader::kOpCodeText,
+      kFinal | kReserved1,
+      std::string("\x4a\xce\xcf\x2d\x28\x4a\x2d\x2e\x4e\x4d\x31\x04\x00", 13));
   AppendTo(&frames_to_output,
            WebSocketFrameHeader::kOpCodeText,
            kFinal | kReserved1,
-           std::string(
-               "\x4a\xce\xcf\x2d\x28\x4a\x2d\x2e\x4e\x4d\x31\x04\x00", 13));
-  AppendTo(&frames_to_output,
-           WebSocketFrameHeader::kOpCodeText,
-           kFinal | kReserved1,
            std::string("\x4a\x86\x33\x8d\x00\x00", 6));
   ReadFramesStub stub(OK, &frames_to_output);
   CompletionCallback callback;
   ScopedVector<WebSocketFrame> frames;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
   }
@@ skipping 39 matching lines @@
   EXPECT_FALSE(frames[1]->header.reserved1);
   EXPECT_EQ("uncompressed2", ToString(frames[1]));
 }
 
 TEST_F(WebSocketDeflateStreamTest,
        ReadCompressedMessageThenUncompressedMessage) {
   ScopedVector<WebSocketFrame> frames_to_output;
   AppendTo(&frames_to_output,
            WebSocketFrameHeader::kOpCodeText,
            kFinal | kReserved1,
-           std::string(
-               "\x4a\xce\xcf\x2d\x28\x4a\x2d\x2e\x4e\x4d\x01\x00", 12));
+           std::string("\x4a\xce\xcf\x2d\x28\x4a\x2d\x2e\x4e\x4d\x01\x00", 12));
   AppendTo(&frames_to_output,
            WebSocketFrameHeader::kOpCodeText,
            kFinal,
            "uncompressed");
   ReadFramesStub stub(OK, &frames_to_output);
   CompletionCallback callback;
   ScopedVector<WebSocketFrame> frames;
 
   {
     InSequence s;
@@ skipping 15 matching lines @@
 TEST_F(WebSocketDeflateStreamTest,
        ReadUncompressedMessageThenCompressedMessage) {
   ScopedVector<WebSocketFrame> frames_to_output;
   AppendTo(&frames_to_output,
            WebSocketFrameHeader::kOpCodeText,
            kFinal,
            "uncompressed");
   AppendTo(&frames_to_output,
            WebSocketFrameHeader::kOpCodeText,
            kFinal | kReserved1,
-           std::string(
-               "\x4a\xce\xcf\x2d\x28\x4a\x2d\x2e\x4e\x4d\x01\x00", 12));
+           std::string("\x4a\xce\xcf\x2d\x28\x4a\x2d\x2e\x4e\x4d\x01\x00", 12));
   ReadFramesStub stub(OK, &frames_to_output);
   CompletionCallback callback;
   ScopedVector<WebSocketFrame> frames;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
   }
   ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
@@ skipping 367 matching lines @@
   AddCompressibleFrameString();
   WriteFramesStub stub(predictor_, OK);
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, WriteFrames(_, _))
         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
   }
   ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames_, callback));
   const ScopedVector<WebSocketFrame>& frames_passed = *stub.frames();
   ASSERT_EQ(1u, frames_passed.size());
-  EXPECT_EQ(std::string("r\xce(\xca\xcf\xcd,\xcdM\x1c\xe1\xc0\x39\xa3"
-                        "(?7\xb3\x34\x17\x00", 21),
+  EXPECT_EQ(std::string(
+                "r\xce(\xca\xcf\xcd,\xcdM\x1c\xe1\xc0\x39\xa3"
+                "(?7\xb3\x34\x17\x00",
+                21),
             ToString(frames_passed[0]));
 }
 
 // The same input with window_bits=10 returns smaller output.
 TEST_F(WebSocketDeflateStreamWithClientWindowBitsTest, WindowBits10) {
   SetUpWithWindowBits(10);
   CompletionCallback callback;
   AddCompressibleFrameString();
   WriteFramesStub stub(predictor_, OK);
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, WriteFrames(_, _))
         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
   }
   ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames_, callback));
   const ScopedVector<WebSocketFrame>& frames_passed = *stub.frames();
   ASSERT_EQ(1u, frames_passed.size());
   EXPECT_EQ(
       std::string("r\xce(\xca\xcf\xcd,\xcdM\x1c\xe1\xc0\x19\x1a\x0e\0\0", 17),
       ToString(frames_passed[0]));
 }
 
 }  // namespace
 
 }  // namespace net