Change WebSocketChannel to pass data via IOBuffer

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 <limits.h>  // for INT_MAX
 #include <stddef.h>
 
 #include <algorithm>
@@ skipping 110 matching lines @@
       break;
 
     default:
       *name = "Unknown frame type";
       break;
   }
 
   return;
 }
 
+class DependentIOBuffer : public WrappedIOBuffer {
+ public:
+  DependentIOBuffer(scoped_refptr<IOBuffer> buffer, size_t offset)
+      : WrappedIOBuffer(buffer->data() + offset), buffer_(std::move(buffer)) {}
+
+ private:
+  ~DependentIOBuffer() override {}
+  scoped_refptr<net::IOBuffer> buffer_;
+};
+
 }  // 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(std::unique_ptr<WebSocketFrame> chunk);
@@ skipping 131 matching lines @@
     // TODO(yhirano): We can release |this| to save memory because
     // there will be no more opening handshake notification.
   }
 
   return CHANNEL_ALIVE;
 }
 
 WebSocketChannel::PendingReceivedFrame::PendingReceivedFrame(
     bool final,
     WebSocketFrameHeader::OpCode opcode,
-    const scoped_refptr<IOBuffer>& data,
+    scoped_refptr<IOBuffer> data,
     uint64_t offset,
     uint64_t size)
     : final_(final),
       opcode_(opcode),
