Clear reserved flags on synthetic continuations.

net/websockets/websocket_basic_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.
 //
 // Tests for WebSocketBasicStream. Note that we do not attempt to verify that
 // frame parsing itself functions correctly, as that is covered by the
 // WebSocketFrameParser tests.
 
 #include "net/websockets/websocket_basic_stream.h"
 
@@ skipping 810 matching lines @@
     size_t expected_payload_size = kReadBufferSize;
     if (frame == 0) {
       expected_payload_size = kReadBufferSize - kLargeFrameHeaderSize;
     } else if (frame == kExpectedFrameCount - 1) {
       expected_payload_size = kLargeFrameHeaderSize;
     }
     EXPECT_EQ(expected_payload_size, frames_[0]->header.payload_length);
   }
 }
 
+// A frame with reserved flag(s) set that arrives in chunks should only have the
+// reserved flag(s) set on the first chunk when split.
+TEST_F(WebSocketBasicStreamSocketChunkedReadTest, ReservedFlagCleared) {
+  static const char kReservedFlagFrame[] = "\x41\x05Hello";
+  const size_t kReservedFlagFrameSize = arraysize(kReservedFlagFrame) - 1;
+  const size_t kChunkSize = 5;
+
+  CreateChunkedRead(ASYNC,
+                    kReservedFlagFrame,
+                    kReservedFlagFrameSize,
+                    kChunkSize,
+                    2,
+                    LAST_FRAME_BIG);
+
+  TestCompletionCallback cb[2];
+  ASSERT_EQ(ERR_IO_PENDING, stream_->ReadFrames(&frames_, cb[0].callback()));
+  EXPECT_EQ(OK, cb[0].WaitForResult());
+  ASSERT_EQ(1U, frames_.size());
+  EXPECT_TRUE(frames_[0]->header.reserved1);
+
+  frames_.clear();
+  ASSERT_EQ(ERR_IO_PENDING, stream_->ReadFrames(&frames_, cb[1].callback()));
+  EXPECT_EQ(OK, cb[1].WaitForResult());
+  ASSERT_EQ(1U, frames_.size());
+  EXPECT_FALSE(frames_[0]->header.reserved1);
+}
+
 // Check that writing a frame all at once works.
 TEST_F(WebSocketBasicStreamSocketWriteTest, WriteAtOnce) {
   MockWrite writes[] = {MockWrite(SYNCHRONOUS, kWriteFrame, kWriteFrameSize)};
   CreateWriteOnly(writes);
 
   EXPECT_EQ(OK, stream_->WriteFrames(&frames_, cb_.callback()));
 }
 
 // Check that completely async writing works.
 TEST_F(WebSocketBasicStreamSocketWriteTest, AsyncWriteAtOnce) {
@@ skipping 68 matching lines @@
 
 TEST_F(WebSocketBasicStreamSocketTest, GetSubProtocolWorks) {
   sub_protocol_ = "cyberchat";
   CreateNullStream();
 
   EXPECT_EQ("cyberchat", stream_->GetSubProtocol());
 }
 
 }  // namespace
 }  // namespace net