[WebSocket] Incoming close frame should not overtake data frames

net/websockets/websocket_channel.h

 // 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.
 
 #ifndef NET_WEBSOCKETS_WEBSOCKET_CHANNEL_H_
 #define NET_WEBSOCKETS_WEBSOCKET_CHANNEL_H_
 
 #include <stdint.h>
 
 #include <queue>
@@ skipping 71 matching lines @@
   // for |data| to be split on character boundaries. Calling SendFrame may
   // result in synchronous calls to |event_interface_| which may result in this
   // object being deleted. In that case, the return value will be
   // CHANNEL_DELETED.
   ChannelState SendFrame(bool fin,
                          WebSocketFrameHeader::OpCode op_code,
                          const std::vector<char>& data);
 
   // Sends |quota| units of flow control to the remote side. If the underlying
   // transport has a concept of |quota|, then it permits the remote server to
-  // send up to |quota| units of data.
-  void SendFlowControl(int64_t quota);
+  // send up to |quota| units of data. Calling this function may

[tyoshino (SeeGerritForStatus), 2016/03/29 11:18:56]

break the line at the end of the sentence and have a blank line?

[yhirano, 2016/03/29 12:26:41]

Done.

+  // result in synchronous calls to |event_interface_| which may result in this
+  // object being deleted. In that case, the return value will be
+  // CHANNEL_DELETED.
+  ChannelState SendFlowControl(int64_t quota) WARN_UNUSED_RESULT;
 
   // Starts the closing handshake for a client-initiated shutdown of the
   // connection. There is no API to close the connection without a closing
   // handshake, but destroying the WebSocketChannel object while connected will
   // effectively do that. |code| must be in the range 1000-4999. |reason| should
   // be a valid UTF-8 string or empty.
   //
-  // This does *not* trigger the event OnClosingHandshake(). The caller should
-  // assume that the closing handshake has started and perform the equivalent
-  // processing to OnClosingHandshake() if necessary.
-  void StartClosingHandshake(uint16_t code, const std::string& reason);
+  // Calling this function may result in synchronous calls to |event_interface_|
+  // which may result in this object being deleted. In that case, the return
+  // value will be CHANNEL_DELETED.
+  ChannelState StartClosingHandshake(uint16_t code, const std::string& reason)
+      WARN_UNUSED_RESULT;
 
   // Returns the current send quota. This value is unsafe to use outside of the
   // browser IO thread because it changes asynchronously.  The value is only
   // valid for the execution of the current Task or until SendFrame() is called,
   // whichever happens sooner.
   int current_send_quota() const { return current_send_quota_; }
 
   // Starts the connection process, using a specified creator callback rather
   // than the default. This is exposed for testing.
   void SendAddChannelRequestForTesting(
@@ skipping 151 matching lines @@
   ChannelState HandleFrame(
       scoped_ptr<WebSocketFrame> frame) WARN_UNUSED_RESULT;
 
   // Handles a single frame depending on the current state. It's used by the
   // HandleFrame() method.
   ChannelState HandleFrameByState(const WebSocketFrameHeader::OpCode opcode,
                                   bool final,
                                   const scoped_refptr<IOBuffer>& data_buffer,
                                   uint64_t size) WARN_UNUSED_RESULT;
 
-  // Forward a received data frame to the renderer, if connected. If
+  // Forwards a received data frame to the renderer, if connected. If
   // |expecting_continuation| is not equal to |expecting_to_read_continuation_|,
   // will fail the channel. Also checks the UTF-8 validity of text frames.
   ChannelState HandleDataFrame(WebSocketFrameHeader::OpCode opcode,
                                bool final,
                                const scoped_refptr<IOBuffer>& data_buffer,
                                uint64_t size) WARN_UNUSED_RESULT;
 
+  // Handles an incoming close frame with |code| and |reason|.
+  ChannelState HandleCloseFrame(uint16_t code,
+                                const std::string& reason) WARN_UNUSED_RESULT;
+
+  // Responds to a closing handshake initiated by the server.
+  ChannelState RespondToClosingHandshake() WARN_UNUSED_RESULT;
+
   // Low-level method to send a single frame. Used for both data and control
   // frames. Either sends the frame immediately or buffers it to be scheduled
   // when the current write finishes. |fin| and |op_code| are defined as for
   // SendFrame() above, except that |op_code| may also be a control frame
   // opcode.
   ChannelState SendFrameFromIOBuffer(bool fin,
                                      WebSocketFrameHeader::OpCode op_code,
                                      const scoped_refptr<IOBuffer>& buffer,
                                      uint64_t size) WARN_UNUSED_RESULT;
 
@@ skipping 130 matching lines @@
   // For UMA. The time when OnConnectSuccess() method was called and |stream_|
   // was set.
   base::TimeTicks established_on_;
 
   DISALLOW_COPY_AND_ASSIGN(WebSocketChannel);
 };
 
 }  // namespace net
 
 #endif  // NET_WEBSOCKETS_WEBSOCKET_CHANNEL_H_