[WebSocket] Incoming close frame should not overtake data frames

net/websockets/websocket_channel_test.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/websockets/websocket_channel.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <string.h>
 #include <iostream>
@@ skipping 734 matching lines @@
         base::Bind(&ArgumentCopyingWebSocketStreamCreator::Create,
                    base::Unretained(&connect_data_.creator)));
   }
 
   // Same as CreateChannelAndConnect(), but calls the on_success callback as
   // well. This method is virtual so that subclasses can also set the stream.
   virtual void CreateChannelAndConnectSuccessfully() {
     CreateChannelAndConnect();
     // Most tests aren't concerned with flow control from the renderer, so allow
     // MAX_INT quota units.
-    channel_->SendFlowControl(kPlentyOfQuota);
+    EXPECT_EQ(CHANNEL_ALIVE, channel_->SendFlowControl(kPlentyOfQuota));
     connect_data_.creator.connect_delegate->OnSuccess(std::move(stream_));
   }
 
   // Returns a WebSocketEventInterface to be passed to the WebSocketChannel.
   // This implementation returns a newly-created fake. Subclasses may return a
   // mock instead.
   virtual scoped_ptr<WebSocketEventInterface> CreateEventInterface() {
     return scoped_ptr<WebSocketEventInterface>(new FakeWebSocketEventInterface);
   }
 
