Replace WebSocketFrameChunk with WebSocketFrame

net/websockets/websocket_stream.h

 // Copyright (c) 2012 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_STREAM_H_
 #define NET_WEBSOCKETS_WEBSOCKET_STREAM_H_
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback_forward.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_export.h"
 #include "net/websockets/websocket_stream_base.h"
 
 class GURL;
 
 namespace net {
 
 class BoundNetLog;
 class HttpRequestHeaders;
 class HttpResponseInfo;
 class URLRequestContext;
-struct WebSocketFrameChunk;
+struct WebSocketFrame;
 
 // WebSocketStreamRequest is the caller's handle to the process of creation of a
 // WebSocketStream. Deleting the object before the OnSuccess or OnFailure
 // callbacks are called will cancel the request (and neither callback will be
 // called). After OnSuccess or OnFailure have been called, this object may be
 // safely deleted without side-effects.
 class NET_EXPORT_PRIVATE WebSocketStreamRequest {
  public:
   virtual ~WebSocketStreamRequest();
 };
@@ skipping 46 matching lines @@
       const GURL& origin,
       URLRequestContext* url_request_context,
       const BoundNetLog& net_log,
       scoped_ptr<ConnectDelegate> connect_delegate);
 
   // Derived classes must make sure Close() is called when the stream is not
   // closed on destruction.
   virtual ~WebSocketStream();
 
   // Reads WebSocket frame data. This operation finishes when new frame data
-  // becomes available. Each frame message might be chopped off in the middle
-  // as specified in the description of the WebSocketFrameChunk struct.
-  // |frame_chunks| remains owned by the caller and must be valid until the
-  // operation completes or Close() is called. |frame_chunks| must be empty on
+  // becomes available.
+  //
+  // |frames| remains owned by the caller and must be valid until the
+  // operation completes or Close() is called. |frames| must be empty on
   // calling.
   //
   // This function should not be called while the previous call of ReadFrames()
   // is still pending.
   //
   // Returns net::OK or one of the net::ERR_* codes.
   //
-  // frame_chunks->size() >= 1 if the result is OK.
+  // frames->size() >= 1 if the result is OK.
   //
-  // A frame with an incomplete header will never be inserted into
-  // |frame_chunks|. If the currently available bytes of a new frame do not form
-  // a complete frame header, then the implementation will buffer them until all
-  // the fields in the WebSocketFrameHeader object can be filled. If
-  // ReadFrames() is freshly called in this situation, it will return
-  // ERR_IO_PENDING exactly as if no data was available.
+  // Only complete frames are inserted into |frames|. If the currently available
+  // bytes of a new frame do not form a complete frame header, then the
+  // implementation will buffer them until all the fields in the
+  // WebSocketFrameHeader object can be filled. If ReadFrames() is freshly
+  // called in this situation, it will return ERR_IO_PENDING exactly as if no
+  // data was available.
   //
-  // Every WebSocketFrameChunk in the vector except the first and last is
-  // guaranteed to be a complete frame. The first chunk may be the final part
-  // of the previous frame. The last chunk may be the first part of a new
-  // frame. If there is only one chunk, then it may consist of data from the
-  // middle part of a frame.
+  // Original frame boundaries are not preserved. In particular, if only part of
+  // a frame is available, then the frame will be split, and the available data
+  // returned immediately.
   //
   // When the socket is closed on the remote side, this method will return
   // ERR_CONNECTION_CLOSED. It will not return OK with an empty vector.
   //
   // If the connection is closed in the middle of receiving an incomplete frame,
   // ReadFrames may discard the incomplete frame. Since the renderer will
   // discard any incomplete messages when the connection is closed, this makes
   // no difference to the overall semantics.
-  virtual int ReadFrames(ScopedVector<WebSocketFrameChunk>* frame_chunks,
+  virtual int ReadFrames(ScopedVector<WebSocketFrame>* frames,
                          const CompletionCallback& callback) = 0;
 
-  // Writes WebSocket frame data. |frame_chunks| must only contain complete
-  // frames. Every chunk must have a non-NULL |header| and the |final_chunk|
-  // boolean set to true.
+  // Writes WebSocket frame data.
   //
-  // The |frame_chunks| pointer must remain valid until the operation completes
-  // or Close() is called. WriteFrames() will modify the contents of
-  // |frame_chunks| in the process of sending the message. After WriteFrames()
-  // has completed it is safe to clear and then re-use the vector, but other
-  // than that the caller should make no assumptions about its contents.
+  // |frames| must be valid until the operation completes or Close() is called.
   //
-  // This function should not be called while a previous call to WriteFrames()
-  // on the same stream is pending.
-  //
-  // Frame boundaries may not be preserved. Frames may be split or
-  // coalesced. Message boundaries are preserved (as required by WebSocket API
-  // semantics).
+  // This function must not be called while a previous call of WriteFrames() is
+  // still pending.
   //
   // This method will only return OK if all frames were written completely.
   // Otherwise it will return an appropriate net error code.
-  virtual int WriteFrames(ScopedVector<WebSocketFrameChunk>* frame_chunks,
+  virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
                           const CompletionCallback& callback) = 0;
 
   // Closes the stream. All pending I/O operations (if any) are cancelled
-  // at this point, so |frame_chunks| can be freed.
+  // at this point, so |frames| can be freed.
   virtual void Close() = 0;
 
   // The subprotocol that was negotiated for the stream. If no protocol was
   // negotiated, then the empty string is returned.
   virtual std::string GetSubProtocol() const = 0;
 
   // The extensions that were negotiated for the stream. Since WebSocketStreams
   // can be layered, this may be different from what this particular
   // WebSocketStream implements. The primary purpose of this accessor is to make
   // the data available to Javascript. The format of the string is identical to
@@ skipping 41 matching lines @@
  protected:
   WebSocketStream();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WebSocketStream);
 };
 
 }  // namespace net
 
 #endif  // NET_WEBSOCKETS_WEBSOCKET_STREAM_H_