Per-renderer WebSocket throttling

content/browser/renderer_host/websocket_host.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/renderer_host/websocket_host.h"
 
 #include "base/basictypes.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/string_util.h"
 #include "content/browser/renderer_host/websocket_dispatcher_host.h"
@@ skipping 296 matching lines @@
 
 void WebSocketEventHandler::SSLErrorHandlerDelegate::ContinueSSLRequest() {
   DVLOG(3) << "SSLErrorHandlerDelegate::ContinueSSLRequest";
   callbacks_->ContinueSSLRequest();
 }
 
 }  // namespace
 
 WebSocketHost::WebSocketHost(int routing_id,
                              WebSocketDispatcherHost* dispatcher,
-                             net::URLRequestContext* url_request_context)
+                             net::URLRequestContext* url_request_context,
+                             int delay_in_ms)
     : dispatcher_(dispatcher),
       url_request_context_(url_request_context),
-      routing_id_(routing_id) {
+      routing_id_(routing_id),
+      delay_in_ms_(delay_in_ms),
+      pending_flow_control_quota_(-1),
+      handshake_succeeded_(false),
+      weak_ptr_factory_(this) {
   DVLOG(1) << "WebSocketHost: created routing_id=" << routing_id;
 }
 
 WebSocketHost::~WebSocketHost() {}
 
 void WebSocketHost::GoAway() {
   OnDropChannel(false, static_cast<uint16>(net::kWebSocketErrorGoingAway), "");
 }
 
 bool WebSocketHost::OnMessageReceived(const IPC::Message& message) {
@@ skipping 13 matching lines @@
     const std::vector<std::string>& requested_protocols,
     const url::Origin& origin,
     int render_frame_id) {
   DVLOG(3) << "WebSocketHost::OnAddChannelRequest"
            << " routing_id=" << routing_id_ << " socket_url=\"" << socket_url
            << "\" requested_protocols=\""
            << JoinString(requested_protocols, ", ") << "\" origin=\""
            << origin.string() << "\"";
 
   DCHECK(!channel_);
+  if (delay_in_ms_ > 0) {
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&WebSocketHost::AddChannel,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   socket_url,
+                   requested_protocols,
+                   origin,
+                   render_frame_id),
+        base::TimeDelta::FromMilliseconds(delay_in_ms_));
+  } else {
+    AddChannel(socket_url, requested_protocols, origin, render_frame_id);
+  }
+}
+
+void WebSocketHost::AddChannel(
+    const GURL& socket_url,
+    const std::vector<std::string>& requested_protocols,
+    const url::Origin& origin,
+    int render_frame_id) {
+  DVLOG(3) << "WebSocketHost::AddChannel"
+           << " routing_id=" << routing_id_ << " socket_url=\"" << socket_url
+           << "\" requested_protocols=\""
+           << JoinString(requested_protocols, ", ") << "\" origin=\""
+           << origin.string() << "\"";
+
+  DCHECK(!channel_);
+
   scoped_ptr<net::WebSocketEventInterface> event_interface(
       new WebSocketEventHandler(dispatcher_, routing_id_, render_frame_id));
   channel_.reset(
       new net::WebSocketChannel(event_interface.Pass(), url_request_context_));
   channel_->SendAddChannelRequest(socket_url, requested_protocols, origin);
+
+  if (pending_flow_control_quota_ >= 0) {
+    channel_->SendFlowControl(pending_flow_control_quota_);

[Adam Rice, 2015/03/03 15:10:03]

I suggest setting pending_flow_control_quota_ to 0, just to be safe.

[hiroshige, 2015/03/04 06:02:38]

Done.

+  }
 }
 
 void WebSocketHost::OnSendFrame(bool fin,
                                 WebSocketMessageType type,
                                 const std::vector<char>& data) {
   DVLOG(3) << "WebSocketHost::OnSendFrame"
            << " routing_id=" << routing_id_ << " fin=" << fin
            << " type=" << type << " data is " << data.size() << " bytes";
 
   DCHECK(channel_);
   channel_->SendFrame(fin, MessageTypeToOpCode(type), data);
 }
 
 void WebSocketHost::OnFlowControl(int64 quota) {
   DVLOG(3) << "WebSocketHost::OnFlowControl"
            << " routing_id=" << routing_id_ << " quota=" << quota;
 
-  DCHECK(channel_);
+  if (!channel_) {
+    // WebSocketChannel is not yet created due to the delay introduced by
+    // Per-renderer WebSocket throttling.
+    // SendFlowControl() is called after WebSocketChannel is created.
+    pending_flow_control_quota_ = quota;

[Adam Rice, 2015/03/03 15:10:02]

This should be += because flow control quota is always added to any remaining
quota. It doesn't make any difference at the moment because the renderer only
sends one FlowControl message before data is received, but the implementation
could change in future.

[hiroshige, 2015/03/04 06:02:38]

Done.

+    return;
+  }
+
   channel_->SendFlowControl(quota);
 }
 
 void WebSocketHost::OnDropChannel(bool was_clean,
                                   uint16 code,
                                   const std::string& reason) {
   DVLOG(3) << "WebSocketHost::OnDropChannel"
            << " routing_id=" << routing_id_ << " was_clean=" << was_clean
            << " code=" << code << " reason=\"" << reason << "\"";
 
-  DCHECK(channel_);
+  if (!channel_) {
+    // WebSocketChannel is not yet created due to the delay introduced by
+    // Per-renderer WebSocket throttling.
+    WebSocketDispatcherHost::WebSocketHostState result =
+        dispatcher_->DoDropChannel(routing_id_, was_clean, code, reason);

[Adam Rice, 2015/03/03 15:10:03]

We should not use the values from the renderer in DoDropChannel. It should be
was_clean = false, code = kWebSocketErrorAbnormalClosure and reason = "", the
same as at websocket_channel.cc:484 (
https://code.google.com/p/chromium/codesearch#chromium/src/net/websockets/web...
)

[hiroshige, 2015/03/04 06:02:38]

Done.

+    DCHECK_EQ(WebSocketDispatcherHost::WEBSOCKET_HOST_DELETED, result);
+    return;
+  }
+
   // TODO(yhirano): Handle |was_clean| appropriately.
   channel_->StartClosingHandshake(code, reason);
 }
 
 }  // namespace content