@@ skipping 203 matching lines @@
 };
 
 // Fixture for tests which test use of receive quota from the renderer.
 class WebSocketChannelFlowControlTest
     : public WebSocketChannelEventInterfaceTest {
  protected:
   // Tests using this fixture should use CreateChannelAndConnectWithQuota()
   // instead of CreateChannelAndConnectSuccessfully().
   void CreateChannelAndConnectWithQuota(int64_t quota) {
     CreateChannelAndConnect();
-    channel_->SendFlowControl(quota);
+    EXPECT_EQ(CHANNEL_ALIVE, channel_->SendFlowControl(quota));
     connect_data_.creator.connect_delegate->OnSuccess(std::move(stream_));
   }
 
   virtual void CreateChannelAndConnectSuccesfully() { NOTREACHED(); }
 };
 
 // Fixture for tests which test UTF-8 validation of received Text frames using a
 // mock WebSocketStream.
 class WebSocketChannelReceiveUtf8Test : public WebSocketChannelStreamTest {
  public:
@@ skipping 22 matching lines @@
   EXPECT_EQ(connect_data_.requested_subprotocols,
             actual.requested_subprotocols);
   EXPECT_EQ(connect_data_.origin.Serialize(), actual.origin.Serialize());
 }
 
 // Verify that calling SendFlowControl before the connection is established does
 // not cause a crash.
 TEST_F(WebSocketChannelTest, SendFlowControlDuringHandshakeOkay) {
   CreateChannelAndConnect();
   ASSERT_TRUE(channel_);
-  channel_->SendFlowControl(65536);
+  ASSERT_EQ(CHANNEL_ALIVE, channel_->SendFlowControl(65536));
 }
 
 // Any WebSocketEventInterface methods can delete the WebSocketChannel and
 // return CHANNEL_DELETED. The WebSocketChannelDeletingTests are intended to
 // verify that there are no use-after-free bugs when this happens. Problems will
 // probably only be found when running under Address Sanitizer or a similar
 // tool.
 TEST_F(WebSocketChannelDeletingTest, OnAddChannelResponseFail) {
   CreateChannelAndConnect();
   EXPECT_TRUE(channel_);
@@ skipping 794 matching lines @@
   {
     InSequence s;
     EXPECT_CALL(*event_interface_, OnAddChannelResponse(_, _));
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
     EXPECT_CALL(*event_interface_,
                 OnDropChannel(true, kWebSocketNormalClosure, "Fred"));
   }
 
   CreateChannelAndConnectSuccessfully();
 
-  channel_->StartClosingHandshake(kWebSocketNormalClosure, "Fred");
+  ASSERT_EQ(CHANNEL_ALIVE,
+            channel_->StartClosingHandshake(kWebSocketNormalClosure, "Fred"));
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 // StartClosingHandshake() also works before connection completes, and calls
 // OnDropChannel.
 TEST_F(WebSocketChannelEventInterfaceTest, CloseDuringConnection) {
   EXPECT_CALL(*event_interface_,
               OnDropChannel(false, kWebSocketErrorAbnormalClosure, ""));
 
   CreateChannelAndConnect();
-  channel_->StartClosingHandshake(kWebSocketNormalClosure, "Joe");
+  ASSERT_EQ(CHANNEL_DELETED,
+            channel_->StartClosingHandshake(kWebSocketNormalClosure, "Joe"));
 }
 
 // OnDropChannel() is only called once when a write() on the socket triggers a
 // connection reset.
 TEST_F(WebSocketChannelEventInterfaceTest, OnDropChannelCalledOnce) {
   set_stream(make_scoped_ptr(new ResetOnWriteFakeWebSocketStream));
   EXPECT_CALL(*event_interface_, OnAddChannelResponse(_, _));
   EXPECT_CALL(*event_interface_, OnFlowControl(_));
 
   EXPECT_CALL(*event_interface_,
@@ skipping 282 matching lines @@
         .WillOnce(InvokeClosureReturnDeleted(completion.closure()));
   }
   CreateChannelAndConnectSuccessfully();
   // OneShotTimer is not very friendly to testing; there is no apparent way to
   // set an expectation on it. Instead the tests need to infer that the timeout
   // was fired by the behaviour of the WebSocketChannel object.
   channel_->SetClosingHandshakeTimeoutForTesting(
       TimeDelta::FromMilliseconds(kVeryTinyTimeoutMillis));
   channel_->SetUnderlyingConnectionCloseTimeoutForTesting(
       TimeDelta::FromMilliseconds(kVeryBigTimeoutMillis));
-  channel_->StartClosingHandshake(kWebSocketNormalClosure, "");
+  ASSERT_EQ(CHANNEL_ALIVE,
+            channel_->StartClosingHandshake(kWebSocketNormalClosure, ""));
   checkpoint.Call(1);
   completion.WaitForResult();
 }
 
 // The closing handshake times out and sends an OnDropChannel event if a Close
 // message is received but the connection isn't closed by the remote host.
 TEST_F(WebSocketChannelEventInterfaceTest,
        ServerInitiatedClosingHandshakeTimesOut) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
@@ skipping 32 matching lines @@
   {
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
         .WillOnce(Return(ERR_IO_PENDING));
     EXPECT_CALL(checkpoint, Call(2));
   }
 
   set_stream(std::move(mock_stream_));
   CreateChannelAndConnect();
-  channel_->SendFlowControl(kPlentyOfQuota);
+  ASSERT_EQ(CHANNEL_ALIVE, channel_->SendFlowControl(kPlentyOfQuota));
   checkpoint.Call(1);
   connect_data_.creator.connect_delegate->OnSuccess(std::move(stream_));
   checkpoint.Call(2);
 }
 
 // If for some reason the connect succeeds before the renderer sends us quota,
 // we shouldn't call ReadFrames() immediately.
 // TODO(ricea): Actually we should call ReadFrames() with a small limit so we
 // can still handle control frames. This should be done once we have any API to
 // expose quota to the lower levels.
 TEST_F(WebSocketChannelStreamTest, FlowControlLate) {
   Checkpoint checkpoint;
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, GetExtensions()).Times(AnyNumber());
   {
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
         .WillOnce(Return(ERR_IO_PENDING));
     EXPECT_CALL(checkpoint, Call(2));
   }
 
   set_stream(std::move(mock_stream_));
   CreateChannelAndConnect();
   connect_data_.creator.connect_delegate->OnSuccess(std::move(stream_));
   checkpoint.Call(1);
-  channel_->SendFlowControl(kPlentyOfQuota);
+  ASSERT_EQ(CHANNEL_ALIVE, channel_->SendFlowControl(kPlentyOfQuota));
   checkpoint.Call(2);
 }
 
 // We should stop calling ReadFrames() when all quota is used.
 TEST_F(WebSocketChannelStreamTest, FlowControlStopsReadFrames) {
   static const InitFrame frames[] = {
       {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, "FOUR"}};
 
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, GetExtensions()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
       .WillOnce(ReturnFrames(&frames));
 
   set_stream(std::move(mock_stream_));
   CreateChannelAndConnect();
-  channel_->SendFlowControl(4);
+  ASSERT_EQ(CHANNEL_ALIVE, channel_->SendFlowControl(4));
   connect_data_.creator.connect_delegate->OnSuccess(std::move(stream_));
 }
 
 // Providing extra quota causes ReadFrames() to be called again.
 TEST_F(WebSocketChannelStreamTest, FlowControlStartsWithMoreQuota) {
   static const InitFrame frames[] = {
       {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, "FOUR"}};
   Checkpoint checkpoint;
 
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, GetExtensions()).Times(AnyNumber());
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
         .WillOnce(ReturnFrames(&frames));
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
         .WillOnce(Return(ERR_IO_PENDING));
   }
 
   set_stream(std::move(mock_stream_));
   CreateChannelAndConnect();
