Introduce WebSocketDeflatePredictor.

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>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
+#include "net/websockets/websocket_deflate_predictor.h"
 #include "net/websockets/websocket_deflater.h"
 #include "net/websockets/websocket_frame.h"
 #include "net/websockets/websocket_inflater.h"
 #include "net/websockets/websocket_stream.h"
 #include "net/websockets/websocket_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace {
@@ skipping 30 matching lines @@
 }
 
 std::string ToString(IOBuffer* buffer, size_t size) {
   return std::string(buffer->data(), size);
 }
 
 std::string ToString(const scoped_refptr<IOBuffer>& buffer, size_t size) {
   return ToString(buffer.get(), size);
 }
 
-std::string ToString(WebSocketFrame* frame) {
+std::string ToString(const WebSocketFrame* frame) {
   return frame->data ? ToString(frame->data, frame->header.payload_length) : "";
 }
 
 void AppendTo(ScopedVector<WebSocketFrame>* frames,
               WebSocketFrameHeader::OpCode opcode,
               FrameFlag flag,
               const std::string& data) {
   scoped_ptr<WebSocketFrame> frame(new WebSocketFrame(opcode));
   frame->header.final = (flag & kFinal);
   frame->header.reserved1 = (flag & kReserved1);
@@ skipping 15 matching lines @@
  public:
   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 {
+ public:
+  WebSocketDeflatePredictorMock() : result_(DEFLATE) {}
+  virtual ~WebSocketDeflatePredictorMock() {
+    // Verify whether all expectaions are consumed.
+    if (!frames_to_be_input_.empty()) {
+      ADD_FAILURE() << "There are missing frames to be input.";
+      return;
+    }
+    if (!frames_written_.empty()) {
+      ADD_FAILURE() << "There are extra written frames.";
+      return;
+    }
+  }
+
+  // WebSocketDeflatePredictor functions.
+  virtual Result Predict(const ScopedVector<WebSocketFrame>& frames,
+                         size_t frame_index) OVERRIDE {
+    return result_;
+  }
+  virtual void RecordInputDataFrame(const WebSocketFrame* frame) OVERRIDE {
+    if (!WebSocketFrameHeader::IsKnownDataOpCode(frame->header.opcode)) {
+      ADD_FAILURE() << "Control frames should not be recorded.";
+      return;
+    }
+    if (frame->header.reserved1) {
+      ADD_FAILURE() << "Input frame may not be compressed.";
+      return;
+    }
+    if (frames_to_be_input_.empty()) {
+      ADD_FAILURE() << "Unexpected input data frame";
+      return;
+    }
+    if (frame != frames_to_be_input_.front()) {
+      ADD_FAILURE() << "Input data frame does not match the expectation.";
+      return;
+    }
+    frames_to_be_input_.pop_front();
+  }
+  virtual void RecordWrittenDataFrame(const WebSocketFrame* frame) OVERRIDE {
+    if (!WebSocketFrameHeader::IsKnownDataOpCode(frame->header.opcode)) {
+      ADD_FAILURE() << "Control frames should not be recorded.";
+      return;
+    }
+    frames_written_.push_back(frame);
+  }
+
+  // Sets |result_| for the |Predict| return value.
+  void set_result(Result result) { result_ = result; }
+
+  // Adds |frame| as an expectation of future |RecordInputDataFrame| call.
+  void AddFrameToBeInput(const WebSocketFrame* frame) {
+    if (!WebSocketFrameHeader::IsKnownDataOpCode(frame->header.opcode))
+      return;
+    frames_to_be_input_.push_back(frame);
+  }
+  // Verifies that |frame| is recorded in order.
+  void VerifySentFrame(const WebSocketFrame* frame) {
+    if (!WebSocketFrameHeader::IsKnownDataOpCode(frame->header.opcode))
+      return;
+    if (frames_written_.empty()) {
+      ADD_FAILURE() << "There are missing frames to be written.";
+      return;
+    }
+    if (frame != frames_written_.front()) {
+      ADD_FAILURE() << "Written data frame does not match the expectation.";
+      return;
+    }
+    frames_written_.pop_front();
+  }
+  void AddFramesToBeInput(const ScopedVector<WebSocketFrame>& frames) {
+    for (size_t i = 0; i < frames.size(); ++i)
+      AddFrameToBeInput(frames[i]);
+  }
+  void VerifySentFrames(const ScopedVector<WebSocketFrame>& frames) {
+    for (size_t i = 0; i < frames.size(); ++i)
+      VerifySentFrame(frames[i]);
+  }
+  // Call this method in order to disable checks in the destructor when
+  // WriteFrames fails.
+  void Clear() {
+    frames_to_be_input_.clear();
+    frames_written_.clear();
+  }
+
+ private:
+  Result result_;
+  // Data frames which will be recorded by |RecordInputFrames|.
+  // Pushed by |AddFrameToBeInput| and popped and verified by
+  // |RecordInputFrames|.
+  std::deque<const WebSocketFrame*> frames_to_be_input_;
+  // 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) {
     mock_stream_ = new testing::StrictMock<MockWebSocketStream>;
+    predictor_ = new WebSocketDeflatePredictorMock;
     deflate_stream_.reset(new WebSocketDeflateStream(
         scoped_ptr<WebSocketStream>(mock_stream_),
-        WebSocketDeflater::TAKE_OVER_CONTEXT));
+        WebSocketDeflater::TAKE_OVER_CONTEXT,
+        scoped_ptr<WebSocketDeflatePredictor>(predictor_)));
   }
   virtual ~WebSocketDeflateStreamTest() {}
 
  protected:
   scoped_ptr<WebSocketDeflateStream> deflate_stream_;
