Rename closing_* in WebSocketChannel to received_close_ and do some refactoring

net/websockets/websocket_channel.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 <algorithm>
 
 #include "base/basictypes.h"  // for size_t
 #include "base/bind.h"
@@ skipping 62 matching lines @@
   DCHECK_NE(kInvalidRangesEnd, upper);
   DCHECK_GT(upper, kInvalidRanges);
   DCHECK_GT(*upper, code);
   DCHECK_LE(*(upper - 1), code);
   return ((upper - kInvalidRanges) % 2) == 0;
 }
 
 // This function avoids a bunch of boilerplate code.
 void AllowUnused(ChannelState ALLOW_UNUSED unused) {}
 
+// Sets |name| to the name of the frame type for the given |opcode|. Note that
+// for all of Text, Binary and Continuation opcode, this method returns
+// "Data frame".
+void GetFrameTypeForOpcode(WebSocketFrameHeader::OpCode opcode,
+                           std::string* name) {
+  switch (opcode) {
+    case WebSocketFrameHeader::kOpCodeText:    // fall-thru
+    case WebSocketFrameHeader::kOpCodeBinary:  // fall-thru
+    case WebSocketFrameHeader::kOpCodeContinuation:
+      *name = "Data frame";
+      break;
+
+    case WebSocketFrameHeader::kOpCodePing:
+      *name = "Ping";
+      break;
+
+    case WebSocketFrameHeader::kOpCodePong:
+      *name = "Pong";
+      break;
+
+    case WebSocketFrameHeader::kOpCodeClose:
+      *name = "Close";
+      break;
+
+    default:
+      *name = "Unknown frame type";
+      break;
+  }
+
+  return;
+}
+
 }  // namespace
 
 // A class to encapsulate a set of frames and information about the size of
 // those frames.
 class WebSocketChannel::SendBuffer {
  public:
   SendBuffer() : total_bytes_(0) {}
 
   // Add a WebSocketFrame to the buffer and increase total_bytes_.
   void AddFrame(scoped_ptr<WebSocketFrame> chunk);
@@ skipping 125 matching lines @@
 
 WebSocketChannel::WebSocketChannel(
     scoped_ptr<WebSocketEventInterface> event_interface,
     URLRequestContext* url_request_context)
     : event_interface_(event_interface.Pass()),
       url_request_context_(url_request_context),
       send_quota_low_water_mark_(kDefaultSendQuotaLowWaterMark),
       send_quota_high_water_mark_(kDefaultSendQuotaHighWaterMark),
       current_send_quota_(0),
       timeout_(base::TimeDelta::FromSeconds(kClosingHandshakeTimeoutSeconds)),
-      closing_code_(0),
+      received_close_code_(0),
       state_(FRESHLY_CONSTRUCTED),
       notification_sender_(new HandshakeNotificationSender(this)),
       sending_text_message_(false),
       receiving_text_message_(false) {}
 
 WebSocketChannel::~WebSocketChannel() {
   // The stream may hold a pointer to read_frames_, and so it needs to be
   // destroyed first.
   stream_.reset();
   // The timer may have a callback pointing back to us, so stop it just in case
@@ skipping 317 matching lines @@
   DCHECK_NE(ERR_IO_PENDING, result);
   switch (result) {
     case OK:
       // ReadFrames() must use ERR_CONNECTION_CLOSED for a closed connection
       // with no data read, not an empty response.
       DCHECK(!read_frames_.empty())
           << "ReadFrames() returned OK, but nothing was read.";
       for (size_t i = 0; i < read_frames_.size(); ++i) {
         scoped_ptr<WebSocketFrame> frame(read_frames_[i]);
         read_frames_[i] = NULL;
-        if (ProcessFrame(frame.Pass()) == CHANNEL_DELETED)
+        if (HandleFrame(frame.Pass()) == CHANNEL_DELETED)
           return CHANNEL_DELETED;
       }
       read_frames_.clear();
       // There should always be a call to ReadFrames pending.
       // TODO(ricea): Unless we are out of quota.
       DCHECK_NE(CLOSED, state_);
       if (!synchronous)
         return ReadFrames();
       return CHANNEL_ALIVE;
 
     case ERR_WS_PROTOCOL_ERROR:
       // This could be kWebSocketErrorProtocolError (specifically, non-minimal
       // encoding of payload length) or kWebSocketErrorMessageTooBig, or an
       // extension-specific error.
       return FailChannel("Invalid frame header",
                          kWebSocketErrorProtocolError,
                          "WebSocket Protocol Error");
 
     default:
       DCHECK_LT(result, 0)
           << "ReadFrames() should only return OK or ERR_ codes";
       stream_->Close();
       DCHECK_NE(CLOSED, state_);
       state_ = CLOSED;
       uint16 code = kWebSocketErrorAbnormalClosure;
       std::string reason = "";
       bool was_clean = false;
-      if (closing_code_ != 0) {
-        code = closing_code_;
-        reason = closing_reason_;
+      if (received_close_code_ != 0) {
+        code = received_close_code_;
+        reason = received_close_reason_;
         was_clean = (result == ERR_CONNECTION_CLOSED);
       }
       return DoDropChannel(was_clean, code, reason);
   }
 }
 
-ChannelState WebSocketChannel::ProcessFrame(scoped_ptr<WebSocketFrame> frame) {
+ChannelState WebSocketChannel::HandleFrame(
+    scoped_ptr<WebSocketFrame> frame) {
   if (frame->header.masked) {
     // RFC6455 Section 5.1 "A client MUST close a connection if it detects a
     // masked frame."
     return FailChannel(
         "A server must not mask any frames that it sends to the "
         "client.",
         kWebSocketErrorProtocolError,
         "Masked frame from server");
   }
   const WebSocketFrameHeader::OpCode opcode = frame->header.opcode;
   if (WebSocketFrameHeader::IsKnownControlOpCode(opcode) &&
       !frame->header.final) {
     return FailChannel(
         base::StringPrintf("Received fragmented control frame: opcode = %d",
                            opcode),
         kWebSocketErrorProtocolError,
         "Control message with FIN bit unset received");
   }
 
   // Respond to the frame appropriately to its type.
-  return HandleFrame(
+  return HandleFrameByState(
       opcode, frame->header.final, frame->data, frame->header.payload_length);
 }
 
-ChannelState WebSocketChannel::HandleFrame(
+ChannelState WebSocketChannel::HandleFrameByState(
     const WebSocketFrameHeader::OpCode opcode,
     bool final,
     const scoped_refptr<IOBuffer>& data_buffer,
     size_t size) {
   DCHECK_NE(RECV_CLOSED, state_)
       << "HandleFrame() does not support being called re-entrantly from within "
          "SendClose()";
   DCHECK_NE(CLOSED, state_);
   if (state_ == CLOSE_WAIT) {
     std::string frame_name;
-    switch (opcode) {
-      case WebSocketFrameHeader::kOpCodeText:    // fall-thru
-      case WebSocketFrameHeader::kOpCodeBinary:  // fall-thru
-      case WebSocketFrameHeader::kOpCodeContinuation:
-        frame_name = "Data frame";
-        break;
+    GetFrameTypeForOpcode(opcode, &frame_name);
 
-      case WebSocketFrameHeader::kOpCodePing:
-        frame_name = "Ping";
-        break;
-
-      case WebSocketFrameHeader::kOpCodePong:
-        frame_name = "Pong";
-        break;
-
-      case WebSocketFrameHeader::kOpCodeClose:
-        frame_name = "Close";
-        break;
-
-      default:
-        frame_name = "Unknown frame type";
-        break;
-    }
     // FailChannel() won't send another Close frame.
     return FailChannel(
         frame_name + " received after close", kWebSocketErrorProtocolError, "");
   }
   switch (opcode) {
     case WebSocketFrameHeader::kOpCodeText:    // fall-thru
     case WebSocketFrameHeader::kOpCodeBinary:  // fall-thru
     case WebSocketFrameHeader::kOpCodeContinuation:
       if (state_ == CONNECTED) {
         if (opcode == WebSocketFrameHeader::kOpCodeText ||
@@ skipping 52 matching lines @@
       // message (escape control codes and so on).
       VLOG(1) << "Got Close with code " << code;
       switch (state_) {
         case CONNECTED:
           state_ = RECV_CLOSED;
           if (SendClose(code, reason) ==  // Sets state_ to CLOSE_WAIT
               CHANNEL_DELETED)
             return CHANNEL_DELETED;
           if (event_interface_->OnClosingHandshake() == CHANNEL_DELETED)
             return CHANNEL_DELETED;
-          closing_code_ = code;
-          closing_reason_ = reason;
+          received_close_code_ = code;
+          received_close_reason_ = reason;
           break;
 
         case SEND_CLOSED:
           state_ = CLOSE_WAIT;
           // From RFC6455 section 7.1.5: "Each endpoint
           // will see the status code sent by the other end as _The WebSocket
           // Connection Close Code_."
-          closing_code_ = code;
-          closing_reason_ = reason;
+          received_close_code_ = code;
+          received_close_reason_ = reason;
           break;
 
         default:
           LOG(DFATAL) << "Got Close in unexpected state " << state_;
           break;
       }
       return CHANNEL_ALIVE;
     }
 
     default:
@@ skipping 152 matching lines @@
 
 void WebSocketChannel::CloseTimeout() {
   stream_->Close();
   DCHECK_NE(CLOSED, state_);
   state_ = CLOSED;
   AllowUnused(DoDropChannel(false, kWebSocketErrorAbnormalClosure, ""));
   // |this| has been deleted.
 }
 
 }  // namespace net