Change WebSocketChannel to pass data via IOBuffer

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 <memory>
@@ skipping 64 matching lines @@
       const GURL& socket_url,
       const std::vector<std::string>& requested_protocols,
       const url::Origin& origin,
       const GURL& first_party_for_cookies,
       const std::string& additional_headers);
 
   // Sends a data frame to the remote side. It is the responsibility of the
   // caller to ensure that they have sufficient send quota to send this data,
   // otherwise the connection will be closed without sending. |fin| indicates
   // the last frame in a message, equivalent to "FIN" as specified in section
-  // 5.2 of RFC6455. |data| is the "Payload Data". If |op_code| is kOpCodeText,
-  // or it is kOpCodeContinuation and the type the message is Text, then |data|
-  // must be a chunk of a valid UTF-8 message, however there is no requirement
-  // 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.
+  // 5.2 of RFC6455. |buffer->data()| is the "Payload Data". If |op_code| is
+  // kOpCodeText, or it is kOpCodeContinuation and the type the message is
+  // Text, then |buffer->data()| must be a chunk of a valid UTF-8 message,
+  // however there is no requirement for |buffer->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);
+                         scoped_refptr<IOBuffer> buffer,
+                         size_t buffer_size);
 
   // 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.
   //
   // 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 SendFlowControl(int64_t quota) WARN_UNUSED_RESULT;
 
@@ skipping 174 matching lines @@
   // 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(std::unique_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,
+                                  scoped_refptr<IOBuffer> data_buffer,
                                   uint64_t size) WARN_UNUSED_RESULT;
 
   // 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,
+                               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;
+                                     scoped_refptr<IOBuffer> buffer,
+                                     uint64_t buffer_size) WARN_UNUSED_RESULT;
 
   // Performs the "Fail the WebSocket Connection" operation as defined in
   // RFC6455. A NotifyFailure message is sent to the renderer with |message|.
   // The renderer will log the message to the console but not expose it to
   // Javascript. Javascript will see a Close code of AbnormalClosure (1006) with
   // an empty reason string. If state_ is CONNECTED then a Close message is sent
   // to the remote host containing the supplied |code| and |reason|. If the
   // stream is open, closes it and sets state_ to CLOSED.  FailChannel() always
   // returns CHANNEL_DELETED. It is not valid to access any member variables or
   // methods after calling FailChannel().
   ChannelState FailChannel(const std::string& message,
                            uint16_t code,
                            const std::string& reason) WARN_UNUSED_RESULT;
 
   // 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.
   ChannelState SendClose(uint16_t code,
                          const std::string& reason) WARN_UNUSED_RESULT;
 
   // Parses a Close frame payload. If no status code is supplied, then |code| is
   // set to 1005 (No status code) with empty |reason|. If the reason text is not
   // valid UTF-8, then |reason| is set to an empty string. If the payload size
   // is 1, or the supplied code is not permitted to be sent over the network,
   // then false is returned and |message| is set to an appropriate console
   // message.
-  bool ParseClose(const scoped_refptr<IOBuffer>& buffer,
+  bool ParseClose(scoped_refptr<IOBuffer> buffer,
                   uint64_t size,
                   uint16_t* code,
                   std::string* reason,
                   std::string* message);
 
   // Drop this channel.
   // If there are pending opening handshake notifications, notify them
   // before dropping.
   //
   // Always returns CHANNEL_DELETED.
@@ skipping 93 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_