-  // |mock_stream_| will be deleted when |deflate_stream_| is destroyed.
+  // Owned by |deflate_stream_|.
   MockWebSocketStream* mock_stream_;
+  // Owned by |deflate_stream_|.
+  WebSocketDeflatePredictorMock* predictor_;
 };
 
 // Since WebSocketDeflater with DoNotTakeOverContext is well tested at
-// websocket_deflater_test.cc, we have only one test for this configuration
+// websocket_deflater_test.cc, we have only a few tests for this configuration
 // here.
 class WebSocketDeflateStreamWithDoNotTakeOverContextTest
     : public ::testing::Test {
  public:
   WebSocketDeflateStreamWithDoNotTakeOverContextTest()
       : mock_stream_(NULL) {
     mock_stream_ = new testing::StrictMock<MockWebSocketStream>;
+    predictor_ = new WebSocketDeflatePredictorMock;
     deflate_stream_.reset(new WebSocketDeflateStream(
         scoped_ptr<WebSocketStream>(mock_stream_),
-        WebSocketDeflater::DO_NOT_TAKE_OVER_CONTEXT));
+        WebSocketDeflater::DO_NOT_TAKE_OVER_CONTEXT,
+        scoped_ptr<WebSocketDeflatePredictor>(predictor_)));
   }
   virtual ~WebSocketDeflateStreamWithDoNotTakeOverContextTest() {}
 
  protected:
   scoped_ptr<WebSocketDeflateStream> deflate_stream_;
   // |mock_stream_| will be deleted when |deflate_stream_| is destroyed.
   MockWebSocketStream* mock_stream_;
+  // |predictor_| will be deleted when |deflate_stream_| is destroyed.
+  WebSocketDeflatePredictorMock* predictor_;
 };
 
 // ReadFrameStub is a stub for WebSocketStream::ReadFrames.
 // It returns |result_| and |frames_to_output_| to the caller and
 // saves parameters to |frames_passed_| and |callback_|.
 class ReadFramesStub {
  public:
   explicit ReadFramesStub(int result) : result_(result) {}
 
   ReadFramesStub(int result, ScopedVector<WebSocketFrame>* frames_to_output)
@@ skipping 16 matching lines @@
     return frames_passed_;
   }
 
  private:
   int result_;
   CompletionCallback callback_;
   ScopedVector<WebSocketFrame> frames_to_output_;
   ScopedVector<WebSocketFrame>* frames_passed_;
 };
 
-// WriteFrameStub is a stub for WebSocketStream::WriteFrames.
+// 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(int result) : result_(result) {}
+  explicit WriteFramesStub(WebSocketDeflatePredictorMock* predictor,
+                           int result)
+      : result_(result), predictor_(predictor) {}
 
   int Call(ScopedVector<WebSocketFrame>* frames,
            const CompletionCallback& callback) {
-    for (size_t i = 0; i < frames->size(); ++i) {
-      frames_.push_back((*frames)[i]);
-    }
+    frames_.insert(frames_.end(), frames->begin(), frames->end());
     frames->weak_clear();
     callback_ = callback;
+    predictor_->VerifySentFrames(frames_);
     return result_;
   }
 
   int result() const { return result_; }
   const CompletionCallback callback() const { return callback_; }
   ScopedVector<WebSocketFrame>* frames() { return &frames_; }
 
  private:
   int result_;
   CompletionCallback callback_;
   ScopedVector<WebSocketFrame> frames_;