-  channel_->SendFlowControl(4);
+  ASSERT_EQ(CHANNEL_ALIVE, channel_->SendFlowControl(4));
   connect_data_.creator.connect_delegate->OnSuccess(std::move(stream_));
   checkpoint.Call(1);
-  channel_->SendFlowControl(4);
+  ASSERT_EQ(CHANNEL_ALIVE, channel_->SendFlowControl(4));
 }
 
 // ReadFrames() isn't called again until all pending data has been passed to
 // the renderer.
 TEST_F(WebSocketChannelStreamTest, ReadFramesNotCalledUntilQuotaAvailable) {
   static const InitFrame frames[] = {
       {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, "FOUR"}};
   Checkpoint checkpoint;
 
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, GetExtensions()).Times(AnyNumber());
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
         .WillOnce(ReturnFrames(&frames));
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(checkpoint, Call(2));
     EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
         .WillOnce(Return(ERR_IO_PENDING));
   }
 
   set_stream(std::move(mock_stream_));
   CreateChannelAndConnect();
-  channel_->SendFlowControl(2);
+  ASSERT_EQ(CHANNEL_ALIVE, channel_->SendFlowControl(2));
   connect_data_.creator.connect_delegate->OnSuccess(std::move(stream_));
   checkpoint.Call(1);
-  channel_->SendFlowControl(2);
+  ASSERT_EQ(CHANNEL_ALIVE, channel_->SendFlowControl(2));
   checkpoint.Call(2);
-  channel_->SendFlowControl(2);
+  ASSERT_EQ(CHANNEL_ALIVE, channel_->SendFlowControl(2));
 }
 
 // A message that needs to be split into frames to fit within quota should
 // maintain correct semantics.
 TEST_F(WebSocketChannelFlowControlTest, SingleFrameMessageSplitSync) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
   static const InitFrame frames[] = {
       {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, "FOUR"}};
   stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, frames);
   set_stream(std::move(stream));
   {
     InSequence s;
     EXPECT_CALL(*event_interface_, OnAddChannelResponse(_, _));
     EXPECT_CALL(*event_interface_, OnFlowControl(_));
     EXPECT_CALL(
         *event_interface_,
         OnDataFrame(false, WebSocketFrameHeader::kOpCodeText, AsVector("FO")));
     EXPECT_CALL(
         *event_interface_,
         OnDataFrame(
             false, WebSocketFrameHeader::kOpCodeContinuation, AsVector("U")));
     EXPECT_CALL(
         *event_interface_,
         OnDataFrame(
             true, WebSocketFrameHeader::kOpCodeContinuation, AsVector("R")));
   }
 
   CreateChannelAndConnectWithQuota(2);
-  channel_->SendFlowControl(1);
-  channel_->SendFlowControl(1);
+  ASSERT_EQ(CHANNEL_ALIVE, channel_->SendFlowControl(1));
+  ASSERT_EQ(CHANNEL_ALIVE, channel_->SendFlowControl(1));
 }
 
 // The code path for async messages is slightly different, so test it
 // separately.
 TEST_F(WebSocketChannelFlowControlTest, SingleFrameMessageSplitAsync) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
   static const InitFrame frames[] = {
       {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED, "FOUR"}};
   stream->PrepareReadFrames(ReadableFakeWebSocketStream::ASYNC, OK, frames);
@@ skipping 16 matching lines @@
     EXPECT_CALL(
         *event_interface_,
         OnDataFrame(
             true, WebSocketFrameHeader::kOpCodeContinuation, AsVector("R")));
   }
 
   CreateChannelAndConnectWithQuota(2);
   checkpoint.Call(1);
   base::MessageLoop::current()->RunUntilIdle();
   checkpoint.Call(2);
-  channel_->SendFlowControl(1);
+  ASSERT_EQ(CHANNEL_ALIVE, channel_->SendFlowControl(1));
   checkpoint.Call(3);
