Provide child/frame IDs for WebSocket handshake request

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/loader/resource_request_info_impl.h"

[tyoshino (SeeGerritForStatus), 2016/10/12 08:13:36]

for what?

[yhirano, 2016/10/12 10:47:15]

Sorry, it was used when I used ResourceRequestInfo instead of
WebSocketHandshakeRequestInfo. Deleted.

 #include "content/browser/ssl/ssl_error_handler.h"
 #include "content/browser/ssl/ssl_manager.h"
+#include "content/browser/websockets/websocket_handshake_request_info_impl.h"
 #include "content/public/browser/storage_partition.h"
+#include "content/public/common/process_type.h"

[tyoshino (SeeGerritForStatus), 2016/10/12 08:13:36]

for what?

[yhirano, 2016/10/12 10:47:15]

Ditto

 #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.h"

[tyoshino (SeeGerritForStatus), 2016/10/12 08:13:36]

where is this used?

[yhirano, 2016/10/12 10:47:15]

Done.

 #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
 #include "net/websockets/websocket_handshake_request_info.h"
 #include "net/websockets/websocket_handshake_response_info.h"
 #include "url/origin.h"
 
 namespace content {
@@ skipping 40 matching lines @@
 // Implementation of net::WebSocketEventInterface. Receives events from our
 // WebSocketChannel object.
 class WebSocketImpl::WebSocketEventHandler final
     : public net::WebSocketEventInterface {
  public:
   explicit WebSocketEventHandler(WebSocketImpl* impl);
   ~WebSocketEventHandler() override;
 
   // net::WebSocketEventInterface implementation
 
+  void OnCreateURLRequest(net::URLRequest* request) override;
   ChannelState OnAddChannelResponse(const std::string& selected_subprotocol,
                                     const std::string& extensions) override;
   ChannelState OnDataFrame(bool fin,
                            WebSocketMessageType type,
                            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,
@@ skipping 41 matching lines @@
     : impl_(impl) {
   DVLOG(1) << "WebSocketEventHandler created @"
            << reinterpret_cast<void*>(this);
 }
 
 WebSocketImpl::WebSocketEventHandler::~WebSocketEventHandler() {
   DVLOG(1) << "WebSocketEventHandler destroyed @"
            << reinterpret_cast<void*>(this);
 }
 
+void WebSocketImpl::WebSocketEventHandler::OnCreateURLRequest(
+    net::URLRequest* request) {
+  WebSocketHandshakeRequestInfoImpl::CreateInfoAndAssociateWithRequest(
+      impl_->child_id_, impl_->frame_id_, request);
+}
+
 ChannelState WebSocketImpl::WebSocketEventHandler::OnAddChannelResponse(
     const std::string& selected_protocol,
     const std::string& extensions) {
   DVLOG(3) << "WebSocketEventHandler::OnAddChannelResponse @"
            << reinterpret_cast<void*>(this)
            << " selected_protocol=\"" << selected_protocol << "\""
            << " extensions=\"" << extensions << "\"";
 
   impl_->delegate_->OnReceivedResponseFromServer(impl_);
 
@@ skipping 183 matching lines @@
                                            : static_cast<net::CertStatus>(-1));
   callbacks_->CancelSSLRequest(error, ssl_info);
 }
 
 void WebSocketImpl::WebSocketEventHandler::SSLErrorHandlerDelegate::
     ContinueSSLRequest() {
   DVLOG(3) << "SSLErrorHandlerDelegate::ContinueSSLRequest";
   callbacks_->ContinueSSLRequest();
 }
 
-WebSocketImpl::WebSocketImpl(
-    Delegate* delegate,
-    blink::mojom::WebSocketRequest request,
-    int frame_id,
-    base::TimeDelta delay)
+WebSocketImpl::WebSocketImpl(Delegate* delegate,
+                             blink::mojom::WebSocketRequest request,
+                             int child_id,
+                             int frame_id,
+                             base::TimeDelta delay)
     : delegate_(delegate),
       binding_(this, std::move(request)),
       delay_(delay),
       pending_flow_control_quota_(0),
+      child_id_(child_id),
       frame_id_(frame_id),
       handshake_succeeded_(false),
       weak_ptr_factory_(this) {
   binding_.set_connection_error_handler(
       base::Bind(&WebSocketImpl::OnConnectionError, base::Unretained(this)));
 }
 
 WebSocketImpl::~WebSocketImpl() {}
 
 void WebSocketImpl::GoAway() {
@@ skipping 153 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