+  WebSocketDeflatePredictorMock* predictor_;
 };
 
 TEST_F(WebSocketDeflateStreamTest, ReadFailedImmediately) {
   ScopedVector<WebSocketFrame> frames;
   CompletionCallback callback;
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
         .WillOnce(Return(ERR_FAILED));
   }
@@ skipping 573 matching lines @@
 TEST_F(WebSocketDeflateStreamTest, WriteFailedImmediately) {
   ScopedVector<WebSocketFrame> frames;
   CompletionCallback callback;
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, WriteFrames(&frames, _))
         .WillOnce(Return(ERR_FAILED));
   }
 
   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kFinal, "hello");
+  predictor_->AddFramesToBeInput(frames);
   EXPECT_EQ(ERR_FAILED, deflate_stream_->WriteFrames(&frames, callback));
+  predictor_->Clear();
 }
 
 TEST_F(WebSocketDeflateStreamTest, WriteFrameImmediately) {
   ScopedVector<WebSocketFrame> frames;
   CompletionCallback callback;
-  WriteFramesStub stub(OK);
+  WriteFramesStub stub(predictor_, OK);
   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kFinal, "Hello");
+  predictor_->AddFramesToBeInput(frames);
   {
     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(WebSocketFrameHeader::kOpCodeText, frames_passed[0]->header.opcode);
   EXPECT_TRUE(frames_passed[0]->header.final);
   EXPECT_TRUE(frames_passed[0]->header.reserved1);
   EXPECT_EQ(std::string("\xf2\x48\xcd\xc9\xc9\x07\x00", 7),
             ToString(frames_passed[0]));
 }
 
 TEST_F(WebSocketDeflateStreamTest, WriteFrameAsync) {
-  WriteFramesStub stub(ERR_IO_PENDING);
+  WriteFramesStub stub(predictor_, 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_, WriteFrames(&frames, _))
         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
     EXPECT_CALL(checkpoint, Call(0));
     EXPECT_CALL(mock_callback, Call(OK));
   }
   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kFinal, "Hello");
+  predictor_->AddFramesToBeInput(frames);
   ASSERT_EQ(ERR_IO_PENDING, deflate_stream_->WriteFrames(&frames, callback));
 
   checkpoint.Call(0);
   stub.callback().Run(OK);
 
   const ScopedVector<WebSocketFrame>& frames_passed = *stub.frames();
   ASSERT_EQ(1u, frames_passed.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[0]->header.opcode);
   EXPECT_TRUE(frames_passed[0]->header.final);
   EXPECT_TRUE(frames_passed[0]->header.reserved1);
   EXPECT_EQ(std::string("\xf2\x48\xcd\xc9\xc9\x07\x00", 7),
             ToString(frames_passed[0]));
 }
 
 TEST_F(WebSocketDeflateStreamTest, WriteControlFrameBetweenDataFrames) {
   ScopedVector<WebSocketFrame> frames;
   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kNoFlag, "Hel");
   AppendTo(&frames, WebSocketFrameHeader::kOpCodePing, kFinal);
   AppendTo(&frames, WebSocketFrameHeader::kOpCodeContinuation, kFinal, "lo");
-  WriteFramesStub stub(OK);
+  predictor_->AddFramesToBeInput(frames);
+  WriteFramesStub stub(predictor_, OK);
   CompletionCallback callback;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, WriteFrames(&frames, _))
         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
   }
   ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames, callback));
   const ScopedVector<WebSocketFrame>& frames_passed = *stub.frames();
   ASSERT_EQ(2u, frames_passed.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodePing, frames_passed[0]->header.opcode);
   EXPECT_TRUE(frames_passed[0]->header.final);
   EXPECT_FALSE(frames_passed[0]->header.reserved1);
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[1]->header.opcode);
   EXPECT_TRUE(frames_passed[1]->header.final);
   EXPECT_TRUE(frames_passed[1]->header.reserved1);
   EXPECT_EQ(std::string("\xf2\x48\xcd\xc9\xc9\x07\x00", 7),
             ToString(frames_passed[1]));
 }
 
 TEST_F(WebSocketDeflateStreamTest, WriteEmptyMessage) {
   ScopedVector<WebSocketFrame> frames;
   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kFinal);
-  WriteFramesStub stub(OK);
+  predictor_->AddFramesToBeInput(frames);
+  WriteFramesStub stub(predictor_, OK);
   CompletionCallback callback;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, WriteFrames(&frames, _))
         .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(WebSocketFrameHeader::kOpCodeText, frames_passed[0]->header.opcode);
   EXPECT_TRUE(frames_passed[0]->header.final);
   EXPECT_TRUE(frames_passed[0]->header.reserved1);
   EXPECT_EQ(std::string("\x02\x00", 2), ToString(frames_passed[0]));
 }
 