-  channel_->SendFlowControl(1);
+  ASSERT_EQ(CHANNEL_ALIVE, channel_->SendFlowControl(1));
 }
 
 // A message split into multiple frames which is further split due to quota
 // restrictions should stil be correct.
 // TODO(ricea): The message ends up split into more frames than are strictly
 // necessary. The complexity/performance tradeoffs here need further
 // examination.
 TEST_F(WebSocketChannelFlowControlTest, MultipleFrameSplit) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
@@ skipping 25 matching lines @@
     EXPECT_CALL(*event_interface_,
                 OnDataFrame(false,
                             WebSocketFrameHeader::kOpCodeContinuation,
                             AsVector("FINAL ")));
     EXPECT_CALL(*event_interface_,
                 OnDataFrame(true,
                             WebSocketFrameHeader::kOpCodeContinuation,
                             AsVector("FRAME IS 24 BYTES.")));
   }
   CreateChannelAndConnectWithQuota(14);
-  channel_->SendFlowControl(43);
-  channel_->SendFlowControl(32);
+  ASSERT_EQ(CHANNEL_ALIVE, channel_->SendFlowControl(43));
+  ASSERT_EQ(CHANNEL_ALIVE, channel_->SendFlowControl(32));
 }
 
 // An empty message handled when we are out of quota must not be delivered
 // out-of-order with respect to other messages.
 TEST_F(WebSocketChannelFlowControlTest, EmptyMessageNoQuota) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
   static const InitFrame frames[] = {
       {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText,
        NOT_MASKED,  "FIRST MESSAGE"},
@@ skipping 19 matching lines @@
                 OnDataFrame(true,
                             WebSocketFrameHeader::kOpCodeText,
                             AsVector("")));
     EXPECT_CALL(*event_interface_,
                 OnDataFrame(true,
                             WebSocketFrameHeader::kOpCodeText,
                             AsVector("THIRD MESSAGE")));
   }
 
   CreateChannelAndConnectWithQuota(6);
-  channel_->SendFlowControl(128);
+  ASSERT_EQ(CHANNEL_ALIVE, channel_->SendFlowControl(128));
+}
+
+// A close frame should not overtake data frames.
+TEST_F(WebSocketChannelFlowControlTest, CloseFrameShouldNotOvertakeDataFrames) {
+  scoped_ptr<ReadableFakeWebSocketStream> stream(
+      new ReadableFakeWebSocketStream);
+  static const InitFrame frames[] = {
+      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED,
+       "FIRST "},
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeContinuation, NOT_MASKED,
+       "MESSAGE"},
+      {NOT_FINAL_FRAME, WebSocketFrameHeader::kOpCodeText, NOT_MASKED,
+       "SECOND "},
+      {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED,
+       CLOSE_DATA(NORMAL_CLOSURE, "GOOD BYE")},
+  };
+  stream->PrepareReadFrames(ReadableFakeWebSocketStream::SYNC, OK, frames);
+  set_stream(std::move(stream));
+  Checkpoint checkpoint;
+  InSequence s;
+  EXPECT_CALL(*event_interface_, OnAddChannelResponse(_, _));
+  EXPECT_CALL(*event_interface_, OnFlowControl(_));
+  EXPECT_CALL(*event_interface_,
+              OnDataFrame(false, WebSocketFrameHeader::kOpCodeText,
+                          AsVector("FIRST ")));
+  EXPECT_CALL(checkpoint, Call(1));
+  EXPECT_CALL(*event_interface_,
+              OnDataFrame(false, WebSocketFrameHeader::kOpCodeContinuation,
+                          AsVector("MESSAG")));
+  EXPECT_CALL(checkpoint, Call(2));
+  EXPECT_CALL(*event_interface_,
+              OnDataFrame(true, WebSocketFrameHeader::kOpCodeContinuation,
+                          AsVector("E")));
+  EXPECT_CALL(
+      *event_interface_,
+      OnDataFrame(false, WebSocketFrameHeader::kOpCodeText, AsVector("SECON")));
+  EXPECT_CALL(checkpoint, Call(3));
+  EXPECT_CALL(*event_interface_,
+              OnDataFrame(false, WebSocketFrameHeader::kOpCodeContinuation,
+                          AsVector("D ")));
+  EXPECT_CALL(*event_interface_, OnClosingHandshake());
+  EXPECT_CALL(checkpoint, Call(4));
+
+  CreateChannelAndConnectWithQuota(6);
+  checkpoint.Call(1);
+  ASSERT_EQ(CHANNEL_ALIVE, channel_->SendFlowControl(6));
+  checkpoint.Call(2);
+  ASSERT_EQ(CHANNEL_ALIVE, channel_->SendFlowControl(6));
+  checkpoint.Call(3);
+  ASSERT_EQ(CHANNEL_ALIVE, channel_->SendFlowControl(6));
+  checkpoint.Call(4);
 }
 
 // RFC6455 5.1 "a client MUST mask all frames that it sends to the server".
 // WebSocketChannel actually only sets the mask bit in the header, it doesn't
 // perform masking itself (not all transports actually use masking).
 TEST_F(WebSocketChannelStreamTest, SentFramesAreMasked) {
   static const InitFrame expected[] = {
       {FINAL_FRAME, WebSocketFrameHeader::kOpCodeText,
        MASKED,      "NEEDS MASKING"}};
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
@@ skipping 13 matching lines @@
   static const InitFrame expected[] = {
       {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
        MASKED,      CLOSE_DATA(NORMAL_CLOSURE, "Success")}};
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, GetExtensions()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _)).WillOnce(Return(ERR_IO_PENDING));
   EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
       .WillOnce(Return(OK));
 
   CreateChannelAndConnectSuccessfully();
