Change WebSocketChannel to pass data via IOBuffer

content/browser/websockets/websocket_impl.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 "content/browser/websockets/websocket_impl.h"
 
 #include <inttypes.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/ssl/ssl_error_handler.h"
 #include "content/browser/ssl/ssl_manager.h"
 #include "content/public/browser/storage_partition.h"
 #include "ipc/ipc_message.h"
+#include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/ssl/ssl_info.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/websockets/websocket_channel.h"
 #include "net/websockets/websocket_errors.h"
 #include "net/websockets/websocket_event_interface.h"
 #include "net/websockets/websocket_frame.h"  // for WebSocketFrameHeader::OpCode
@@ skipping 49 matching lines @@
  public:
   explicit WebSocketEventHandler(WebSocketImpl* impl);
   ~WebSocketEventHandler() override;
 
   // net::WebSocketEventInterface implementation
 
   ChannelState OnAddChannelResponse(const std::string& selected_subprotocol,
                                     const std::string& extensions) override;
   ChannelState OnDataFrame(bool fin,
                            WebSocketMessageType type,
-                           const std::vector<char>& data) override;
+                           scoped_refptr<net::IOBuffer> buffer,
+                           size_t buffer_size) override;
   ChannelState OnClosingHandshake() override;
   ChannelState OnFlowControl(int64_t quota) override;
   ChannelState OnDropChannel(bool was_clean,
                              uint16_t code,
                              const std::string& reason) override;
   ChannelState OnFailChannel(const std::string& message) override;
   ChannelState OnStartOpeningHandshake(
       std::unique_ptr<net::WebSocketHandshakeRequestInfo> request) override;
   ChannelState OnFinishOpeningHandshake(
       std::unique_ptr<net::WebSocketHandshakeResponseInfo> response) override;
@@ skipping 53 matching lines @@
   impl_->delegate_->OnReceivedResponseFromServer(impl_);
 
   impl_->client_->OnAddChannelResponse(selected_protocol, extensions);
 
   return net::WebSocketEventInterface::CHANNEL_ALIVE;
 }
 
 ChannelState WebSocketImpl::WebSocketEventHandler::OnDataFrame(
     bool fin,
     net::WebSocketFrameHeader::OpCode type,
-    const std::vector<char>& data) {
+    scoped_refptr<net::IOBuffer> buffer,
+    size_t buffer_size) {
   DVLOG(3) << "WebSocketEventHandler::OnDataFrame @"
            << reinterpret_cast<void*>(this)
            << " fin=" << fin
-           << " type=" << type << " data is " << data.size() << " bytes";
+           << " type=" << type << " data is " << buffer_size << " bytes";
 
   // TODO(darin): Avoid this copy.
-  std::vector<uint8_t> data_to_pass(data.size());
-  std::copy(data.begin(), data.end(), data_to_pass.begin());
+  std::vector<uint8_t> data_to_pass(buffer_size);
+  if (buffer_size > 0) {
+    std::copy(buffer->data(), buffer->data() + buffer_size,
+              data_to_pass.begin());
+  }
 
   impl_->client_->OnDataFrame(fin, OpCodeToMessageType(type), data_to_pass);
 
   return net::WebSocketEventInterface::CHANNEL_ALIVE;
 }
 
 ChannelState WebSocketImpl::WebSocketEventHandler::OnClosingHandshake() {
   DVLOG(3) << "WebSocketEventHandler::OnClosingHandshake @"
            << reinterpret_cast<void*>(this);
 
@@ skipping 238 matching lines @@
     if (handshake_succeeded_) {
       DVLOG(1) << "Dropping frame sent to closed websocket";
     } else {
       bad_message::ReceivedBadMessage(
           delegate_->GetClientProcessId(),
           bad_message::WSI_UNEXPECTED_SEND_FRAME);
     }
     return;
   }
 
-  // TODO(darin): Avoid this copy.
-  std::vector<char> data_to_pass(data.size());
-  std::copy(data.begin(), data.end(), data_to_pass.begin());
+  scoped_refptr<net::IOBuffer> data_to_pass(new net::IOBuffer(data.size()));

[yhirano, 2016/09/06 12:19:48]

"Avoid this copy" missing?

+  std::copy(data.begin(), data.end(), data_to_pass->data());
 
-  channel_->SendFrame(fin, MessageTypeToOpCode(type), data_to_pass);
+  channel_->SendFrame(fin, MessageTypeToOpCode(type), std::move(data_to_pass),
+                      data.size());
 }
 
 void WebSocketImpl::SendFlowControl(int64_t quota) {
   DVLOG(3) << "WebSocketImpl::OnFlowControl @"
            << reinterpret_cast<void*>(this) << " quota=" << quota;
 
   if (!channel_) {
     // WebSocketChannel is not yet created due to the delay introduced by
     // per-renderer WebSocket throttling.
     // SendFlowControl() is called after WebSocketChannel is created.
@@ skipping 70 matching lines @@
                                             net::HttpRequestHeaders::kUserAgent,
                                             user_agent_override.c_str());
   }
   channel_->SendAddChannelRequest(socket_url, requested_protocols, origin,
                                   first_party_for_cookies, additional_headers);
   if (quota > 0)
     SendFlowControl(quota);
 }
 
 }  // namespace content