+TEST_F(WebSocketDeflateStreamTest, WriteUncompressedMessage) {
+  ScopedVector<WebSocketFrame> frames;
+  AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kNoFlag, "AAAA");
+  AppendTo(&frames, WebSocketFrameHeader::kOpCodeContinuation, kFinal, "AAA");
+  predictor_->AddFramesToBeInput(frames);
+  WriteFramesStub stub(predictor_, OK);
+  CompletionCallback callback;
+
+  predictor_->set_result(WebSocketDeflatePredictor::DO_NOT_DEFLATE);
+
+  {
+    InSequence s;
+    EXPECT_CALL(*mock_stream_, WriteFrames(&frames, _))
+        .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
+  }
+  ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames, callback));
+  const ScopedVector<WebSocketFrame>& frames_passed = *stub.frames();
+  ASSERT_EQ(2u, frames_passed.size());
+  EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[0]->header.opcode);
+  EXPECT_FALSE(frames_passed[0]->header.final);
+  EXPECT_FALSE(frames_passed[0]->header.reserved1);
+  EXPECT_EQ("AAAA", ToString(frames_passed[0]));
+  EXPECT_EQ(WebSocketFrameHeader::kOpCodeContinuation,
+            frames_passed[1]->header.opcode);
+  EXPECT_TRUE(frames_passed[1]->header.final);
+  EXPECT_FALSE(frames_passed[1]->header.reserved1);
+  EXPECT_EQ("AAA", ToString(frames_passed[1]));
+}
+
 TEST_F(WebSocketDeflateStreamTest, LargeDeflatedFramesShouldBeSplit) {
   WebSocketDeflater deflater(WebSocketDeflater::TAKE_OVER_CONTEXT);
   LinearCongruentialGenerator lcg(133);
-  WriteFramesStub stub(OK);
+  WriteFramesStub stub(predictor_, OK);
   CompletionCallback callback;
   const size_t size = 1024;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, WriteFrames(_, _))
         .WillRepeatedly(Invoke(&stub, &WriteFramesStub::Call));
   }
   ScopedVector<WebSocketFrame> total_compressed_frames;
 
   deflater.Initialize(kWindowBits);
   while (true) {
     bool is_final = (total_compressed_frames.size() >= 2);
     ScopedVector<WebSocketFrame> frames;
     std::string data;
     for (size_t i = 0; i < size; ++i)
       data += static_cast<char>(lcg.Generate());
     deflater.AddBytes(data.data(), data.size());
     FrameFlag flag = is_final ? kFinal : kNoFlag;
     AppendTo(&frames, WebSocketFrameHeader::kOpCodeBinary, flag, data);
+    predictor_->AddFramesToBeInput(frames);
     ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames, callback));
-    for (size_t i = 0; i < stub.frames()->size(); ++i)
-      total_compressed_frames.push_back((*stub.frames())[i]);
+    total_compressed_frames.insert(total_compressed_frames.end(),
+                                   stub.frames()->begin(),
+                                   stub.frames()->end());
     stub.frames()->weak_clear();
     if (is_final)
       break;
   }
   deflater.Finish();
   std::string total_deflated;
   for (size_t i = 0; i < total_compressed_frames.size(); ++i) {
     WebSocketFrame* frame = total_compressed_frames[i];
     const WebSocketFrameHeader& header = frame->header;
     if (i > 0) {
@@ skipping 10 matching lines @@
     total_deflated += ToString(frame);
   }
   EXPECT_EQ(total_deflated,
             ToString(deflater.GetOutput(deflater.CurrentOutputSize())));
 }
 
 TEST_F(WebSocketDeflateStreamTest, WriteMultipleMessages) {
   ScopedVector<WebSocketFrame> frames;
   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kFinal, "Hello");
   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kFinal, "Hello");
-  WriteFramesStub stub(OK);
+  predictor_->AddFramesToBeInput(frames);
+  WriteFramesStub stub(predictor_, OK);
   CompletionCallback callback;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, WriteFrames(&frames, _))
         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
   }
   ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames, callback));
   const ScopedVector<WebSocketFrame>& frames_passed = *stub.frames();
   ASSERT_EQ(2u, frames_passed.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[0]->header.opcode);
   EXPECT_TRUE(frames_passed[0]->header.final);
   EXPECT_TRUE(frames_passed[0]->header.reserved1);
   EXPECT_EQ(std::string("\xf2\x48\xcd\xc9\xc9\x07\x00", 7),
             ToString(frames_passed[0]));
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[1]->header.opcode);
   EXPECT_TRUE(frames_passed[1]->header.final);
   EXPECT_TRUE(frames_passed[1]->header.reserved1);
   EXPECT_EQ(std::string("\xf2\x00\x11\x00\x00", 5), ToString(frames_passed[1]));
 }
 
 TEST_F(WebSocketDeflateStreamWithDoNotTakeOverContextTest,
        WriteMultipleMessages) {
   ScopedVector<WebSocketFrame> frames;
   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kFinal, "Hello");
   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kFinal, "Hello");
