Rename closing_* in WebSocketChannel to received_close_ and do some refactoring

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 <string>
 #include <vector>
 
@@ skipping 170 matching lines @@
 
   // Calls WebSocketStream::ReadFrames() with the appropriate arguments.
   ChannelState ReadFrames() WARN_UNUSED_RESULT;
 
   // Callback from WebSocketStream::ReadFrames. Handles any errors and processes
   // the returned chunks appropriately to their type. |result| is a net error
   // code. If |synchronous| is true, then OnReadDone() is being called from
   // within the ReadFrames() loop and does not need to call ReadFrames() itself.
   ChannelState OnReadDone(bool synchronous, int result) WARN_UNUSED_RESULT;
 
-  // Processes a single frame that has been read from the stream.
-  ChannelState ProcessFrame(
+  // Handles a single frame that the object has received enough of to process.
+  // May call |event_interface_| methods, send responses to the server, and
+  // change the value of |state_|.
+  //
+  // This method performs sanity checks on the frame that are needed regardless
+  // of the current state. Then, calls the HandleFrameByState() method below
+  // which performs the appropriate action(s) depending on the current state.
+  ChannelState HandleFrame(
       scoped_ptr<WebSocketFrame> frame) WARN_UNUSED_RESULT;
 
-  // Handles a frame that the object has received enough of to process. May call
-  // |event_interface_| methods, send responses to the server, and change the
-  // value of |state_|.
-  ChannelState HandleFrame(const WebSocketFrameHeader::OpCode opcode,
-                           bool final,
-                           const scoped_refptr<IOBuffer>& data_buffer,
-                           size_t size) 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,
+      size_t size) 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 SendIOBuffer(bool fin,
                             WebSocketFrameHeader::OpCode op_code,
                             const scoped_refptr<IOBuffer>& buffer,
                             size_t size) WARN_UNUSED_RESULT;
@@ skipping 82 matching lines @@
 
   // Timer for the closing handshake.
   base::OneShotTimer<WebSocketChannel> timer_;
 
   // Timeout for the closing handshake.
   base::TimeDelta timeout_;
 
   // Storage for the status code and reason from the time the Close frame
   // arrives until the connection is closed and they are passed to
   // OnDropChannel().
-  uint16 closing_code_;
-  std::string closing_reason_;
+  uint16 received_close_code_;
+  std::string received_close_reason_;
 
   // The current state of the channel. Mainly used for sanity checking, but also
   // used to track the close state.
   State state_;
 
   // |notification_sender_| is owned by this object.
   scoped_ptr<HandshakeNotificationSender> notification_sender_;
 
   // UTF-8 validator for outgoing Text messages.
   base::StreamingUtf8Validator outgoing_utf8_validator_;
   bool sending_text_message_;
 
   // UTF-8 validator for incoming Text messages.
   base::StreamingUtf8Validator incoming_utf8_validator_;
   bool receiving_text_message_;
 
   DISALLOW_COPY_AND_ASSIGN(WebSocketChannel);
 };
 
 }  // namespace net
 
 #endif  // NET_WEBSOCKETS_WEBSOCKET_CHANNEL_H_