Replace WebSocketFrameChunk with WebSocketFrame

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>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "net/base/net_export.h"
 #include "net/websockets/websocket_frame.h"
 #include "net/websockets/websocket_stream.h"
 #include "url/gurl.h"
 
 namespace net {
 
-class GrowableIOBuffer;
+class BoundNetLog;
+class IOBuffer;
 class URLRequestContext;
 class WebSocketEventInterface;
-class BoundNetLog;
 
 // Transport-independent implementation of WebSockets. Implements protocol
 // semantics that do not depend on the underlying transport. Provides the
 // interface to the content layer. Some WebSocket concepts are used here without
 // definition; please see the RFC at http://tools.ietf.org/html/rfc6455 for
 // clarification.
 class NET_EXPORT WebSocketChannel {
  public:
   // The type of a WebSocketStream factory callback. Must match the signature of
   // WebSocketStream::CreateAndConnectStream().
@@ skipping 121 matching lines @@
 
   // Calls WebSocketStream::ReadFrames() with the appropriate arguments.
   void ReadFrames();
 
   // 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.
   void OnReadDone(bool synchronous, int result);
 
-  // Processes a single chunk that has been read from the stream.
-  void ProcessFrameChunk(scoped_ptr<WebSocketFrameChunk> chunk);
-
-  // Appends |data_buffer| to |incomplete_control_frame_body_|.
-  void AddToIncompleteControlFrameBody(
-      const scoped_refptr<IOBufferWithSize>& data_buffer);
+  // Processes a single frame that has been read from the stream.
+  void ProcessFrame(scoped_ptr<WebSocketFrame> frame);
 
   // 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_.
+  // |event_interface_| methods, send responses to the server, and change the
+  // value of |state_|.
   void HandleFrame(const WebSocketFrameHeader::OpCode opcode,
-                   bool is_first_chunk,
-                   bool is_final_chunk,
-                   const scoped_refptr<IOBufferWithSize>& data_buffer);
+                   bool final,
+                   const scoped_refptr<IOBuffer>& data_buffer,
+                   size_t size);
 
   // 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.
-  void SendIOBufferWithSize(bool fin,
-                            WebSocketFrameHeader::OpCode op_code,
-                            const scoped_refptr<IOBufferWithSize>& buffer);
+  void SendIOBuffer(bool fin,
+                    WebSocketFrameHeader::OpCode op_code,
+                    const scoped_refptr<IOBuffer>& buffer,
+                    size_t size);
 
   // Performs the "Fail the WebSocket Connection" operation as defined in
   // RFC6455. The supplied code and reason are sent back to the renderer in an
   // OnDropChannel message. If state_ is CONNECTED then a Close message is sent
   // to the remote host. If |expose| is SEND_REAL_ERROR then the remote host is
   // given the same status code passed to the renderer; otherwise it is sent a
-  // fixed "Going Away" code.  Resets current_frame_header_, closes the stream_,
-  // and sets state_ to CLOSED.
+  // fixed "Going Away" code.  Closes the stream_ and sets state_ to CLOSED.
   void FailChannel(ExposeError expose, uint16 code, const std::string& reason);
 
   // Sends a Close frame to Start the WebSocket Closing Handshake, or to respond
   // to a Close frame from the server. As a special case, setting |code| to
   // kWebSocketErrorNoStatusReceived will create a Close frame with no payload;
   // this is symmetric with the behaviour of ParseClose.
   void SendClose(uint16 code, const std::string& reason);
 
   // Parses a Close frame. If no status code is supplied, then |code| is set to
   // 1005 (No status code) with empty |reason|. If the supplied code is
   // outside the valid range, then 1002 (Protocol error) is set instead. If the
   // reason text is not valid UTF-8, then |reason| is set to an empty string
   // instead.
-  void ParseClose(const scoped_refptr<IOBufferWithSize>& buffer,
+  void ParseClose(const scoped_refptr<IOBuffer>& buffer,
+                  size_t size,
                   uint16* code,
                   std::string* reason);
 
   // The URL of the remote server.
   const GURL socket_url_;
 
   // The object receiving events.
   const scoped_ptr<WebSocketEventInterface> event_interface_;
 
   // The WebSocketStream on which to send and receive data.
   scoped_ptr<WebSocketStream> stream_;
 
   // A data structure containing a vector of frames to be sent and the total
   // number of bytes contained in the vector.
   class SendBuffer;
   // Data that is currently pending write, or NULL if no write is pending.
   scoped_ptr<SendBuffer> data_being_sent_;
   // Data that is queued up to write after the current write completes.
   // Only non-NULL when such data actually exists.
   scoped_ptr<SendBuffer> data_to_send_next_;
 
   // Destination for the current call to WebSocketStream::ReadFrames
-  ScopedVector<WebSocketFrameChunk> read_frame_chunks_;
-  // Frame header for the frame currently being received. Only non-NULL while we
-  // are processing the frame. If the frame arrives in multiple chunks, it can
-  // remain non-NULL until additional chunks arrive. If the header of the frame
-  // was invalid, this is set to NULL, the channel is failed, and subsequent
-  // chunks of the same frame will be ignored.
-  scoped_ptr<WebSocketFrameHeader> current_frame_header_;
+  ScopedVector<WebSocketFrame> read_frames_;
+
   // Handle to an in-progress WebSocketStream creation request. Only non-NULL
   // during the connection process.
   scoped_ptr<WebSocketStreamRequest> stream_request_;
-  // Although it should rarely happen in practice, a control frame can arrive
-  // broken into chunks. This variable provides storage for a partial control
-  // frame until the rest arrives. It will be NULL the rest of the time.
-  scoped_refptr<GrowableIOBuffer> incomplete_control_frame_body_;
+
   // If the renderer's send quota reaches this level, it is sent a quota
   // refresh. "quota units" are currently bytes. TODO(ricea): Update the
   // definition of quota units when necessary.
   int send_quota_low_water_mark_;
   // The level the quota is refreshed to when it reaches the low_water_mark
   // (quota units).
   int send_quota_high_water_mark_;
   // The current amount of quota that the renderer has available for sending
   // on this logical channel (quota units).
   int current_send_quota_;
 
   // 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_;
 
   // The current state of the channel. Mainly used for sanity checking, but also
   // used to track the close state.
   State state_;
 
   DISALLOW_COPY_AND_ASSIGN(WebSocketChannel);
 };
 
 }  // namespace net
 
 #endif  // NET_WEBSOCKETS_WEBSOCKET_CHANNEL_H_