-  channel_->StartClosingHandshake(1000, "Success");
+  ASSERT_EQ(CHANNEL_ALIVE, channel_->StartClosingHandshake(1000, "Success"));
   channel_->SendFrame(
       true, WebSocketFrameHeader::kOpCodeText, AsVector("SHOULD  BE IGNORED"));
 }
 
 // RFC6455 5.5.1 "If an endpoint receives a Close frame and did not previously
 // send a Close frame, the endpoint MUST send a Close frame in response."
 TEST_F(WebSocketChannelStreamTest, CloseIsEchoedBack) {
   static const InitFrame frames[] = {
       {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
        NOT_MASKED,  CLOSE_DATA(NORMAL_CLOSURE, "Close")}};
@@ skipping 44 matching lines @@
     EXPECT_CALL(checkpoint, Call(2));
     EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
         .WillOnce(Return(ERR_IO_PENDING));
     EXPECT_CALL(checkpoint, Call(3));
     // WriteFrames() must not be called again. GoogleMock will ensure that the
     // test fails if it is.
   }
 
   CreateChannelAndConnectSuccessfully();
   checkpoint.Call(1);
-  channel_->StartClosingHandshake(kWebSocketNormalClosure, "Close");
+  ASSERT_EQ(CHANNEL_ALIVE,
+            channel_->StartClosingHandshake(kWebSocketNormalClosure, "Close"));
   checkpoint.Call(2);
 
   *frames = CreateFrameVector(frames_init);
   read_callback.Run(OK);
   checkpoint.Call(3);
 }
 
 // Invalid close status codes should not be sent on the network.
 TEST_F(WebSocketChannelStreamTest, InvalidCloseStatusCodeNotSent) {
   static const InitFrame expected[] = {
       {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
        MASKED,      CLOSE_DATA(SERVER_ERROR, "")}};
 
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, GetExtensions()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
       .WillOnce(Return(ERR_IO_PENDING));
 
   EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _));
 
   CreateChannelAndConnectSuccessfully();
-  channel_->StartClosingHandshake(999, "");
+  ASSERT_EQ(CHANNEL_ALIVE, channel_->StartClosingHandshake(999, ""));
 }
 
 // A Close frame with a reason longer than 123 bytes cannot be sent on the
 // network.
 TEST_F(WebSocketChannelStreamTest, LongCloseReasonNotSent) {
   static const InitFrame expected[] = {
       {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
        MASKED,      CLOSE_DATA(SERVER_ERROR, "")}};
 
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, GetExtensions()).Times(AnyNumber());
   EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
       .WillOnce(Return(ERR_IO_PENDING));
 
   EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _));
 
   CreateChannelAndConnectSuccessfully();