-      data_(data),
+      data_(std::move(data)),
       offset_(offset),
       size_(size) {}
 
 WebSocketChannel::PendingReceivedFrame::PendingReceivedFrame(
     const PendingReceivedFrame& other) = default;
 
 WebSocketChannel::PendingReceivedFrame::~PendingReceivedFrame() {}
 
 void WebSocketChannel::PendingReceivedFrame::ResetOpcode() {
   DCHECK(WebSocketFrameHeader::IsKnownDataOpCode(opcode_));
@@ skipping 65 matching lines @@
   // The state RECV_CLOSED is not supported here, because it is only used in one
   // code path and should not leak into the code in general.
   DCHECK_NE(RECV_CLOSED, state_)
       << "InClosingState called with state_ == RECV_CLOSED";
   return state_ == SEND_CLOSED || state_ == CLOSE_WAIT || state_ == CLOSED;
 }
 
 WebSocketChannel::ChannelState WebSocketChannel::SendFrame(
     bool fin,
     WebSocketFrameHeader::OpCode op_code,
-    const std::vector<char>& data) {
-  if (data.size() > INT_MAX) {
+    scoped_refptr<IOBuffer> buffer,
+    size_t buffer_size) {
+  if (buffer_size > INT_MAX) {
     NOTREACHED() << "Frame size sanity check failed";
     return CHANNEL_ALIVE;
   }
   if (stream_ == NULL) {
     LOG(DFATAL) << "Got SendFrame without a connection established; "
                 << "misbehaving renderer? fin=" << fin << " op_code=" << op_code
-                << " data.size()=" << data.size();
+                << " buffer_size=" << buffer_size;
     return CHANNEL_ALIVE;
   }
   if (InClosingState()) {
     DVLOG(1) << "SendFrame called in state " << state_
              << ". This may be a bug, or a harmless race.";
     return CHANNEL_ALIVE;
   }
   if (state_ != CONNECTED) {
     NOTREACHED() << "SendFrame() called in state " << state_;
     return CHANNEL_ALIVE;
   }
-  if (data.size() > base::checked_cast<size_t>(current_send_quota_)) {
+  if (buffer_size > base::checked_cast<size_t>(current_send_quota_)) {
     // TODO(ricea): Kill renderer.
     return FailChannel("Send quota exceeded", kWebSocketErrorGoingAway, "");
     // |this| has been deleted.
   }
   if (!WebSocketFrameHeader::IsKnownDataOpCode(op_code)) {
     LOG(DFATAL) << "Got SendFrame with bogus op_code " << op_code
                 << "; misbehaving renderer? fin=" << fin
-                << " data.size()=" << data.size();
+                << " buffer_size=" << buffer_size;
     return CHANNEL_ALIVE;
   }
   if (op_code == WebSocketFrameHeader::kOpCodeText ||
       (op_code == WebSocketFrameHeader::kOpCodeContinuation &&
        sending_text_message_)) {
     StreamingUtf8Validator::State state =
-        outgoing_utf8_validator_.AddBytes(data.data(), data.size());
+        outgoing_utf8_validator_.AddBytes(buffer->data(), buffer_size);
     if (state == StreamingUtf8Validator::INVALID ||
         (state == StreamingUtf8Validator::VALID_MIDPOINT && fin)) {
       // TODO(ricea): Kill renderer.
       return FailChannel("Browser sent a text frame containing invalid UTF-8",
                          kWebSocketErrorGoingAway, "");
       // |this| has been deleted.
     }
     sending_text_message_ = !fin;
     DCHECK(!fin || state == StreamingUtf8Validator::VALID_ENDPOINT);
   }
-  current_send_quota_ -= data.size();
+  current_send_quota_ -= buffer_size;
   // TODO(ricea): If current_send_quota_ has dropped below
   // send_quota_low_water_mark_, it might be good to increase the "low
   // water mark" and "high water mark", but only if the link to the WebSocket
   // server is not saturated.
-  scoped_refptr<IOBuffer> buffer(new IOBuffer(data.size()));
-  std::copy(data.begin(), data.end(), buffer->data());
-  return SendFrameFromIOBuffer(fin, op_code, buffer, data.size());
+  return SendFrameInternal(fin, op_code, std::move(buffer), buffer_size);
   // |this| may have been deleted.
 }
 
 ChannelState WebSocketChannel::SendFlowControl(int64_t quota) {
   DCHECK(state_ == CONNECTING || state_ == CONNECTED || state_ == SEND_CLOSED ||
          state_ == CLOSE_WAIT);
   // TODO(ricea): Kill the renderer if it tries to send us a negative quota
   // value or > INT_MAX.
   DCHECK_GE(quota, 0);
   DCHECK_LE(quota, INT_MAX);
   if (!pending_received_frames_.empty()) {
     DCHECK_EQ(0u, current_receive_quota_);
   }
   while (!pending_received_frames_.empty() && quota > 0) {
     PendingReceivedFrame& front = pending_received_frames_.front();
     const uint64_t data_size = front.size() - front.offset();
     const uint64_t bytes_to_send =
         std::min(base::checked_cast<uint64_t>(quota), data_size);
     const bool final = front.final() && data_size == bytes_to_send;
-    const char* data =
-        front.data().get() ? front.data()->data() + front.offset() : NULL;
-    DCHECK(!bytes_to_send || data) << "Non empty data should not be null.";
-    const std::vector<char> data_vector(data, data + bytes_to_send);
+    scoped_refptr<IOBuffer> buffer_to_pass;
+    if (front.data()) {
+      buffer_to_pass = new DependentIOBuffer(front.data(), front.offset());
+    } else {
+      DCHECK(!bytes_to_send) << "Non empty data should not be null.";
+    }
     DVLOG(3) << "Sending frame previously split due to quota to the "
              << "renderer: quota=" << quota << " data_size=" << data_size
              << " bytes_to_send=" << bytes_to_send;
-    if (event_interface_->OnDataFrame(final, front.opcode(), data_vector) ==
-        CHANNEL_DELETED)
+    if (event_interface_->OnDataFrame(final, front.opcode(),
+                                      std::move(buffer_to_pass),
+                                      bytes_to_send) == CHANNEL_DELETED)
       return CHANNEL_DELETED;
     if (bytes_to_send < data_size) {
       front.DidConsume(bytes_to_send);
       front.ResetOpcode();
       return CHANNEL_ALIVE;
     }
     quota -= bytes_to_send;
 
     pending_received_frames_.pop();
   }
@@ skipping 360 matching lines @@
                            "One or more reserved bits are on: reserved1 = %d, "
                            "reserved2 = %d, reserved3 = %d",
                            static_cast<int>(frame->header.reserved1),
                            static_cast<int>(frame->header.reserved2),
                            static_cast<int>(frame->header.reserved3)),
                        kWebSocketErrorProtocolError,
                        "Invalid reserved bit");
   }
 
   // Respond to the frame appropriately to its type.
