src/net/websockets/websocket_deflate_stream_test.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/websockets/websocket_deflate_stream.h"
   6
   7 #include <stdint.h>
   8 #include <deque>
   9 #include <string>
  10
  11 #include "base/basictypes.h"
  12 #include "base/bind.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/memory/scoped_vector.h"
  16 #include "net/base/completion_callback.h"
  17 #include "net/base/io_buffer.h"
  18 #include "net/base/net_errors.h"
  19 #include "net/websockets/websocket_deflate_predictor.h"
  20 #include "net/websockets/websocket_deflater.h"
  21 #include "net/websockets/websocket_frame.h"
  22 #include "net/websockets/websocket_inflater.h"
  23 #include "net/websockets/websocket_stream.h"
  24 #include "net/websockets/websocket_test_util.h"
  25 #include "testing/gmock/include/gmock/gmock.h"
  26 #include "testing/gtest/include/gtest/gtest.h"
  27
  28 namespace net {
  29 namespace {
  30
  31 typedef ::testing::MockFunction<void(int)> MockCallback;  // NOLINT
  32 using ::testing::_;
  33 using ::testing::InSequence;
  34 using ::testing::Invoke;
  35 using ::testing::Return;
  36
  37 typedef uint32_t FrameFlag;
  38 const FrameFlag kNoFlag = 0;
  39 const FrameFlag kFinal = 1;
  40 const FrameFlag kReserved1 = 2;
  41 // We don't define values for other flags because we don't need them.
  42
  43 // The value must equal to the value of the corresponding
  44 // constant in websocket_deflate_stream.cc
  45 const size_t kChunkSize = 4 * 1024;
  46 const int kWindowBits = 15;
  47
  48 scoped_refptr<IOBuffer> ToIOBuffer(const std::string& s) {
  49   scoped_refptr<IOBuffer> buffer = new IOBuffer(s.size());
  50   memcpy(buffer->data(), s.data(), s.size());
  51   return buffer;
  52 }
  53
  54 std::string ToString(IOBufferWithSize* buffer) {
  55   return std::string(buffer->data(), buffer->size());
  56 }
  57
  58 std::string ToString(const scoped_refptr<IOBufferWithSize>& buffer) {
  59   return ToString(buffer.get());
  60 }
  61
  62 std::string ToString(IOBuffer* buffer, size_t size) {
  63   return std::string(buffer->data(), size);
  64 }
  65
  66 std::string ToString(const scoped_refptr<IOBuffer>& buffer, size_t size) {
  67   return ToString(buffer.get(), size);
  68 }
  69
  70 std::string ToString(const WebSocketFrame* frame) {
  71   return frame->data.get() ? ToString(frame->data, frame->header.payload_length)
  72                            : "";
  73 }
  74
  75 void AppendTo(ScopedVector<WebSocketFrame>* frames,
  76               WebSocketFrameHeader::OpCode opcode,
  77               FrameFlag flag,
  78               const std::string& data) {
  79   scoped_ptr<WebSocketFrame> frame(new WebSocketFrame(opcode));
  80   frame->header.final = (flag & kFinal);
  81   frame->header.reserved1 = (flag & kReserved1);
  82   frame->data = ToIOBuffer(data);
  83   frame->header.payload_length = data.size();
  84   frames->push_back(frame.release());
  85 }
  86
  87 void AppendTo(ScopedVector<WebSocketFrame>* frames,
  88               WebSocketFrameHeader::OpCode opcode,
  89               FrameFlag flag) {
  90   scoped_ptr<WebSocketFrame> frame(new WebSocketFrame(opcode));
  91   frame->header.final = (flag & kFinal);
  92   frame->header.reserved1 = (flag & kReserved1);
  93   frames->push_back(frame.release());
  94 }
  95
  96 class MockWebSocketStream : public WebSocketStream {
  97  public:
  98   MOCK_METHOD2(ReadFrames, int(ScopedVector<WebSocketFrame>*,
  99                                const CompletionCallback&));
 100   MOCK_METHOD2(WriteFrames, int(ScopedVector<WebSocketFrame>*,
 101                                 const CompletionCallback&));
 102   MOCK_METHOD0(Close, void());
 103   MOCK_CONST_METHOD0(GetSubProtocol, std::string());
 104   MOCK_CONST_METHOD0(GetExtensions, std::string());
 105 };
 106
 107 // This mock class relies on some assumptions.
 108 //  - RecordInputDataFrame is called after the corresponding WriteFrames
 109 //    call.
 110 //  - RecordWrittenDataFrame is called before writing the frame.
 111 class WebSocketDeflatePredictorMock : public WebSocketDeflatePredictor {
 112  public:
 113   WebSocketDeflatePredictorMock() : result_(DEFLATE) {}
 114   virtual ~WebSocketDeflatePredictorMock() {
 115     // Verify whether all expectaions are consumed.
 116     if (!frames_to_be_input_.empty()) {
 117       ADD_FAILURE() << "There are missing frames to be input.";
 118       return;
 119     }
 120     if (!frames_written_.empty()) {
 121       ADD_FAILURE() << "There are extra written frames.";
 122       return;
 123     }
 124   }
 125
 126   // WebSocketDeflatePredictor functions.
 127   virtual Result Predict(const ScopedVector<WebSocketFrame>& frames,
 128                          size_t frame_index) OVERRIDE {
 129     return result_;
 130   }
 131   virtual void RecordInputDataFrame(const WebSocketFrame* frame) OVERRIDE {
 132     if (!WebSocketFrameHeader::IsKnownDataOpCode(frame->header.opcode)) {
 133       ADD_FAILURE() << "Control frames should not be recorded.";
 134       return;
 135     }
 136     if (frame->header.reserved1) {
 137       ADD_FAILURE() << "Input frame may not be compressed.";
 138       return;
 139     }
 140     if (frames_to_be_input_.empty()) {
 141       ADD_FAILURE() << "Unexpected input data frame";
 142       return;
 143     }
 144     if (frame != frames_to_be_input_.front()) {
 145       ADD_FAILURE() << "Input data frame does not match the expectation.";
 146       return;
 147     }
 148     frames_to_be_input_.pop_front();
 149   }
 150   virtual void RecordWrittenDataFrame(const WebSocketFrame* frame) OVERRIDE {
 151     if (!WebSocketFrameHeader::IsKnownDataOpCode(frame->header.opcode)) {
 152       ADD_FAILURE() << "Control frames should not be recorded.";
 153       return;
 154     }
 155     frames_written_.push_back(frame);
 156   }
 157
 158   // Sets |result_| for the |Predict| return value.
 159   void set_result(Result result) { result_ = result; }
 160
 161   // Adds |frame| as an expectation of future |RecordInputDataFrame| call.
 162   void AddFrameToBeInput(const WebSocketFrame* frame) {
 163     if (!WebSocketFrameHeader::IsKnownDataOpCode(frame->header.opcode))
 164       return;
 165     frames_to_be_input_.push_back(frame);
 166   }
 167   // Verifies that |frame| is recorded in order.
 168   void VerifySentFrame(const WebSocketFrame* frame) {
 169     if (!WebSocketFrameHeader::IsKnownDataOpCode(frame->header.opcode))
 170       return;
 171     if (frames_written_.empty()) {
 172       ADD_FAILURE() << "There are missing frames to be written.";
 173       return;
 174     }
 175     if (frame != frames_written_.front()) {
 176       ADD_FAILURE() << "Written data frame does not match the expectation.";
 177       return;
 178     }
 179     frames_written_.pop_front();
 180   }
 181   void AddFramesToBeInput(const ScopedVector<WebSocketFrame>& frames) {
 182     for (size_t i = 0; i < frames.size(); ++i)
 183       AddFrameToBeInput(frames[i]);
 184   }
 185   void VerifySentFrames(const ScopedVector<WebSocketFrame>& frames) {
 186     for (size_t i = 0; i < frames.size(); ++i)
 187       VerifySentFrame(frames[i]);
 188   }
 189   // Call this method in order to disable checks in the destructor when
 190   // WriteFrames fails.
 191   void Clear() {
 192     frames_to_be_input_.clear();
 193     frames_written_.clear();
 194   }
 195
 196  private:
 197   Result result_;
 198   // Data frames which will be recorded by |RecordInputFrames|.
 199   // Pushed by |AddFrameToBeInput| and popped and verified by
 200   // |RecordInputFrames|.
 201   std::deque<const WebSocketFrame*> frames_to_be_input_;
 202   // Data frames recorded by |RecordWrittenFrames|.
 203   // Pushed by |RecordWrittenFrames| and popped and verified by
 204   // |VerifySentFrame|.
 205   std::deque<const WebSocketFrame*> frames_written_;
 206
 207   DISALLOW_COPY_AND_ASSIGN(WebSocketDeflatePredictorMock);
 208 };
 209
 210 class WebSocketDeflateStreamTest : public ::testing::Test {
 211  public:
 212   WebSocketDeflateStreamTest()
 213       : mock_stream_(NULL),
 214         predictor_(NULL) {}
 215   virtual ~WebSocketDeflateStreamTest() {}
 216
 217   virtual void SetUp() {
 218     Initialize(WebSocketDeflater::TAKE_OVER_CONTEXT, kWindowBits);
 219   }
 220
 221  protected:
 222   // Initialize deflate_stream_ with the given parameters.
 223   void Initialize(WebSocketDeflater::ContextTakeOverMode mode,
 224                   int window_bits) {
 225     mock_stream_ = new testing::StrictMock<MockWebSocketStream>;
 226     predictor_ = new WebSocketDeflatePredictorMock;
 227     deflate_stream_.reset(new WebSocketDeflateStream(
 228         scoped_ptr<WebSocketStream>(mock_stream_),
 229         mode,
 230         window_bits,
 231         scoped_ptr<WebSocketDeflatePredictor>(predictor_)));
 232   }
 233
 234   scoped_ptr<WebSocketDeflateStream> deflate_stream_;
 235   // Owned by |deflate_stream_|.
 236   MockWebSocketStream* mock_stream_;
 237   // Owned by |deflate_stream_|.
 238   WebSocketDeflatePredictorMock* predictor_;
 239 };
 240
 241 // Since WebSocketDeflater with DoNotTakeOverContext is well tested at
 242 // websocket_deflater_test.cc, we have only a few tests for this configuration
 243 // here.
 244 class WebSocketDeflateStreamWithDoNotTakeOverContextTest
 245     : public WebSocketDeflateStreamTest {
 246  public:
 247   WebSocketDeflateStreamWithDoNotTakeOverContextTest() {}
 248   virtual ~WebSocketDeflateStreamWithDoNotTakeOverContextTest() {}
 249
 250   virtual void SetUp() {
 251     Initialize(WebSocketDeflater::DO_NOT_TAKE_OVER_CONTEXT, kWindowBits);
 252   }
 253 };
 254
 255 class WebSocketDeflateStreamWithClientWindowBitsTest
 256     : public WebSocketDeflateStreamTest {
 257  public:
 258   WebSocketDeflateStreamWithClientWindowBitsTest() {}
 259   virtual ~WebSocketDeflateStreamWithClientWindowBitsTest() {}
 260
 261   // Overridden to postpone the call to Initialize().
 262   virtual void SetUp() {}
 263
 264   // This needs to be called explicitly from the tests.
 265   void SetUpWithWindowBits(int window_bits) {
 266     Initialize(WebSocketDeflater::TAKE_OVER_CONTEXT, window_bits);
 267   }
 268
 269   // Add a frame which will be compressed to a smaller size if the window
 270   // size is large enough.
 271   void AddCompressibleFrameString() {
 272     const std::string word = "Chromium";
 273     const std::string payload = word + std::string(256, 'a') + word;
 274     AppendTo(&frames_, WebSocketFrameHeader::kOpCodeText, kFinal, payload);
 275     predictor_->AddFramesToBeInput(frames_);
 276   }
 277
 278  protected:
 279   ScopedVector<WebSocketFrame> frames_;
 280 };
 281
 282 // ReadFrameStub is a stub for WebSocketStream::ReadFrames.
 283 // It returns |result_| and |frames_to_output_| to the caller and
 284 // saves parameters to |frames_passed_| and |callback_|.
 285 class ReadFramesStub {
 286  public:
 287   explicit ReadFramesStub(int result) : result_(result) {}
 288
 289   ReadFramesStub(int result, ScopedVector<WebSocketFrame>* frames_to_output)
 290       : result_(result) {
 291     frames_to_output_.swap(*frames_to_output);
 292   }
 293
 294   int Call(ScopedVector<WebSocketFrame>* frames,
 295            const CompletionCallback& callback) {
 296     DCHECK(frames->empty());
 297     frames_passed_ = frames;
 298     callback_ = callback;
 299     frames->swap(frames_to_output_);
 300     return result_;
 301   }
 302
 303   int result() const { return result_; }
 304   const CompletionCallback callback() const { return callback_; }
 305   ScopedVector<WebSocketFrame>* frames_passed() {
 306     return frames_passed_;
 307   }
 308
 309  private:
 310   int result_;
 311   CompletionCallback callback_;
 312   ScopedVector<WebSocketFrame> frames_to_output_;
 313   ScopedVector<WebSocketFrame>* frames_passed_;
 314 };
 315
 316 // WriteFramesStub is a stub for WebSocketStream::WriteFrames.
 317 // It returns |result_| and |frames_| to the caller and
 318 // saves |callback| parameter to |callback_|.
 319 class WriteFramesStub {
 320  public:
 321   explicit WriteFramesStub(WebSocketDeflatePredictorMock* predictor,
 322                            int result)
 323       : result_(result), predictor_(predictor) {}
 324
 325   int Call(ScopedVector<WebSocketFrame>* frames,
 326            const CompletionCallback& callback) {
 327     frames_.insert(frames_.end(), frames->begin(), frames->end());
 328     frames->weak_clear();
 329     callback_ = callback;
 330     predictor_->VerifySentFrames(frames_);
 331     return result_;
 332   }
 333
 334   int result() const { return result_; }
 335   const CompletionCallback callback() const { return callback_; }
 336   ScopedVector<WebSocketFrame>* frames() { return &frames_; }
 337
 338  private:
 339   int result_;
 340   CompletionCallback callback_;
 341   ScopedVector<WebSocketFrame> frames_;
 342   WebSocketDeflatePredictorMock* predictor_;
 343 };
 344
 345 TEST_F(WebSocketDeflateStreamTest, ReadFailedImmediately) {
 346   ScopedVector<WebSocketFrame> frames;
 347   CompletionCallback callback;
 348   {
 349     InSequence s;
 350     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
 351         .WillOnce(Return(ERR_FAILED));
 352   }
 353   EXPECT_EQ(ERR_FAILED, deflate_stream_->ReadFrames(&frames, callback));
 354 }
 355
 356 TEST_F(WebSocketDeflateStreamTest, ReadUncompressedFrameImmediately) {
 357   ScopedVector<WebSocketFrame> frames_to_output;
 358   AppendTo(&frames_to_output,
 359            WebSocketFrameHeader::kOpCodeText,
 360            kFinal,
 361            "hello");
 362   ReadFramesStub stub(OK, &frames_to_output);
 363   ScopedVector<WebSocketFrame> frames;
 364
 365   {
 366     InSequence s;
 367     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
 368         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
 369   }
 370   CompletionCallback callback;
 371   ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
 372   ASSERT_EQ(1u, frames.size());
 373   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
 374   EXPECT_TRUE(frames[0]->header.final);
 375   EXPECT_FALSE(frames[0]->header.reserved1);
 376   EXPECT_EQ("hello", ToString(frames[0]));
 377 }
 378
 379 TEST_F(WebSocketDeflateStreamTest, ReadUncompressedFrameAsync) {
 380   ReadFramesStub stub(ERR_IO_PENDING);
 381   ScopedVector<WebSocketFrame> frames;
 382   MockCallback mock_callback, checkpoint;
 383   CompletionCallback callback =
 384       base::Bind(&MockCallback::Call, base::Unretained(&mock_callback));
 385
 386   {
 387     InSequence s;
 388     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
 389         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
 390     EXPECT_CALL(checkpoint, Call(0));
 391     EXPECT_CALL(mock_callback, Call(OK));
 392   }
 393   ASSERT_EQ(ERR_IO_PENDING, deflate_stream_->ReadFrames(&frames, callback));
 394   ASSERT_EQ(0u, frames.size());
 395
 396   checkpoint.Call(0);
 397
 398   AppendTo(stub.frames_passed(),
 399            WebSocketFrameHeader::kOpCodeText,
 400            kFinal,
 401            "hello");
 402   stub.callback().Run(OK);
 403   ASSERT_EQ(1u, frames.size());
 404   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
 405   EXPECT_TRUE(frames[0]->header.final);
 406   EXPECT_FALSE(frames[0]->header.reserved1);
 407   EXPECT_EQ("hello", ToString(frames[0]));
 408 }
 409
 410 TEST_F(WebSocketDeflateStreamTest, ReadFailedAsync) {
 411   ReadFramesStub stub(ERR_IO_PENDING);
 412   ScopedVector<WebSocketFrame> frames;
 413   MockCallback mock_callback, checkpoint;
 414   CompletionCallback callback =
 415       base::Bind(&MockCallback::Call, base::Unretained(&mock_callback));
 416
 417   {
 418     InSequence s;
 419     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
 420         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
 421     EXPECT_CALL(checkpoint, Call(0));
 422     EXPECT_CALL(mock_callback, Call(ERR_FAILED));
 423   }
 424   ASSERT_EQ(ERR_IO_PENDING, deflate_stream_->ReadFrames(&frames, callback));
 425   ASSERT_EQ(0u, frames.size());
 426
 427   checkpoint.Call(0);
 428
 429   AppendTo(stub.frames_passed(),
 430            WebSocketFrameHeader::kOpCodeText,
 431            kFinal,
 432            "hello");
 433   stub.callback().Run(ERR_FAILED);
 434   ASSERT_EQ(0u, frames.size());
 435 }
 436
 437 TEST_F(WebSocketDeflateStreamTest, ReadCompressedFrameImmediately) {
 438   ScopedVector<WebSocketFrame> frames_to_output;
 439   AppendTo(&frames_to_output,
 440            WebSocketFrameHeader::kOpCodeText,
 441            kFinal | kReserved1,
 442            std::string("\xf2\x48\xcd\xc9\xc9\x07\x00", 7));
 443   ReadFramesStub stub(OK, &frames_to_output);
 444   CompletionCallback callback;
 445   ScopedVector<WebSocketFrame> frames;
 446   {
 447     InSequence s;
 448     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
 449         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
 450   }
 451   ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
 452   ASSERT_EQ(1u, frames.size());
 453   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
 454   EXPECT_TRUE(frames[0]->header.final);
 455   EXPECT_FALSE(frames[0]->header.reserved1);
 456   EXPECT_EQ("Hello", ToString(frames[0]));
 457 }
 458
 459 TEST_F(WebSocketDeflateStreamTest, ReadCompressedFrameAsync) {
 460   ReadFramesStub stub(ERR_IO_PENDING);
 461   MockCallback mock_callback, checkpoint;
 462   CompletionCallback callback =
 463       base::Bind(&MockCallback::Call, base::Unretained(&mock_callback));
 464   ScopedVector<WebSocketFrame> frames;
 465   {
 466     InSequence s;
 467     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
 468         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
 469     EXPECT_CALL(checkpoint, Call(0));
 470     EXPECT_CALL(mock_callback, Call(OK));
 471   }
 472   ASSERT_EQ(ERR_IO_PENDING, deflate_stream_->ReadFrames(&frames, callback));
 473
 474   checkpoint.Call(0);
 475
 476   AppendTo(stub.frames_passed(),
 477            WebSocketFrameHeader::kOpCodeText,
 478            kFinal | kReserved1,
 479            std::string("\xf2\x48\xcd\xc9\xc9\x07\x00", 7));
 480   stub.callback().Run(OK);
 481
 482   ASSERT_EQ(1u, frames.size());
 483   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
 484   EXPECT_TRUE(frames[0]->header.final);
 485   EXPECT_FALSE(frames[0]->header.reserved1);
 486   EXPECT_EQ("Hello", ToString(frames[0]));
 487 }
 488
 489 TEST_F(WebSocketDeflateStreamTest,
 490        ReadCompressedFrameFragmentImmediatelyButInflaterReturnsPending) {
 491   ScopedVector<WebSocketFrame> frames_to_output;
 492   const std::string data1("\xf2", 1);
 493   const std::string data2("\x48\xcd\xc9\xc9\x07\x00", 6);
 494   AppendTo(&frames_to_output,
 495            WebSocketFrameHeader::kOpCodeText,
 496            kReserved1,
 497            data1);
 498   ReadFramesStub stub1(OK, &frames_to_output), stub2(ERR_IO_PENDING);
 499   MockCallback mock_callback, checkpoint;
 500   CompletionCallback callback =
 501       base::Bind(&MockCallback::Call, base::Unretained(&mock_callback));
 502   ScopedVector<WebSocketFrame> frames;
 503
 504   {
 505     InSequence s;
 506     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
 507         .WillOnce(Invoke(&stub1, &ReadFramesStub::Call))
 508         .WillOnce(Invoke(&stub2, &ReadFramesStub::Call));
 509     EXPECT_CALL(checkpoint, Call(0));
 510     EXPECT_CALL(mock_callback, Call(OK));
 511   }
 512   ASSERT_EQ(ERR_IO_PENDING, deflate_stream_->ReadFrames(&frames, callback));
 513   ASSERT_EQ(0u, frames.size());
 514
 515   AppendTo(stub2.frames_passed(),
 516            WebSocketFrameHeader::kOpCodeText,
 517            kFinal,
 518            data2);
 519
 520   checkpoint.Call(0);
 521   stub2.callback().Run(OK);
 522
 523   ASSERT_EQ(1u, frames.size());
 524   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
 525   EXPECT_TRUE(frames[0]->header.final);
 526   EXPECT_FALSE(frames[0]->header.reserved1);
 527   EXPECT_EQ("Hello", ToString(frames[0]));
 528 }
 529
 530 TEST_F(WebSocketDeflateStreamTest, ReadInvalidCompressedPayload) {
 531   const std::string data("\xf2\x48\xcdINVALID", 10);
 532   ScopedVector<WebSocketFrame> frames_to_output;
 533   AppendTo(&frames_to_output,
 534            WebSocketFrameHeader::kOpCodeText,
 535            kFinal | kReserved1,
 536            data);
 537   ReadFramesStub stub(OK, &frames_to_output);
 538   CompletionCallback callback;
 539   ScopedVector<WebSocketFrame> frames;
 540
 541   {
 542     InSequence s;
 543     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
 544         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
 545   }
 546   ASSERT_EQ(ERR_WS_PROTOCOL_ERROR,
 547             deflate_stream_->ReadFrames(&frames, callback));
 548   ASSERT_EQ(0u, frames.size());
 549 }
 550
 551 TEST_F(WebSocketDeflateStreamTest, MergeMultipleFramesInReadFrames) {
 552   const std::string data1("\xf2\x48\xcd", 3);
 553   const std::string data2("\xc9\xc9\x07\x00", 4);
 554   ScopedVector<WebSocketFrame> frames_to_output;
 555   AppendTo(&frames_to_output,
 556            WebSocketFrameHeader::kOpCodeText,
 557            kReserved1,
 558            data1);
 559   AppendTo(&frames_to_output,
 560            WebSocketFrameHeader::kOpCodeContinuation,
 561            kFinal,
 562            data2);
 563   ReadFramesStub stub(OK, &frames_to_output);
 564   CompletionCallback callback;
 565   ScopedVector<WebSocketFrame> frames;
 566
 567   {
 568     InSequence s;
 569     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
 570         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
 571   }
 572   ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
 573   ASSERT_EQ(1u, frames.size());
 574   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
 575   EXPECT_TRUE(frames[0]->header.final);
 576   EXPECT_FALSE(frames[0]->header.reserved1);
 577   EXPECT_EQ("Hello", ToString(frames[0]));
 578 }
 579
 580 TEST_F(WebSocketDeflateStreamTest, ReadUncompressedEmptyFrames) {
 581   ScopedVector<WebSocketFrame> frames_to_output;
 582   AppendTo(&frames_to_output,
 583            WebSocketFrameHeader::kOpCodeText,
 584            kNoFlag);
 585   AppendTo(&frames_to_output,
 586            WebSocketFrameHeader::kOpCodeContinuation,
 587            kFinal);
 588   ReadFramesStub stub(OK, &frames_to_output);
 589   CompletionCallback callback;
 590   ScopedVector<WebSocketFrame> frames;
 591
 592   {
 593     InSequence s;
 594     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
 595         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
 596   }
 597   ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
 598   ASSERT_EQ(2u, frames.size());
 599   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
 600   EXPECT_FALSE(frames[0]->header.final);
 601   EXPECT_FALSE(frames[0]->header.reserved1);
 602   EXPECT_EQ("", ToString(frames[0]));
 603   EXPECT_EQ(WebSocketFrameHeader::kOpCodeContinuation,
 604             frames[1]->header.opcode);
 605   EXPECT_TRUE(frames[1]->header.final);
 606   EXPECT_FALSE(frames[1]->header.reserved1);
 607   EXPECT_EQ("", ToString(frames[1]));
 608 }
 609
 610 TEST_F(WebSocketDeflateStreamTest, ReadCompressedEmptyFrames) {
 611   ScopedVector<WebSocketFrame> frames_to_output;
 612   AppendTo(&frames_to_output,
 613            WebSocketFrameHeader::kOpCodeText,
 614            kReserved1,
 615            std::string("\x02\x00", 1));
 616   AppendTo(&frames_to_output,
 617            WebSocketFrameHeader::kOpCodeContinuation,
 618            kFinal);
 619   ReadFramesStub stub(OK, &frames_to_output);
 620   CompletionCallback callback;
 621   ScopedVector<WebSocketFrame> frames;
 622
 623   {
 624     InSequence s;
 625     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
 626         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
 627   }
 628   ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
 629   ASSERT_EQ(1u, frames.size());
 630   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
 631   EXPECT_TRUE(frames[0]->header.final);
 632   EXPECT_FALSE(frames[0]->header.reserved1);
 633   EXPECT_EQ("", ToString(frames[0]));
 634 }
 635
 636 TEST_F(WebSocketDeflateStreamTest,
 637        ReadCompressedFrameFollowedByEmptyFrame) {
 638   const std::string data("\xf2\x48\xcd\xc9\xc9\x07\x00", 7);
 639   ScopedVector<WebSocketFrame> frames_to_output;
 640   AppendTo(&frames_to_output,
 641            WebSocketFrameHeader::kOpCodeText,
 642            kReserved1,
 643            data);
 644   AppendTo(&frames_to_output,
 645            WebSocketFrameHeader::kOpCodeContinuation,
 646            kFinal);
 647   ReadFramesStub stub(OK, &frames_to_output);
 648   CompletionCallback callback;
 649   ScopedVector<WebSocketFrame> frames;
 650
 651   {
 652     InSequence s;
 653     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
 654         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
 655   }
 656   ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
 657   ASSERT_EQ(1u, frames.size());
 658   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
 659   EXPECT_TRUE(frames[0]->header.final);
 660   EXPECT_FALSE(frames[0]->header.reserved1);
 661   EXPECT_EQ("Hello", ToString(frames[0]));
 662 }
 663
 664 TEST_F(WebSocketDeflateStreamTest, ReadControlFrameBetweenDataFrames) {
 665   const std::string data1("\xf2\x48\xcd", 3);
 666   const std::string data2("\xc9\xc9\x07\x00", 4);
 667   ScopedVector<WebSocketFrame> frames_to_output;
 668   AppendTo(&frames_to_output,
 669            WebSocketFrameHeader::kOpCodeText,
 670            kReserved1,
 671            data1);
 672   AppendTo(&frames_to_output, WebSocketFrameHeader::kOpCodePing, kFinal);
 673   AppendTo(&frames_to_output, WebSocketFrameHeader::kOpCodeText, kFinal, data2);
 674   ReadFramesStub stub(OK, &frames_to_output);
 675   CompletionCallback callback;
 676   ScopedVector<WebSocketFrame> frames;
 677
 678   {
 679     InSequence s;
 680     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
 681         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
 682   }
 683   ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
 684   ASSERT_EQ(2u, frames.size());
 685   EXPECT_EQ(WebSocketFrameHeader::kOpCodePing, frames[0]->header.opcode);
 686   EXPECT_TRUE(frames[0]->header.final);
 687   EXPECT_FALSE(frames[0]->header.reserved1);
 688   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[1]->header.opcode);
 689   EXPECT_TRUE(frames[1]->header.final);
 690   EXPECT_FALSE(frames[1]->header.reserved1);
 691   EXPECT_EQ("Hello", ToString(frames[1]));
 692 }
 693
 694 TEST_F(WebSocketDeflateStreamTest, SplitToMultipleFramesInReadFrames) {
 695   WebSocketDeflater deflater(WebSocketDeflater::TAKE_OVER_CONTEXT);
 696   deflater.Initialize(kWindowBits);
 697   const size_t kSize = kChunkSize * 3;
 698   const std::string original_data(kSize, 'a');
 699   deflater.AddBytes(original_data.data(), original_data.size());
 700   deflater.Finish();
 701
 702   ScopedVector<WebSocketFrame> frames_to_output;
 703   AppendTo(&frames_to_output,
 704            WebSocketFrameHeader::kOpCodeBinary,
 705            kFinal | kReserved1,
 706            ToString(deflater.GetOutput(deflater.CurrentOutputSize())));
 707
 708   ReadFramesStub stub(OK, &frames_to_output);
 709   CompletionCallback callback;
 710   ScopedVector<WebSocketFrame> frames;
 711   {
 712     InSequence s;
 713     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
 714         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
 715   }
 716
 717   ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
 718   ASSERT_EQ(3u, frames.size());
 719   EXPECT_EQ(WebSocketFrameHeader::kOpCodeBinary, frames[0]->header.opcode);
 720   EXPECT_FALSE(frames[0]->header.final);
 721   EXPECT_FALSE(frames[0]->header.reserved1);
 722   EXPECT_EQ(kChunkSize, static_cast<size_t>(frames[0]->header.payload_length));
 723   EXPECT_EQ(WebSocketFrameHeader::kOpCodeContinuation,
 724             frames[1]->header.opcode);
 725   EXPECT_FALSE(frames[1]->header.final);
 726   EXPECT_FALSE(frames[1]->header.reserved1);
 727   EXPECT_EQ(kChunkSize, static_cast<size_t>(frames[1]->header.payload_length));
 728   EXPECT_EQ(WebSocketFrameHeader::kOpCodeContinuation,
 729             frames[2]->header.opcode);
 730   EXPECT_TRUE(frames[2]->header.final);
 731   EXPECT_FALSE(frames[2]->header.reserved1);
 732   EXPECT_EQ(kChunkSize, static_cast<size_t>(frames[2]->header.payload_length));
 733   EXPECT_EQ(original_data,
 734             ToString(frames[0]) + ToString(frames[1]) + ToString(frames[2]));
 735 }
 736
 737 TEST_F(WebSocketDeflateStreamTest, InflaterInternalDataCanBeEmpty) {
 738   WebSocketDeflater deflater(WebSocketDeflater::TAKE_OVER_CONTEXT);
 739   deflater.Initialize(kWindowBits);
 740   const std::string original_data(kChunkSize, 'a');
 741   deflater.AddBytes(original_data.data(), original_data.size());
 742   deflater.Finish();
 743
 744   ScopedVector<WebSocketFrame> frames_to_output;
 745   AppendTo(&frames_to_output,
 746            WebSocketFrameHeader::kOpCodeBinary,
 747            kReserved1,
 748            ToString(deflater.GetOutput(deflater.CurrentOutputSize())));
 749   AppendTo(&frames_to_output,
 750            WebSocketFrameHeader::kOpCodeBinary,
 751            kFinal,
 752            "");
 753
 754   ReadFramesStub stub(OK, &frames_to_output);
 755   CompletionCallback callback;
 756   ScopedVector<WebSocketFrame> frames;
 757   {
 758     InSequence s;
 759     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
 760         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
 761   }
 762
 763   ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
 764   ASSERT_EQ(2u, frames.size());
 765   EXPECT_EQ(WebSocketFrameHeader::kOpCodeBinary, frames[0]->header.opcode);
 766   EXPECT_FALSE(frames[0]->header.final);
 767   EXPECT_FALSE(frames[0]->header.reserved1);
 768   EXPECT_EQ(kChunkSize, static_cast<size_t>(frames[0]->header.payload_length));
 769
 770   EXPECT_EQ(WebSocketFrameHeader::kOpCodeContinuation,
 771             frames[1]->header.opcode);
 772   EXPECT_TRUE(frames[1]->header.final);
 773   EXPECT_FALSE(frames[1]->header.reserved1);
 774   EXPECT_EQ(0u, static_cast<size_t>(frames[1]->header.payload_length));
 775   EXPECT_EQ(original_data, ToString(frames[0]) + ToString(frames[1]));
 776 }
 777
 778 TEST_F(WebSocketDeflateStreamTest,
 779        Reserved1TurnsOnDuringReadingCompressedContinuationFrame) {
 780   const std::string data1("\xf2\x48\xcd", 3);
 781   const std::string data2("\xc9\xc9\x07\x00", 4);
 782   ScopedVector<WebSocketFrame> frames_to_output;
 783   AppendTo(&frames_to_output,
 784            WebSocketFrameHeader::kOpCodeText,
 785            kReserved1,
 786            data1);
 787   AppendTo(&frames_to_output,
 788            WebSocketFrameHeader::kOpCodeContinuation,
 789            kFinal | kReserved1,
 790            data2);
 791   ReadFramesStub stub(OK, &frames_to_output);
 792   CompletionCallback callback;
 793   ScopedVector<WebSocketFrame> frames;
 794
 795   {
 796     InSequence s;
 797     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
 798         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
 799   }
 800   ASSERT_EQ(ERR_WS_PROTOCOL_ERROR,
 801             deflate_stream_->ReadFrames(&frames, callback));
 802 }
 803
 804 TEST_F(WebSocketDeflateStreamTest,
 805        Reserved1TurnsOnDuringReadingUncompressedContinuationFrame) {
 806   ScopedVector<WebSocketFrame> frames_to_output;
 807   AppendTo(&frames_to_output,
 808            WebSocketFrameHeader::kOpCodeText,
 809            kNoFlag,
 810            "hello");
 811   AppendTo(&frames_to_output,
 812            WebSocketFrameHeader::kOpCodeContinuation,
 813            kFinal | kReserved1,
 814            "world");
 815   ReadFramesStub stub(OK, &frames_to_output);
 816   CompletionCallback callback;
 817   ScopedVector<WebSocketFrame> frames;
 818
 819   {
 820     InSequence s;
 821     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
 822         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
 823   }
 824   ASSERT_EQ(ERR_WS_PROTOCOL_ERROR,
 825             deflate_stream_->ReadFrames(&frames, callback));
 826 }
 827
 828 TEST_F(WebSocketDeflateStreamTest, ReadCompressedMessages) {
 829   ScopedVector<WebSocketFrame> frames_to_output;
 830   AppendTo(&frames_to_output,
 831            WebSocketFrameHeader::kOpCodeText,
 832            kFinal | kReserved1,
 833            std::string(
 834                "\x4a\xce\xcf\x2d\x28\x4a\x2d\x2e\x4e\x4d\x31\x04\x00", 13));
 835   AppendTo(&frames_to_output,
 836            WebSocketFrameHeader::kOpCodeText,
 837            kFinal | kReserved1,
 838            std::string("\x4a\x86\x33\x8d\x00\x00", 6));
 839   ReadFramesStub stub(OK, &frames_to_output);
 840   CompletionCallback callback;
 841   ScopedVector<WebSocketFrame> frames;
 842
 843   {
 844     InSequence s;
 845     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
 846         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
 847   }
 848   ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
 849   ASSERT_EQ(2u, frames.size());
 850   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
 851   EXPECT_TRUE(frames[0]->header.final);
 852   EXPECT_FALSE(frames[0]->header.reserved1);
 853   EXPECT_EQ("compressed1", ToString(frames[0]));
 854   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[1]->header.opcode);
 855   EXPECT_TRUE(frames[1]->header.final);
 856   EXPECT_FALSE(frames[1]->header.reserved1);
 857   EXPECT_EQ("compressed2", ToString(frames[1]));
 858 }
 859
 860 TEST_F(WebSocketDeflateStreamTest, ReadUncompressedMessages) {
 861   ScopedVector<WebSocketFrame> frames_to_output;
 862   AppendTo(&frames_to_output,
 863            WebSocketFrameHeader::kOpCodeText,
 864            kFinal,
 865            "uncompressed1");
 866   AppendTo(&frames_to_output,
 867            WebSocketFrameHeader::kOpCodeText,
 868            kFinal,
 869            "uncompressed2");
 870   ReadFramesStub stub(OK, &frames_to_output);
 871   CompletionCallback callback;
 872   ScopedVector<WebSocketFrame> frames;
 873
 874   {
 875     InSequence s;
 876     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
 877         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
 878   }
 879   ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
 880   ASSERT_EQ(2u, frames.size());
 881   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
 882   EXPECT_TRUE(frames[0]->header.final);
 883   EXPECT_FALSE(frames[0]->header.reserved1);
 884   EXPECT_EQ("uncompressed1", ToString(frames[0]));
 885   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[1]->header.opcode);
 886   EXPECT_TRUE(frames[1]->header.final);
 887   EXPECT_FALSE(frames[1]->header.reserved1);
 888   EXPECT_EQ("uncompressed2", ToString(frames[1]));
 889 }
 890
 891 TEST_F(WebSocketDeflateStreamTest,
 892        ReadCompressedMessageThenUncompressedMessage) {
 893   ScopedVector<WebSocketFrame> frames_to_output;
 894   AppendTo(&frames_to_output,
 895            WebSocketFrameHeader::kOpCodeText,
 896            kFinal | kReserved1,
 897            std::string(
 898                "\x4a\xce\xcf\x2d\x28\x4a\x2d\x2e\x4e\x4d\x01\x00", 12));
 899   AppendTo(&frames_to_output,
 900            WebSocketFrameHeader::kOpCodeText,
 901            kFinal,
 902            "uncompressed");
 903   ReadFramesStub stub(OK, &frames_to_output);
 904   CompletionCallback callback;
 905   ScopedVector<WebSocketFrame> frames;
 906
 907   {
 908     InSequence s;
 909     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
 910         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
 911   }
 912   ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
 913   ASSERT_EQ(2u, frames.size());
 914   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
 915   EXPECT_TRUE(frames[0]->header.final);
 916   EXPECT_FALSE(frames[0]->header.reserved1);
 917   EXPECT_EQ("compressed", ToString(frames[0]));
 918   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[1]->header.opcode);
 919   EXPECT_TRUE(frames[1]->header.final);
 920   EXPECT_FALSE(frames[1]->header.reserved1);
 921   EXPECT_EQ("uncompressed", ToString(frames[1]));
 922 }
 923
 924 TEST_F(WebSocketDeflateStreamTest,
 925        ReadUncompressedMessageThenCompressedMessage) {
 926   ScopedVector<WebSocketFrame> frames_to_output;
 927   AppendTo(&frames_to_output,
 928            WebSocketFrameHeader::kOpCodeText,
 929            kFinal,
 930            "uncompressed");
 931   AppendTo(&frames_to_output,
 932            WebSocketFrameHeader::kOpCodeText,
 933            kFinal | kReserved1,
 934            std::string(
 935                "\x4a\xce\xcf\x2d\x28\x4a\x2d\x2e\x4e\x4d\x01\x00", 12));
 936   ReadFramesStub stub(OK, &frames_to_output);
 937   CompletionCallback callback;
 938   ScopedVector<WebSocketFrame> frames;
 939
 940   {
 941     InSequence s;
 942     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
 943         .WillOnce(Invoke(&stub, &ReadFramesStub::Call));
 944   }
 945   ASSERT_EQ(OK, deflate_stream_->ReadFrames(&frames, callback));
 946   ASSERT_EQ(2u, frames.size());
 947   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
 948   EXPECT_TRUE(frames[0]->header.final);
 949   EXPECT_FALSE(frames[0]->header.reserved1);
 950   EXPECT_EQ("uncompressed", ToString(frames[0]));
 951   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[1]->header.opcode);
 952   EXPECT_TRUE(frames[1]->header.final);
 953   EXPECT_FALSE(frames[1]->header.reserved1);
 954   EXPECT_EQ("compressed", ToString(frames[1]));
 955 }
 956
 957 // This is a regression test for crbug.com/343506.
 958 TEST_F(WebSocketDeflateStreamTest, ReadEmptyAsyncFrame) {
 959   ScopedVector<ReadFramesStub> stub_vector;
 960   stub_vector.push_back(new ReadFramesStub(ERR_IO_PENDING));
 961   stub_vector.push_back(new ReadFramesStub(ERR_IO_PENDING));
 962   MockCallback mock_callback;
 963   CompletionCallback callback =
 964       base::Bind(&MockCallback::Call, base::Unretained(&mock_callback));
 965   ScopedVector<WebSocketFrame> frames;
 966
 967   {
 968     InSequence s;
 969     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
 970         .WillOnce(Invoke(stub_vector[0], &ReadFramesStub::Call));
 971
 972     EXPECT_CALL(*mock_stream_, ReadFrames(&frames, _))
 973         .WillOnce(Invoke(stub_vector[1], &ReadFramesStub::Call));
 974
 975     EXPECT_CALL(mock_callback, Call(OK));
 976   }
 977
 978   ASSERT_EQ(ERR_IO_PENDING, deflate_stream_->ReadFrames(&frames, callback));
 979   AppendTo(stub_vector[0]->frames_passed(),
 980            WebSocketFrameHeader::kOpCodeText,
 981            kReserved1,
 982            std::string());
 983   stub_vector[0]->callback().Run(OK);
 984   AppendTo(stub_vector[1]->frames_passed(),
 985            WebSocketFrameHeader::kOpCodeContinuation,
 986            kFinal,
 987            std::string("\x02\x00"));
 988   stub_vector[1]->callback().Run(OK);
 989   ASSERT_EQ(1u, frames.size());
 990   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames[0]->header.opcode);
 991   EXPECT_EQ("", ToString(frames[0]));
 992 }
 993
 994 TEST_F(WebSocketDeflateStreamTest, WriteEmpty) {
 995   ScopedVector<WebSocketFrame> frames;
 996   CompletionCallback callback;
 997   {
 998     InSequence s;
 999     EXPECT_CALL(*mock_stream_, WriteFrames(&frames, _)).Times(0);
1000   }
1001   EXPECT_EQ(OK, deflate_stream_->WriteFrames(&frames, callback));
1002 }
1003
1004 TEST_F(WebSocketDeflateStreamTest, WriteFailedImmediately) {
1005   ScopedVector<WebSocketFrame> frames;
1006   CompletionCallback callback;
1007   {
1008     InSequence s;
1009     EXPECT_CALL(*mock_stream_, WriteFrames(&frames, _))
1010         .WillOnce(Return(ERR_FAILED));
1011   }
1012
1013   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kFinal, "hello");
1014   predictor_->AddFramesToBeInput(frames);
1015   EXPECT_EQ(ERR_FAILED, deflate_stream_->WriteFrames(&frames, callback));
1016   predictor_->Clear();
1017 }
1018
1019 TEST_F(WebSocketDeflateStreamTest, WriteFrameImmediately) {
1020   ScopedVector<WebSocketFrame> frames;
1021   CompletionCallback callback;
1022   WriteFramesStub stub(predictor_, OK);
1023   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kFinal, "Hello");
1024   predictor_->AddFramesToBeInput(frames);
1025   {
1026     InSequence s;
1027     EXPECT_CALL(*mock_stream_, WriteFrames(_, _))
1028         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
1029   }
1030   ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames, callback));
1031   const ScopedVector<WebSocketFrame>& frames_passed = *stub.frames();
1032   ASSERT_EQ(1u, frames_passed.size());
1033   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[0]->header.opcode);
1034   EXPECT_TRUE(frames_passed[0]->header.final);
1035   EXPECT_TRUE(frames_passed[0]->header.reserved1);
1036   EXPECT_EQ(std::string("\xf2\x48\xcd\xc9\xc9\x07\x00", 7),
1037             ToString(frames_passed[0]));
1038 }
1039
1040 TEST_F(WebSocketDeflateStreamTest, WriteFrameAsync) {
1041   WriteFramesStub stub(predictor_, ERR_IO_PENDING);
1042   MockCallback mock_callback, checkpoint;
1043   CompletionCallback callback =
1044       base::Bind(&MockCallback::Call, base::Unretained(&mock_callback));
1045   ScopedVector<WebSocketFrame> frames;
1046   {
1047     InSequence s;
1048     EXPECT_CALL(*mock_stream_, WriteFrames(&frames, _))
1049         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
1050     EXPECT_CALL(checkpoint, Call(0));
1051     EXPECT_CALL(mock_callback, Call(OK));
1052   }
1053   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kFinal, "Hello");
1054   predictor_->AddFramesToBeInput(frames);
1055   ASSERT_EQ(ERR_IO_PENDING, deflate_stream_->WriteFrames(&frames, callback));
1056
1057   checkpoint.Call(0);
1058   stub.callback().Run(OK);
1059
1060   const ScopedVector<WebSocketFrame>& frames_passed = *stub.frames();
1061   ASSERT_EQ(1u, frames_passed.size());
1062   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[0]->header.opcode);
1063   EXPECT_TRUE(frames_passed[0]->header.final);
1064   EXPECT_TRUE(frames_passed[0]->header.reserved1);
1065   EXPECT_EQ(std::string("\xf2\x48\xcd\xc9\xc9\x07\x00", 7),
1066             ToString(frames_passed[0]));
1067 }
1068
1069 TEST_F(WebSocketDeflateStreamTest, WriteControlFrameBetweenDataFrames) {
1070   ScopedVector<WebSocketFrame> frames;
1071   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kNoFlag, "Hel");
1072   AppendTo(&frames, WebSocketFrameHeader::kOpCodePing, kFinal);
1073   AppendTo(&frames, WebSocketFrameHeader::kOpCodeContinuation, kFinal, "lo");
1074   predictor_->AddFramesToBeInput(frames);
1075   WriteFramesStub stub(predictor_, OK);
1076   CompletionCallback callback;
1077
1078   {
1079     InSequence s;
1080     EXPECT_CALL(*mock_stream_, WriteFrames(&frames, _))
1081         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
1082   }
1083   ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames, callback));
1084   const ScopedVector<WebSocketFrame>& frames_passed = *stub.frames();
1085   ASSERT_EQ(2u, frames_passed.size());
1086   EXPECT_EQ(WebSocketFrameHeader::kOpCodePing, frames_passed[0]->header.opcode);
1087   EXPECT_TRUE(frames_passed[0]->header.final);
1088   EXPECT_FALSE(frames_passed[0]->header.reserved1);
1089   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[1]->header.opcode);
1090   EXPECT_TRUE(frames_passed[1]->header.final);
1091   EXPECT_TRUE(frames_passed[1]->header.reserved1);
1092   EXPECT_EQ(std::string("\xf2\x48\xcd\xc9\xc9\x07\x00", 7),
1093             ToString(frames_passed[1]));
1094 }
1095
1096 TEST_F(WebSocketDeflateStreamTest, WriteEmptyMessage) {
1097   ScopedVector<WebSocketFrame> frames;
1098   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kFinal);
1099   predictor_->AddFramesToBeInput(frames);
1100   WriteFramesStub stub(predictor_, OK);
1101   CompletionCallback callback;
1102
1103   {
1104     InSequence s;
1105     EXPECT_CALL(*mock_stream_, WriteFrames(&frames, _))
1106         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
1107   }
1108   ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames, callback));
1109   const ScopedVector<WebSocketFrame>& frames_passed = *stub.frames();
1110   ASSERT_EQ(1u, frames_passed.size());
1111   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[0]->header.opcode);
1112   EXPECT_TRUE(frames_passed[0]->header.final);
1113   EXPECT_TRUE(frames_passed[0]->header.reserved1);
1114   EXPECT_EQ(std::string("\x00", 1), ToString(frames_passed[0]));
1115 }
1116
1117 TEST_F(WebSocketDeflateStreamTest, WriteUncompressedMessage) {
1118   ScopedVector<WebSocketFrame> frames;
1119   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kNoFlag, "AAAA");
1120   AppendTo(&frames, WebSocketFrameHeader::kOpCodeContinuation, kFinal, "AAA");
1121   predictor_->AddFramesToBeInput(frames);
1122   WriteFramesStub stub(predictor_, OK);
1123   CompletionCallback callback;
1124
1125   predictor_->set_result(WebSocketDeflatePredictor::DO_NOT_DEFLATE);
1126
1127   {
1128     InSequence s;
1129     EXPECT_CALL(*mock_stream_, WriteFrames(&frames, _))
1130         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
1131   }
1132   ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames, callback));
1133   const ScopedVector<WebSocketFrame>& frames_passed = *stub.frames();
1134   ASSERT_EQ(2u, frames_passed.size());
1135   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[0]->header.opcode);
1136   EXPECT_FALSE(frames_passed[0]->header.final);
1137   EXPECT_FALSE(frames_passed[0]->header.reserved1);
1138   EXPECT_EQ("AAAA", ToString(frames_passed[0]));
1139   EXPECT_EQ(WebSocketFrameHeader::kOpCodeContinuation,
1140             frames_passed[1]->header.opcode);
1141   EXPECT_TRUE(frames_passed[1]->header.final);
1142   EXPECT_FALSE(frames_passed[1]->header.reserved1);
1143   EXPECT_EQ("AAA", ToString(frames_passed[1]));
1144 }
1145
1146 TEST_F(WebSocketDeflateStreamTest, LargeDeflatedFramesShouldBeSplit) {
1147   WebSocketDeflater deflater(WebSocketDeflater::TAKE_OVER_CONTEXT);
1148   LinearCongruentialGenerator lcg(133);
1149   WriteFramesStub stub(predictor_, OK);
1150   CompletionCallback callback;
1151   const size_t size = 1024;
1152
1153   {
1154     InSequence s;
1155     EXPECT_CALL(*mock_stream_, WriteFrames(_, _))
1156         .WillRepeatedly(Invoke(&stub, &WriteFramesStub::Call));
1157   }
1158   ScopedVector<WebSocketFrame> total_compressed_frames;
1159
1160   deflater.Initialize(kWindowBits);
1161   while (true) {
1162     bool is_final = (total_compressed_frames.size() >= 2);
1163     ScopedVector<WebSocketFrame> frames;
1164     std::string data;
1165     for (size_t i = 0; i < size; ++i)
1166       data += static_cast<char>(lcg.Generate());
1167     deflater.AddBytes(data.data(), data.size());
1168     FrameFlag flag = is_final ? kFinal : kNoFlag;
1169     AppendTo(&frames, WebSocketFrameHeader::kOpCodeBinary, flag, data);
1170     predictor_->AddFramesToBeInput(frames);
1171     ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames, callback));
1172     total_compressed_frames.insert(total_compressed_frames.end(),
1173                                    stub.frames()->begin(),
1174                                    stub.frames()->end());
1175     stub.frames()->weak_clear();
1176     if (is_final)
1177       break;
1178   }
1179   deflater.Finish();
1180   std::string total_deflated;
1181   for (size_t i = 0; i < total_compressed_frames.size(); ++i) {
1182     WebSocketFrame* frame = total_compressed_frames[i];
1183     const WebSocketFrameHeader& header = frame->header;
1184     if (i > 0) {
1185       EXPECT_EQ(header.kOpCodeContinuation, header.opcode);
1186       EXPECT_FALSE(header.reserved1);
1187     } else {
1188       EXPECT_EQ(header.kOpCodeBinary, header.opcode);
1189       EXPECT_TRUE(header.reserved1);
1190     }
1191     const bool is_final_frame = (i + 1 == total_compressed_frames.size());
1192     EXPECT_EQ(is_final_frame, header.final);
1193     if (!is_final_frame)
1194       EXPECT_GT(header.payload_length, 0ul);
1195     total_deflated += ToString(frame);
1196   }
1197   EXPECT_EQ(total_deflated,
1198             ToString(deflater.GetOutput(deflater.CurrentOutputSize())));
1199 }
1200
1201 TEST_F(WebSocketDeflateStreamTest, WriteMultipleMessages) {
1202   ScopedVector<WebSocketFrame> frames;
1203   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kFinal, "Hello");
1204   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kFinal, "Hello");
1205   predictor_->AddFramesToBeInput(frames);
1206   WriteFramesStub stub(predictor_, OK);
1207   CompletionCallback callback;
1208
1209   {
1210     InSequence s;
1211     EXPECT_CALL(*mock_stream_, WriteFrames(&frames, _))
1212         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
1213   }
1214   ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames, callback));
1215   const ScopedVector<WebSocketFrame>& frames_passed = *stub.frames();
1216   ASSERT_EQ(2u, frames_passed.size());
1217   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[0]->header.opcode);
1218   EXPECT_TRUE(frames_passed[0]->header.final);
1219   EXPECT_TRUE(frames_passed[0]->header.reserved1);
1220   EXPECT_EQ(std::string("\xf2\x48\xcd\xc9\xc9\x07\x00", 7),
1221             ToString(frames_passed[0]));
1222   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[1]->header.opcode);
1223   EXPECT_TRUE(frames_passed[1]->header.final);
1224   EXPECT_TRUE(frames_passed[1]->header.reserved1);
1225   EXPECT_EQ(std::string("\xf2\x00\x11\x00\x00", 5), ToString(frames_passed[1]));
1226 }
1227
1228 TEST_F(WebSocketDeflateStreamWithDoNotTakeOverContextTest,
1229        WriteMultipleMessages) {
1230   ScopedVector<WebSocketFrame> frames;
1231   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kFinal, "Hello");
1232   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kFinal, "Hello");
1233   predictor_->AddFramesToBeInput(frames);
1234   WriteFramesStub stub(predictor_, OK);
1235   CompletionCallback callback;
1236
1237   {
1238     InSequence s;
1239     EXPECT_CALL(*mock_stream_, WriteFrames(&frames, _))
1240         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
1241   }
1242   ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames, callback));
1243   const ScopedVector<WebSocketFrame>& frames_passed = *stub.frames();
1244   ASSERT_EQ(2u, frames_passed.size());
1245   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[0]->header.opcode);
1246   EXPECT_TRUE(frames_passed[0]->header.final);
1247   EXPECT_TRUE(frames_passed[0]->header.reserved1);
1248   EXPECT_EQ(std::string("\xf2\x48\xcd\xc9\xc9\x07\x00", 7),
1249             ToString(frames_passed[0]));
1250   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[1]->header.opcode);
1251   EXPECT_TRUE(frames_passed[1]->header.final);
1252   EXPECT_TRUE(frames_passed[1]->header.reserved1);
1253   EXPECT_EQ(std::string("\xf2\x48\xcd\xc9\xc9\x07\x00", 7),
1254             ToString(frames_passed[1]));
1255 }
1256
1257 // In order to check the stream works correctly for multiple
1258 // "PossiblyCompressedMessage"s, we test various messages at one test case.
1259 TEST_F(WebSocketDeflateStreamWithDoNotTakeOverContextTest,
1260        WritePossiblyCompressMessages) {
1261   ScopedVector<WebSocketFrame> frames;
1262   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kNoFlag, "He");
1263   AppendTo(&frames, WebSocketFrameHeader::kOpCodeContinuation, kFinal, "llo");
1264   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kNoFlag, "AAAAAAAAAA");
1265   AppendTo(&frames, WebSocketFrameHeader::kOpCodeContinuation, kFinal, "AA");
1266   AppendTo(&frames, WebSocketFrameHeader::kOpCodeText, kNoFlag, "XX");
1267   AppendTo(&frames, WebSocketFrameHeader::kOpCodeContinuation, kFinal, "YY");
1268   predictor_->AddFramesToBeInput(frames);
1269   WriteFramesStub stub(predictor_, OK);
1270   CompletionCallback callback;
1271   predictor_->set_result(WebSocketDeflatePredictor::TRY_DEFLATE);
1272
1273   {
1274     InSequence s;
1275     EXPECT_CALL(*mock_stream_, WriteFrames(&frames, _))
1276         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
1277   }
1278   ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames, callback));
1279   const ScopedVector<WebSocketFrame>& frames_passed = *stub.frames();
1280   ASSERT_EQ(5u, frames_passed.size());
1281
1282   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[0]->header.opcode);
1283   EXPECT_FALSE(frames_passed[0]->header.final);
1284   EXPECT_FALSE(frames_passed[0]->header.reserved1);
1285   EXPECT_EQ("He", ToString(frames_passed[0]));
1286   EXPECT_EQ(WebSocketFrameHeader::kOpCodeContinuation,
1287             frames_passed[1]->header.opcode);
1288   EXPECT_TRUE(frames_passed[1]->header.final);
1289   EXPECT_FALSE(frames_passed[1]->header.reserved1);
1290   EXPECT_EQ("llo", ToString(frames_passed[1]));
1291
1292   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[2]->header.opcode);
1293   EXPECT_TRUE(frames_passed[2]->header.final);
1294   EXPECT_TRUE(frames_passed[2]->header.reserved1);
1295   EXPECT_EQ(std::string("\x72\x74\x44\x00\x00\x00", 6),
1296             ToString(frames_passed[2]));
1297
1298   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_passed[3]->header.opcode);
1299   EXPECT_FALSE(frames_passed[3]->header.final);
1300   EXPECT_FALSE(frames_passed[3]->header.reserved1);
1301   EXPECT_EQ("XX", ToString(frames_passed[3]));
1302   EXPECT_EQ(WebSocketFrameHeader::kOpCodeContinuation,
1303             frames_passed[4]->header.opcode);
1304   EXPECT_TRUE(frames_passed[4]->header.final);
1305   EXPECT_FALSE(frames_passed[4]->header.reserved1);
1306   EXPECT_EQ("YY", ToString(frames_passed[4]));
1307 }
1308
1309 // This is based on the similar test from websocket_deflater_test.cc
1310 TEST_F(WebSocketDeflateStreamWithClientWindowBitsTest, WindowBits8) {
1311   SetUpWithWindowBits(8);
1312   CompletionCallback callback;
1313   AddCompressibleFrameString();
1314   WriteFramesStub stub(predictor_, OK);
1315   {
1316     InSequence s;
1317     EXPECT_CALL(*mock_stream_, WriteFrames(_, _))
1318         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
1319   }
1320   ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames_, callback));
1321   const ScopedVector<WebSocketFrame>& frames_passed = *stub.frames();
1322   ASSERT_EQ(1u, frames_passed.size());
1323   EXPECT_EQ(std::string("r\xce(\xca\xcf\xcd,\xcdM\x1c\xe1\xc0\x39\xa3"
1324                         "(?7\xb3\x34\x17\x00", 21),
1325             ToString(frames_passed[0]));
1326 }
1327
1328 // The same input with window_bits=10 returns smaller output.
1329 TEST_F(WebSocketDeflateStreamWithClientWindowBitsTest, WindowBits10) {
1330   SetUpWithWindowBits(10);
1331   CompletionCallback callback;
1332   AddCompressibleFrameString();
1333   WriteFramesStub stub(predictor_, OK);
1334   {
1335     InSequence s;
1336     EXPECT_CALL(*mock_stream_, WriteFrames(_, _))
1337         .WillOnce(Invoke(&stub, &WriteFramesStub::Call));
1338   }
1339   ASSERT_EQ(OK, deflate_stream_->WriteFrames(&frames_, callback));
1340   const ScopedVector<WebSocketFrame>& frames_passed = *stub.frames();
1341   ASSERT_EQ(1u, frames_passed.size());
1342   EXPECT_EQ(
1343       std::string("r\xce(\xca\xcf\xcd,\xcdM\x1c\xe1\xc0\x19\x1a\x0e\0\0", 17),
1344       ToString(frames_passed[0]));
1345 }
1346
1347 }  // namespace
1348
1349 }  // namespace net