-  channel_->StartClosingHandshake(1000, std::string(124, 'A'));
+  ASSERT_EQ(CHANNEL_ALIVE,
+            channel_->StartClosingHandshake(1000, std::string(124, 'A')));
 }
 
 // We generate code 1005, kWebSocketErrorNoStatusReceived, when there is no
 // status in the Close message from the other side. Code 1005 is not allowed to
 // appear on the wire, so we should not echo it back. See test
 // CloseWithNoPayloadGivesStatus1005, above, for confirmation that code 1005 is
 // correctly generated internally.
 TEST_F(WebSocketChannelStreamTest, Code1005IsNotEchoed) {
   static const InitFrame frames[] = {
       {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose, NOT_MASKED, ""}};
@@ skipping 690 matching lines @@
 }
 
 // Set the closing handshake timeout to a very tiny value before connecting.
 class WebSocketChannelStreamTimeoutTest : public WebSocketChannelStreamTest {
  protected:
   WebSocketChannelStreamTimeoutTest() {}
 
   void CreateChannelAndConnectSuccessfully() override {
     set_stream(std::move(mock_stream_));
     CreateChannelAndConnect();
-    channel_->SendFlowControl(kPlentyOfQuota);
+    ASSERT_EQ(CHANNEL_ALIVE, channel_->SendFlowControl(kPlentyOfQuota));
     channel_->SetClosingHandshakeTimeoutForTesting(
         TimeDelta::FromMilliseconds(kVeryTinyTimeoutMillis));
     channel_->SetUnderlyingConnectionCloseTimeoutForTesting(
         TimeDelta::FromMilliseconds(kVeryTinyTimeoutMillis));
     connect_data_.creator.connect_delegate->OnSuccess(std::move(stream_));
   }
 };
 
 // In this case the server initiates the closing handshake with a Close
 // message. WebSocketChannel responds with a matching Close message, and waits
@@ skipping 43 matching lines @@
   TestClosure completion;
   {
     InSequence s;
     EXPECT_CALL(*mock_stream_, WriteFrames(EqualsFrames(expected), _))
         .WillOnce(Return(OK));
     EXPECT_CALL(*mock_stream_, Close())
         .WillOnce(InvokeClosure(completion.closure()));
   }
 
   CreateChannelAndConnectSuccessfully();
-  channel_->StartClosingHandshake(kWebSocketNormalClosure, "OK");
+  ASSERT_EQ(CHANNEL_ALIVE,
+            channel_->StartClosingHandshake(kWebSocketNormalClosure, "OK"));
   completion.WaitForResult();
 }
 
 // In this case the client initiates the closing handshake and the server
 // responds with a matching Close message. WebSocketChannel waits for the server
 // to close the TCP/IP connection, but it never does. The closing handshake
 // times out and WebSocketChannel closes the connection.
 TEST_F(WebSocketChannelStreamTimeoutTest, ConnectionCloseTimesOut) {
   static const InitFrame expected[] = {
       {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
@@ skipping 22 matching lines @@
     // point. ReadFrames is called again by WebSocketChannel, waiting for
     // ERR_CONNECTION_CLOSED.
     EXPECT_CALL(*mock_stream_, ReadFrames(_, _))
         .WillOnce(Return(ERR_IO_PENDING));
     // The timeout happens and so WebSocketChannel closes the stream.
     EXPECT_CALL(*mock_stream_, Close())
         .WillOnce(InvokeClosure(completion.closure()));
   }
 
   CreateChannelAndConnectSuccessfully();
-  channel_->StartClosingHandshake(kWebSocketNormalClosure, "OK");
+  ASSERT_EQ(CHANNEL_ALIVE,
+            channel_->StartClosingHandshake(kWebSocketNormalClosure, "OK"));
   ASSERT_TRUE(read_frames);
   // Provide the "Close" message from the server.
   *read_frames = CreateFrameVector(frames);
   read_callback.Run(OK);
   completion.WaitForResult();
 }
 
 // Verify that current_send_quota() returns a non-zero value for a newly
 // connected channel.
 TEST_F(WebSocketChannelTest, CurrentSendQuotaNonZero) {
@@ skipping 12 matching lines @@
 
   channel_->SendFrame(
       true, WebSocketFrameHeader::kOpCodeText,
       std::vector<char>(static_cast<size_t>(kMessageSize), 'a'));
   int new_send_quota = channel_->current_send_quota();
   EXPECT_EQ(kMessageSize, initial_send_quota - new_send_quota);
 }
 
 }  // namespace
 }  // namespace net