-  return HandleFrameByState(
-      opcode, frame->header.final, frame->data, frame->header.payload_length);
+  return HandleFrameByState(opcode, frame->header.final, std::move(frame->data),
+                            frame->header.payload_length);
 }
 
 ChannelState WebSocketChannel::HandleFrameByState(
     const WebSocketFrameHeader::OpCode opcode,
     bool final,
-    const scoped_refptr<IOBuffer>& data_buffer,
+    scoped_refptr<IOBuffer> data_buffer,
     uint64_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;
     GetFrameTypeForOpcode(opcode, &frame_name);
 
     // 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:
     case WebSocketFrameHeader::kOpCodeContinuation:
-      return HandleDataFrame(opcode, final, data_buffer, size);
+      return HandleDataFrame(opcode, final, std::move(data_buffer), size);
 
     case WebSocketFrameHeader::kOpCodePing:
       DVLOG(1) << "Got Ping of size " << size;
       if (state_ == CONNECTED)
-        return SendFrameFromIOBuffer(
-            true, WebSocketFrameHeader::kOpCodePong, data_buffer, size);
+        return SendFrameInternal(true, WebSocketFrameHeader::kOpCodePong,
+                                 std::move(data_buffer), size);
       DVLOG(3) << "Ignored ping in state " << state_;
       return CHANNEL_ALIVE;
 
     case WebSocketFrameHeader::kOpCodePong:
       DVLOG(1) << "Got Pong of size " << size;
       // There is no need to do anything with pong messages.
       return CHANNEL_ALIVE;
 
     case WebSocketFrameHeader::kOpCodeClose: {
       uint16_t code = kWebSocketNormalClosure;
       std::string reason;
       std::string message;
-      if (!ParseClose(data_buffer, size, &code, &reason, &message)) {
+      if (!ParseClose(std::move(data_buffer), size, &code, &reason, &message)) {
         return FailChannel(message, code, reason);
       }
       // TODO(ricea): Find a way to safely log the message from the close
       // message (escape control codes and so on).
       DVLOG(1) << "Got Close with code " << code;
       return HandleCloseFrame(code, reason);
     }
 
     default:
       return FailChannel(
           base::StringPrintf("Unrecognized frame opcode: %d", opcode),
           kWebSocketErrorProtocolError,
           "Unknown opcode");
   }
 }
 
 ChannelState WebSocketChannel::HandleDataFrame(
     WebSocketFrameHeader::OpCode opcode,
     bool final,
-    const scoped_refptr<IOBuffer>& data_buffer,
+    scoped_refptr<IOBuffer> data_buffer,
     uint64_t size) {
   if (state_ != CONNECTED) {
     DVLOG(3) << "Ignored data packet received in state " << state_;
     return CHANNEL_ALIVE;
   }
   if (has_received_close_frame_) {
     DVLOG(3) << "Ignored data packet as we've received a close frame.";
     return CHANNEL_ALIVE;
   }
   DCHECK(opcode == WebSocketFrameHeader::kOpCodeContinuation ||
@@ skipping 46 matching lines @@
     WebSocketFrameHeader::OpCode opcode_to_queue =
         no_quota ? opcode_to_send : WebSocketFrameHeader::kOpCodeContinuation;
     pending_received_frames_.push(PendingReceivedFrame(
         final, opcode_to_queue, data_buffer, current_receive_quota_, size));
     if (no_quota)
       return CHANNEL_ALIVE;
     size = current_receive_quota_;
     final = false;
   }
 
-  // TODO(ricea): Can this copy be eliminated?
-  const char* const data_begin = size ? data_buffer->data() : NULL;
-  const char* const data_end = data_begin + size;
-  const std::vector<char> data(data_begin, data_end);
   current_receive_quota_ -= size;
 
   // Sends the received frame to the renderer process.
-  return event_interface_->OnDataFrame(final, opcode_to_send, data);
+  return event_interface_->OnDataFrame(final, opcode_to_send,
+                                       std::move(data_buffer), size);
 }
 
 ChannelState WebSocketChannel::HandleCloseFrame(uint16_t code,
                                                 const std::string& reason) {
   DVLOG(1) << "Got Close with code " << code;
   switch (state_) {
     case CONNECTED:
       has_received_close_frame_ = true;
       received_close_code_ = code;
       received_close_reason_ = reason;
@@ skipping 42 matching lines @@
   DCHECK(!close_timer_.IsRunning());
   // This use of base::Unretained() is safe because we stop the timer
   // in the destructor.
   close_timer_.Start(
       FROM_HERE, underlying_connection_close_timeout_,
       base::Bind(&WebSocketChannel::CloseTimeout, base::Unretained(this)));
 
   return event_interface_->OnClosingHandshake();
 }
 
-ChannelState WebSocketChannel::SendFrameFromIOBuffer(
+ChannelState WebSocketChannel::SendFrameInternal(
     bool fin,
     WebSocketFrameHeader::OpCode op_code,
-    const scoped_refptr<IOBuffer>& buffer,
+    scoped_refptr<IOBuffer> buffer,
     uint64_t size) {
   DCHECK(state_ == CONNECTED || state_ == RECV_CLOSED);
   DCHECK(stream_);
 
   std::unique_ptr<WebSocketFrame> frame(new WebSocketFrame(op_code));
   WebSocketFrameHeader& header = frame->header;
   header.final = fin;
   header.masked = true;
   header.payload_length = size;
-  frame->data = buffer;
+  frame->data = std::move(buffer);
 
   if (data_being_sent_) {
     // Either the link to the WebSocket server is saturated, or several messages
     // are being sent in a batch.
     // TODO(ricea): Keep some statistics to work out the situation and adjust
     // quota appropriately.
     if (!data_to_send_next_)
       data_to_send_next_.reset(new SendBuffer);
     data_to_send_next_->AddFrame(std::move(frame));
     return CHANNEL_ALIVE;
@@ skipping 41 matching lines @@
   } else {
     const size_t payload_length = kWebSocketCloseCodeLength + reason.length();
     body = new IOBuffer(payload_length);
     size = payload_length;
     base::WriteBigEndian(body->data(), code);
     static_assert(sizeof(code) == kWebSocketCloseCodeLength,
                   "they should both be two");
     std::copy(
         reason.begin(), reason.end(), body->data() + kWebSocketCloseCodeLength);
   }
-  if (SendFrameFromIOBuffer(
-          true, WebSocketFrameHeader::kOpCodeClose, body, size) ==
-      CHANNEL_DELETED)
+  if (SendFrameInternal(true, WebSocketFrameHeader::kOpCodeClose,
+                        std::move(body), size) == CHANNEL_DELETED)
     return CHANNEL_DELETED;
   return CHANNEL_ALIVE;
 }
 
-bool WebSocketChannel::ParseClose(const scoped_refptr<IOBuffer>& buffer,
+bool WebSocketChannel::ParseClose(scoped_refptr<IOBuffer> buffer,
                                   uint64_t size,
                                   uint16_t* code,
                                   std::string* reason,
                                   std::string* message) {
   reason->clear();
   if (size < kWebSocketCloseCodeLength) {
     if (size == 0U) {
       *code = kWebSocketErrorNoStatusReceived;
       return true;
     }
@@ skipping 52 matching lines @@
 }
 
 void WebSocketChannel::CloseTimeout() {
   stream_->Close();
   SetState(CLOSED);
   DoDropChannel(false, kWebSocketErrorAbnormalClosure, "");
   // |this| has been deleted.
 }
 
 }  // namespace net