-  WriteFramesStub stub(OK);
+  predictor_->AddFramesToBeInput(frames);
+  WriteFramesStub stub(predictor_, OK);
   CompletionCallback callback;
 
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, WriteFrames(&frames, _))
         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
   }
   ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames, callback));
   const ScopedVector<WebSocketFrame>& frames_passed = *stub.frames();
   ASSERT_EQ(2u, frames_passed.size());
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[0]->header.opcode);
   EXPECT_TRUE(frames_passed[0]->header.final);
   EXPECT_TRUE(frames_passed[0]->header.reserved1);
   EXPECT_EQ(std::string("\xf2\x48\xcd\xc9\xc9\x07\x00", 7),
             ToString(frames_passed[0]));
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[1]->header.opcode);
   EXPECT_TRUE(frames_passed[1]->header.final);
   EXPECT_TRUE(frames_passed[1]->header.reserved1);
   EXPECT_EQ(std::string("\xf2\x48\xcd\xc9\xc9\x07\x00", 7),
             ToString(frames_passed[1]));
 }
 
+// In order to check the stream works correctly for multiple
+// "PossiblyCompressedMessage"s, we test various messages at one test case.
+TEST_F(WebSocketDeflateStreamWithDoNotTakeOverContextTest,
+       WritePossiblyCompressMessages) {
+  ScopedVector<WebSocketFrame> frames;
+  AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kNoFlag, "He");
+  AppendTo(&frames, WebSocketFrameHeader::kOpCodeContinuation, kFinal, "llo");
+  AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kNoFlag, "AAAAAAAAAA");
+  AppendTo(&frames, WebSocketFrameHeader::kOpCodeContinuation, kFinal, "AA");
+  AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kNoFlag, "XX");
+  AppendTo(&frames, WebSocketFrameHeader::kOpCodeContinuation, kFinal, "YY");
+  predictor_->AddFramesToBeInput(frames);
+  WriteFramesStub stub(predictor_, OK);
+  CompletionCallback callback;
+  predictor_->set_result(WebSocketDeflatePredictor::TRY_DEFLATE);
+
+  {
+    InSequence s;
+    EXPECT_CALL(*mock_stream_, WriteFrames(&frames, _))
+        .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
+  }
+  ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames, callback));
+  const ScopedVector<WebSocketFrame>& frames_passed = *stub.frames();
+  ASSERT_EQ(5u, frames_passed.size());
+
+  EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[0]->header.opcode);
+  EXPECT_FALSE(frames_passed[0]->header.final);
+  EXPECT_FALSE(frames_passed[0]->header.reserved1);
+  EXPECT_EQ("He", ToString(frames_passed[0]));
+  EXPECT_EQ(WebSocketFrameHeader::kOpCodeContinuation,
+            frames_passed[1]->header.opcode);
+  EXPECT_TRUE(frames_passed[1]->header.final);
+  EXPECT_FALSE(frames_passed[1]->header.reserved1);
+  EXPECT_EQ("llo", ToString(frames_passed[1]));
+
+  EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[2]->header.opcode);
+  EXPECT_TRUE(frames_passed[2]->header.final);
+  EXPECT_TRUE(frames_passed[2]->header.reserved1);
+  EXPECT_EQ(std::string("\x72\x74\x44\x00\x00\x00", 6),
+            ToString(frames_passed[2]));
+
+  EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[3]->header.opcode);
+  EXPECT_FALSE(frames_passed[3]->header.final);
+  EXPECT_FALSE(frames_passed[3]->header.reserved1);
+  EXPECT_EQ("XX", ToString(frames_passed[3]));
+  EXPECT_EQ(WebSocketFrameHeader::kOpCodeContinuation,
+            frames_passed[4]->header.opcode);
+  EXPECT_TRUE(frames_passed[4]->header.final);
+  EXPECT_FALSE(frames_passed[4]->header.reserved1);
+  EXPECT_EQ("YY", ToString(frames_passed[4]));
+}
+
 }  // namespace
 
 }  // namespace net