Have WebSocket throttling work with Network Service

This CL introduces WebSocket throttling on network::WebSocketFactory by
moving some logic from content/browser/websockets to services/network.

Bug: 721400
Cq-Include-Trybots: master.tryserver.chromium.linux:linux_mojo
Change-Id: Ie007765411d95d1854fc0271652d599e5ccbcd0c
Reviewed-on: https://chromium-review.googlesource.com/979872
Commit-Queue: Yutaka Hirano <yhirano@chromium.org>
Reviewed-by: Adam Rice <ricea@chromium.org>
Cr-Commit-Position: refs/heads/master@{#545766}

content/browser/websockets/websocket_manager.cc

@@ -13,7 +13,6 @@
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/numerics/safe_conversions.h"
-#include "base/rand_util.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/ssl/ssl_error_handler.h"
@@ -31,10 +30,6 @@ namespace {
 
 const char kWebSocketManagerKeyName[] = "web_socket_manager";
 
-// Max number of pending connections per WebSocketManager used for per-renderer
-// WebSocket throttling.
-const int kMaxPendingWebSocketConnections = 255;
-
 }  // namespace
 
 class WebSocketManager::Delegate final : public network::WebSocket::Delegate {
@@ -46,10 +41,6 @@ class WebSocketManager::Delegate final : public network::WebSocket::Delegate {
     return manager_->GetURLRequestContext();
   }
 
-  void OnReceivedResponseFromServer(network::WebSocket* impl) override {
-    manager_->OnReceivedResponseFromServer(impl);
-  }
-
   void OnLostConnectionToClient(network::WebSocket* impl) override {
     manager_->OnLostConnectionToClient(impl);
   }
@@ -216,11 +207,6 @@ void WebSocketManager::CreateWebSocketWithOrigin(
 WebSocketManager::WebSocketManager(int process_id,
                                    StoragePartition* storage_partition)
     : process_id_(process_id),
-      num_pending_connections_(0),
-      num_current_succeeded_connections_(0),
-      num_previous_succeeded_connections_(0),
-      num_current_failed_connections_(0),
-      num_previous_failed_connections_(0),
       context_destroyed_(false) {
   if (storage_partition) {
     url_request_context_getter_ = storage_partition->GetURLRequestContext();
@@ -251,7 +237,7 @@ void WebSocketManager::DoCreateWebSocket(
     network::mojom::WebSocketRequest request) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  if (num_pending_connections_ >= kMaxPendingWebSocketConnections) {
+  if (throttler_.HasTooManyPendingConnections()) {
     // Too many websockets!
     request.ResetWithReason(
         network::mojom::WebSocket::kInsufficientResources,
@@ -269,10 +255,10 @@ void WebSocketManager::DoCreateWebSocket(
   // Keep all network::WebSockets alive until either the client drops its
   // connection (see OnLostConnectionToClient) or we need to shutdown.
 
-  impls_.insert(CreateWebSocket(std::make_unique<Delegate>(this),
-                                std::move(request), process_id_, frame_id,
-                                std::move(origin), CalculateDelay()));
-  ++num_pending_connections_;
+  impls_.insert(CreateWebSocket(
+      std::make_unique<Delegate>(this), std::move(request),
+      throttler_.IssuePendingConnectionTracker(), process_id_, frame_id,
+      std::move(origin), throttler_.CalculateDelay()));
 
   if (!throttling_period_timer_.IsRunning()) {
     throttling_period_timer_.Start(
@@ -283,42 +269,23 @@ void WebSocketManager::DoCreateWebSocket(
   }
 }
 
-// Calculate delay as described in the per-renderer WebSocket throttling
-// design doc: https://goo.gl/tldFNn
-base::TimeDelta WebSocketManager::CalculateDelay() const {
-  int64_t f = num_previous_failed_connections_ +
-              num_current_failed_connections_;
-  int64_t s = num_previous_succeeded_connections_ +
-              num_current_succeeded_connections_;
-  int p = num_pending_connections_;
-  return base::TimeDelta::FromMilliseconds(
-      base::RandInt(1000, 5000) *
-      (1 << std::min(p + f / (s + 1), INT64_C(16))) / 65536);
-}
-
 void WebSocketManager::ThrottlingPeriodTimerCallback() {
-  num_previous_failed_connections_ = num_current_failed_connections_;
-  num_current_failed_connections_ = 0;
-
-  num_previous_succeeded_connections_ = num_current_succeeded_connections_;
-  num_current_succeeded_connections_ = 0;
-
-  if (num_pending_connections_ == 0 &&
-      num_previous_failed_connections_ == 0 &&
-      num_previous_succeeded_connections_ == 0) {
+  throttler_.Roll();
+  if (throttler_.IsClean())
     throttling_period_timer_.Stop();
-  }
 }
 
 std::unique_ptr<network::WebSocket> WebSocketManager::CreateWebSocket(
     std::unique_ptr<network::WebSocket::Delegate> delegate,
     network::mojom::WebSocketRequest request,
+    network::WebSocketThrottler::PendingConnection pending_connection_tracker,
     int child_id,
     int frame_id,
     url::Origin origin,
     base::TimeDelta delay) {
   return std::make_unique<network::WebSocket>(
-      std::move(delegate), std::move(request), child_id, frame_id,
+      std::move(delegate), std::move(request),
+      std::move(pending_connection_tracker), child_id, frame_id,
       std::move(origin), delay);
 }
 
@@ -326,22 +293,8 @@ net::URLRequestContext* WebSocketManager::GetURLRequestContext() {
   return url_request_context_getter_->GetURLRequestContext();
 }
 
-void WebSocketManager::OnReceivedResponseFromServer(network::WebSocket* impl) {
-  // The server accepted this WebSocket connection.
-  impl->OnHandshakeSucceeded();
-  --num_pending_connections_;
-  DCHECK_GE(num_pending_connections_, 0);
-  ++num_current_succeeded_connections_;
-}
-
 void WebSocketManager::OnLostConnectionToClient(network::WebSocket* impl) {
   // The client is no longer interested in this WebSocket.
-  if (!impl->handshake_succeeded()) {
-    // Update throttling counters (failure).
-    --num_pending_connections_;
-    DCHECK_GE(num_pending_connections_, 0);
-    ++num_current_failed_connections_;
-  }
   impl->GoAway();
   const auto it = impls_.find(impl);
   DCHECK(it != impls_.end());

content/browser/websockets/websocket_manager.h

@@ -17,6 +17,7 @@
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_context_getter_observer.h"
 #include "services/network/websocket.h"
+#include "services/network/websocket_throttler.h"
 
 namespace content {
 class StoragePartition;
@@ -58,20 +59,19 @@ class CONTENT_EXPORT WebSocketManager
   void DoCreateWebSocket(int frame_id,
                          url::Origin origin,
                          network::mojom::WebSocketRequest request);
-  base::TimeDelta CalculateDelay() const;
   void ThrottlingPeriodTimerCallback();
 
   // This is virtual to support testing.
   virtual std::unique_ptr<network::WebSocket> CreateWebSocket(
       std::unique_ptr<network::WebSocket::Delegate> delegate,
       network::mojom::WebSocketRequest request,
+      network::WebSocketThrottler::PendingConnection pending_connection_tracker,
       int child_id,
       int frame_id,
       url::Origin origin,
       base::TimeDelta delay);
 
   net::URLRequestContext* GetURLRequestContext();
-  void OnReceivedResponseFromServer(network::WebSocket* impl);
   virtual void OnLostConnectionToClient(network::WebSocket* impl);
 
   void ObserveURLRequestContextGetter();
@@ -85,18 +85,7 @@ class CONTENT_EXPORT WebSocketManager
   // Timer and counters for per-renderer WebSocket throttling.
   base::RepeatingTimer throttling_period_timer_;
 
-  // The current number of pending connections.
-  int num_pending_connections_;
-
-  // The number of handshakes that failed in the current and previous time
-  // period.
-  int64_t num_current_succeeded_connections_;
-  int64_t num_previous_succeeded_connections_;
-
-  // The number of handshakes that succeeded in the current and previous time
-  // period.
-  int64_t num_current_failed_connections_;
-  int64_t num_previous_failed_connections_;
+  network::WebSocketPerProcessThrottler throttler_;
 
   bool context_destroyed_;
 

content/browser/websockets/websocket_manager_unittest.cc

@@ -22,14 +22,18 @@ static const int kMagicRenderProcessId = 506116062;
 
 class TestWebSocketImpl : public network::WebSocket {
  public:
-  TestWebSocketImpl(std::unique_ptr<Delegate> delegate,
-                    network::mojom::WebSocketRequest request,
-                    int process_id,
-                    int frame_id,
-                    url::Origin origin,
-                    base::TimeDelta delay)
+  TestWebSocketImpl(
+      std::unique_ptr<Delegate> delegate,
+      network::mojom::WebSocketRequest request,
+      network::WebSocketThrottler::PendingConnection pending_connection_tracker,
+
+      int process_id,
+      int frame_id,
+      url::Origin origin,
+      base::TimeDelta delay)
       : network::WebSocket(std::move(delegate),
                            std::move(request),
+                           std::move(pending_connection_tracker),
                            process_id,
                            frame_id,
                            std::move(origin),
@@ -51,15 +55,20 @@ class TestWebSocketManager : public WebSocketManager {
     return sockets_;
   }
 
-  int num_pending_connections() const {
-    return num_pending_connections_;
+  int64_t num_pending_connections() const {
+    return throttler_.num_pending_connections();
   }
-  int64_t num_failed_connections() const {
-    return num_current_failed_connections_ + num_previous_failed_connections_;
+  int64_t num_current_succeeded_connections() const {
+    return throttler_.num_current_succeeded_connections();
   }
-  int64_t num_succeeded_connections() const {
-    return num_current_succeeded_connections_ +
-           num_previous_succeeded_connections_;
+  int64_t num_previous_succeeded_connections() const {
+    return throttler_.num_previous_succeeded_connections();
+  }
+  int64_t num_current_failed_connections() const {
+    return throttler_.num_current_failed_connections();
+  }
+  int64_t num_previous_failed_connections() const {
+    return throttler_.num_previous_failed_connections();
   }
 
   void DoCreateWebSocket(network::mojom::WebSocketRequest request) {
@@ -71,12 +80,14 @@ class TestWebSocketManager : public WebSocketManager {
   std::unique_ptr<network::WebSocket> CreateWebSocket(
       std::unique_ptr<network::WebSocket::Delegate> delegate,
       network::mojom::WebSocketRequest request,
+      network::WebSocketThrottler::PendingConnection pending_connection_tracker,
       int process_id,
       int frame_id,
       url::Origin origin,
       base::TimeDelta delay) override {
     auto impl = std::make_unique<TestWebSocketImpl>(
-        std::move(delegate), std::move(request), process_id, frame_id,
+        std::move(delegate), std::move(request),
+        std::move(pending_connection_tracker), process_id, frame_id,
         std::move(origin), delay);
     // We keep a vector of sockets here to track their creation order.
     sockets_.push_back(impl.get());
@@ -146,109 +157,19 @@ TEST_F(WebSocketManagerTest, SendFrameButNotConnectedYet) {
   websocket->SendFrame(true, network::mojom::WebSocketMessageType::TEXT, data);
 }
 
-TEST_F(WebSocketManagerTest, DelayFor4thPendingConnectionIsZero) {
-  AddMultipleChannels(4);
-
-  EXPECT_EQ(4, websocket_manager()->num_pending_connections());
-  EXPECT_EQ(0, websocket_manager()->num_failed_connections());
-  EXPECT_EQ(0, websocket_manager()->num_succeeded_connections());
-
-  ASSERT_EQ(4U, websocket_manager()->sockets().size());
-  EXPECT_EQ(base::TimeDelta(), websocket_manager()->sockets()[3]->delay());
-}
-
-TEST_F(WebSocketManagerTest, DelayFor8thPendingConnectionIsNonZero) {
-  AddMultipleChannels(8);
-
-  EXPECT_EQ(8, websocket_manager()->num_pending_connections());
-  EXPECT_EQ(0, websocket_manager()->num_failed_connections());
-  EXPECT_EQ(0, websocket_manager()->num_succeeded_connections());
-
-  ASSERT_EQ(8U, websocket_manager()->sockets().size());
-  EXPECT_LT(base::TimeDelta(), websocket_manager()->sockets()[7]->delay());
-}
-
-TEST_F(WebSocketManagerTest, DelayFor17thPendingConnection) {
-  AddMultipleChannels(17);
-
-  EXPECT_EQ(17, websocket_manager()->num_pending_connections());
-  EXPECT_EQ(0, websocket_manager()->num_failed_connections());
-  EXPECT_EQ(0, websocket_manager()->num_succeeded_connections());
-
-  ASSERT_EQ(17U, websocket_manager()->sockets().size());
-  EXPECT_LE(base::TimeDelta::FromMilliseconds(1000),
-            websocket_manager()->sockets()[16]->delay());
-  EXPECT_GE(base::TimeDelta::FromMilliseconds(5000),
-            websocket_manager()->sockets()[16]->delay());
-}
-
 // The 256th connection is rejected by per-renderer WebSocket throttling.
 // This is not counted as a failure.
 TEST_F(WebSocketManagerTest, Rejects256thPendingConnection) {
   AddMultipleChannels(256);
 
   EXPECT_EQ(255, websocket_manager()->num_pending_connections());
-  EXPECT_EQ(0, websocket_manager()->num_failed_connections());
-  EXPECT_EQ(0, websocket_manager()->num_succeeded_connections());
+  EXPECT_EQ(0, websocket_manager()->num_current_succeeded_connections());
+  EXPECT_EQ(0, websocket_manager()->num_previous_succeeded_connections());
+  EXPECT_EQ(0, websocket_manager()->num_current_failed_connections());
+  EXPECT_EQ(0, websocket_manager()->num_previous_failed_connections());
 
   ASSERT_EQ(255U, websocket_manager()->sockets().size());
 }
 
-TEST_F(WebSocketManagerTest, DelayIsZeroAfter3FailedConnections) {
-  AddAndCancelMultipleChannels(3);
-
-  EXPECT_EQ(0, websocket_manager()->num_pending_connections());
-  EXPECT_EQ(3, websocket_manager()->num_failed_connections());
-  EXPECT_EQ(0, websocket_manager()->num_succeeded_connections());
-
-  AddMultipleChannels(1);
-
-  ASSERT_EQ(1U, websocket_manager()->sockets().size());
-  EXPECT_EQ(base::TimeDelta(), websocket_manager()->sockets()[0]->delay());
-}
-
-TEST_F(WebSocketManagerTest, DelayIsNonZeroAfter7FailedConnections) {
-  AddAndCancelMultipleChannels(7);
-
-  EXPECT_EQ(0, websocket_manager()->num_pending_connections());
-  EXPECT_EQ(7, websocket_manager()->num_failed_connections());
-  EXPECT_EQ(0, websocket_manager()->num_succeeded_connections());
-
-  AddMultipleChannels(1);
-
-  ASSERT_EQ(1U, websocket_manager()->sockets().size());
-  EXPECT_LT(base::TimeDelta(), websocket_manager()->sockets()[0]->delay());
-}
-
-TEST_F(WebSocketManagerTest, DelayAfter16FailedConnections) {
-  AddAndCancelMultipleChannels(16);
-
-  EXPECT_EQ(0, websocket_manager()->num_pending_connections());
-  EXPECT_EQ(16, websocket_manager()->num_failed_connections());
-  EXPECT_EQ(0, websocket_manager()->num_succeeded_connections());
-
-  AddMultipleChannels(1);
-
-  ASSERT_EQ(1U, websocket_manager()->sockets().size());
-  EXPECT_LE(base::TimeDelta::FromMilliseconds(1000),
-            websocket_manager()->sockets()[0]->delay());
-  EXPECT_GE(base::TimeDelta::FromMilliseconds(5000),
-            websocket_manager()->sockets()[0]->delay());
-}
-
-TEST_F(WebSocketManagerTest, NotRejectedAfter255FailedConnections) {
-  AddAndCancelMultipleChannels(255);
-
-  EXPECT_EQ(0, websocket_manager()->num_pending_connections());
-  EXPECT_EQ(255, websocket_manager()->num_failed_connections());
-  EXPECT_EQ(0, websocket_manager()->num_succeeded_connections());
-
-  AddMultipleChannels(1);
-
-  EXPECT_EQ(1, websocket_manager()->num_pending_connections());
-  EXPECT_EQ(255, websocket_manager()->num_failed_connections());
-  EXPECT_EQ(0, websocket_manager()->num_succeeded_connections());
-}
-
 }  // namespace
 }  // namespace content

services/network/BUILD.gn

@@ -90,6 +90,8 @@ component("network_service") {
       "websocket.h",
       "websocket_factory.cc",
       "websocket_factory.h",
+      "websocket_throttler.cc",
+      "websocket_throttler.h",
     ]
   }
 
@@ -163,7 +165,10 @@ source_set("tests") {
   ]
 
   if (!is_ios) {
-    sources += [ "proxy_resolver_factory_mojo_unittest.cc" ]
+    sources += [
+      "proxy_resolver_factory_mojo_unittest.cc",
+      "websocket_throttler_unittest.cc",
+    ]
   }
 
   deps = [

services/network/websocket.cc

@@ -136,7 +136,8 @@ ChannelState WebSocket::WebSocketEventHandler::OnAddChannelResponse(
            << selected_protocol << "\""
            << " extensions=\"" << extensions << "\"";
 
-  impl_->delegate_->OnReceivedResponseFromServer(impl_);
+  impl_->handshake_succeeded_ = true;
+  impl_->pending_connection_tracker_.OnCompleteHandshake();
 
   impl_->client_->OnAddChannelResponse(selected_protocol, extensions);
 
@@ -288,14 +289,17 @@ ChannelState WebSocket::WebSocketEventHandler::OnSSLCertificateError(
   return WebSocketEventInterface::CHANNEL_ALIVE;
 }
 
-WebSocket::WebSocket(std::unique_ptr<Delegate> delegate,
-                     network::mojom::WebSocketRequest request,
-                     int child_id,
-                     int frame_id,
-                     url::Origin origin,
-                     base::TimeDelta delay)
+WebSocket::WebSocket(
+    std::unique_ptr<Delegate> delegate,
+    network::mojom::WebSocketRequest request,
+    WebSocketThrottler::PendingConnection pending_connection_tracker,
+    int child_id,
+    int frame_id,
+    url::Origin origin,
+    base::TimeDelta delay)
     : delegate_(std::move(delegate)),
       binding_(this, std::move(request)),
+      pending_connection_tracker_(std::move(pending_connection_tracker)),
       delay_(delay),
       pending_flow_control_quota_(0),
       child_id_(child_id),

services/network/websocket.h

@@ -18,6 +18,7 @@
 #include "mojo/public/cpp/bindings/binding.h"
 #include "net/websockets/websocket_event_interface.h"
 #include "services/network/public/mojom/websocket.mojom.h"
+#include "services/network/websocket_throttler.h"
 #include "url/origin.h"
 
 class GURL;
@@ -44,7 +45,6 @@ class COMPONENT_EXPORT(NETWORK_SERVICE) WebSocket
     virtual ~Delegate() {}
 
     virtual net::URLRequestContext* GetURLRequestContext() = 0;
-    virtual void OnReceivedResponseFromServer(WebSocket* impl) = 0;
     // This function may delete |impl|.
     virtual void OnLostConnectionToClient(WebSocket* impl) = 0;
     virtual void OnSSLCertificateError(
@@ -65,6 +65,7 @@ class COMPONENT_EXPORT(NETWORK_SERVICE) WebSocket
 
   WebSocket(std::unique_ptr<Delegate> delegate,
             network::mojom::WebSocketRequest request,
+            WebSocketThrottler::PendingConnection pending_connection_tracker,
             int child_id,
             int frame_id,
             url::Origin origin,
@@ -88,7 +89,6 @@ class COMPONENT_EXPORT(NETWORK_SERVICE) WebSocket
   void StartClosingHandshake(uint16_t code, const std::string& reason) override;
 
   bool handshake_succeeded() const { return handshake_succeeded_; }
-  void OnHandshakeSucceeded() { handshake_succeeded_ = true; }
 
  protected:
   class WebSocketEventHandler;
@@ -104,6 +104,8 @@ class COMPONENT_EXPORT(NETWORK_SERVICE) WebSocket
 
   network::mojom::WebSocketClientPtr client_;
 
+  WebSocketThrottler::PendingConnection pending_connection_tracker_;
+
   // The channel we use to send events to the network.
   std::unique_ptr<net::WebSocketChannel> channel_;
 

services/network/websocket_factory.cc

@@ -26,8 +26,6 @@ class WebSocketFactory::Delegate final
     return factory_->context_->GetURLRequestContext();
   }
 
-  void OnReceivedResponseFromServer(WebSocket* impl) override {}
-
   void OnLostConnectionToClient(WebSocket* impl) override {
     factory_->OnLostConnectionToClient(impl);
   }
@@ -100,10 +98,17 @@ void WebSocketFactory::CreateWebSocket(mojom::WebSocketRequest request,
                                        int32_t process_id,
                                        int32_t render_frame_id,
                                        const url::Origin& origin) {
-  base::TimeDelta delay;
+  if (throttler_.HasTooManyPendingConnections(process_id)) {
+    // Too many websockets!
+    request.ResetWithReason(
+        mojom::WebSocket::kInsufficientResources,
+        "Error in connection establishment: net::ERR_INSUFFICIENT_RESOURCES");
+    return;
+  }
   connections_.insert(std::make_unique<WebSocket>(
       std::make_unique<Delegate>(this, process_id), std::move(request),
-      process_id, render_frame_id, origin, delay));
+      throttler_.IssuePendingConnectionTracker(process_id), process_id,
+      render_frame_id, origin, throttler_.CalculateDelay(process_id)));
 }
 
 void WebSocketFactory::OnLostConnectionToClient(WebSocket* impl) {

services/network/websocket_factory.h

@@ -12,6 +12,7 @@
 #include "mojo/public/cpp/bindings/binding.h"
 #include "services/network/public/mojom/websocket.mojom.h"
 #include "services/network/websocket.h"
+#include "services/network/websocket_throttler.h"
 
 namespace url {
 class Origin;
@@ -40,6 +41,8 @@ class WebSocketFactory final : public base::SupportsWeakPtr<WebSocketFactory> {
   // The connections held by this factory.
   std::set<std::unique_ptr<WebSocket>, base::UniquePtrComparator> connections_;
 
+  WebSocketThrottler throttler_;
+
   // |context_| outlives this object.
   NetworkContext* const context_;
 

services/network/websocket_throttler.cc

+// Copyright 2018 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 "services/network/websocket_throttler.h"
+
+#include <algorithm>
+
+#include "base/rand_util.h"
+
+namespace network {
+
+constexpr int WebSocketPerProcessThrottler::kMaxPendingWebSocketConnections;
+
+WebSocketPerProcessThrottler::PendingConnection::PendingConnection(
+    base::WeakPtr<WebSocketPerProcessThrottler> throttler)
+    : throttler_(std::move(throttler)) {
+  DCHECK(throttler_);
+  ++throttler_->num_pending_connections_;
+}
+WebSocketPerProcessThrottler::PendingConnection::PendingConnection(
+    PendingConnection&& other)
+    : throttler_(std::move(other.throttler_)) {
+  other.throttler_ = nullptr;
+}
+WebSocketPerProcessThrottler::PendingConnection::~PendingConnection() {
+  if (!throttler_)
+    return;
+
+  --throttler_->num_pending_connections_;
+  ++throttler_->num_current_failed_connections_;
+}
+
+void WebSocketPerProcessThrottler::PendingConnection::OnCompleteHandshake() {
+  DCHECK(throttler_);
+
+  --throttler_->num_pending_connections_;
+  ++throttler_->num_current_succeeded_connections_;
+  throttler_ = nullptr;
+}
+
+WebSocketPerProcessThrottler::WebSocketPerProcessThrottler() {}
+WebSocketPerProcessThrottler::~WebSocketPerProcessThrottler() {}
+
+base::TimeDelta WebSocketPerProcessThrottler::CalculateDelay() const {
+  int64_t f =
+      num_previous_failed_connections_ + num_current_failed_connections_;
+  int64_t s =
+      num_previous_succeeded_connections_ + num_current_succeeded_connections_;
+  int p = num_pending_connections_;
+  return base::TimeDelta::FromMilliseconds(
+      base::RandInt(1000, 5000) *
+      (1 << std::min(p + f / (s + 1), INT64_C(16))) / 65536);
+  return base::TimeDelta();
+}
+
+WebSocketPerProcessThrottler::PendingConnection
+WebSocketPerProcessThrottler::IssuePendingConnectionTracker() {
+  return PendingConnection(AsWeakPtr());
+}
+
+bool WebSocketPerProcessThrottler::IsClean() const {
+  return num_pending_connections_ == 0 &&
+         num_current_succeeded_connections_ == 0 &&
+         num_previous_succeeded_connections_ == 0 &&
+         num_current_failed_connections_ == 0 &&
+         num_previous_succeeded_connections_ == 0;
+}
+
+void WebSocketPerProcessThrottler::Roll() {
+  num_previous_succeeded_connections_ = num_current_succeeded_connections_;
+  num_previous_failed_connections_ = num_current_failed_connections_;
+
+  num_current_succeeded_connections_ = 0;
+  num_current_failed_connections_ = 0;
+}
+
+WebSocketThrottler::WebSocketThrottler() {}
+WebSocketThrottler::~WebSocketThrottler() {}
+
+bool WebSocketThrottler::HasTooManyPendingConnections(int process_id) const {
+  auto it = per_process_throttlers_.find(process_id);
+  if (it == per_process_throttlers_.end())
+    return false;
+
+  return it->second->HasTooManyPendingConnections();
+}
+
+base::TimeDelta WebSocketThrottler::CalculateDelay(int process_id) const {
+  auto it = per_process_throttlers_.find(process_id);
+  if (it == per_process_throttlers_.end())
+    return base::TimeDelta();
+
+  return it->second->CalculateDelay();
+}
+
+WebSocketThrottler::PendingConnection
+WebSocketThrottler::IssuePendingConnectionTracker(int process_id) {
+  auto it = per_process_throttlers_.find(process_id);
+  if (it == per_process_throttlers_.end()) {
+    it = per_process_throttlers_
+             .insert(std::make_pair(
+                 process_id, std::make_unique<WebSocketPerProcessThrottler>()))
+             .first;
+  }
+
+  if (!throttling_period_timer_.IsRunning()) {
+    throttling_period_timer_.Start(FROM_HERE, base::TimeDelta::FromMinutes(2),
+                                   this, &WebSocketThrottler::OnTimer);
+  }
+  return it->second->IssuePendingConnectionTracker();
+}
+
+void WebSocketThrottler::OnTimer() {
+  auto it = per_process_throttlers_.begin();
+  while (it != per_process_throttlers_.end()) {
+    it->second->Roll();
+    if (it->second->IsClean()) {
+      // We don't need the entry. Erase it.
+      it = per_process_throttlers_.erase(it);
+    } else {
+      ++it;
+    }
+  }
+  if (per_process_throttlers_.empty())
+    throttling_period_timer_.Stop();
+}
+
+}  // namespace network

services/network/websocket_throttler.h

+// Copyright 2018 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 SERVICES_NETWORK_WEBSOCKET_THROTTLER_H_
+#define SERVICES_NETWORK_WEBSOCKET_THROTTLER_H_
+
+#include <stdint.h>
+#include <map>
+#include <memory>
+
+#include "base/component_export.h"
+#include "base/memory/weak_ptr.h"
+#include "base/time/time.h"
+#include "base/timer/timer.h"
+
+namespace network {
+
+// WebSocketPerProcessThrottler provies a throttling functionality per
+// renderer process. See https://goo.gl/tldFNn.
+class COMPONENT_EXPORT(NETWORK_SERVICE) WebSocketPerProcessThrottler final
+    : public base::SupportsWeakPtr<WebSocketPerProcessThrottler> {
+ public:
+  // A PendingConnection represents a connection that has not finished a
+  // handshake.
+  //
+  // Destroying a PendingConnection whose OnCompleteHandshake has not been
+  // called represents a handshake failure (including going away during
+  // handshake).
+  class COMPONENT_EXPORT(NETWORK_SERVICE) PendingConnection final {
+   public:
+    // |throttler| cannot be null.
+    explicit PendingConnection(
+        base::WeakPtr<WebSocketPerProcessThrottler> throttler);
+    PendingConnection(PendingConnection&& other);
+    ~PendingConnection();
+
+    // Called when the hansdhake finishes sucessfully.
+    void OnCompleteHandshake();
+
+   private:
+    base::WeakPtr<WebSocketPerProcessThrottler> throttler_;
+
+    DISALLOW_COPY_AND_ASSIGN(PendingConnection);
+  };
+
+  WebSocketPerProcessThrottler();
+  ~WebSocketPerProcessThrottler();
+
+  // Returns if there are too many pending connections.
+  bool HasTooManyPendingConnections() const {
+    return num_pending_connections_ >= kMaxPendingWebSocketConnections;
+  }
+
+  // Returns the delay which should be used to throttle opening websocket
+  // connections.
+  base::TimeDelta CalculateDelay() const;
+
+  // Issues an object which represents a pending connection.
+  PendingConnection IssuePendingConnectionTracker();
+
+  // Returns true if this throttler is clean, i.e., we can restore the internal
+  // state by simply creating a new object.
+  bool IsClean() const;
+
+  // Copies the succeeded / failed counters for the current period to the
+  // ones for the previous period, and zeroes them.
+  void Roll();
+
+  int64_t num_pending_connections() const { return num_pending_connections_; }
+  int64_t num_current_succeeded_connections() const {
+    return num_current_succeeded_connections_;
+  }
+  int64_t num_previous_succeeded_connections() const {
+    return num_previous_succeeded_connections_;
+  }
+  int64_t num_current_failed_connections() const {
+    return num_current_failed_connections_;
+  }
+  int64_t num_previous_failed_connections() const {
+    return num_previous_failed_connections_;
+  }
+
+ private:
+  // The current number of pending connections.
+  int num_pending_connections_ = 0;
+
+  // The number of handshakes that failed in the clurrent and previous time
+  // period.
+  int64_t num_current_succeeded_connections_ = 0;
+  int64_t num_previous_succeeded_connections_ = 0;
+
+  // The number of handshakes that succeeded in the current and previous time
+  // period.
+  int64_t num_current_failed_connections_ = 0;
+  int64_t num_previous_failed_connections_ = 0;
+
+  static constexpr int kMaxPendingWebSocketConnections = 255;
+
+  DISALLOW_COPY_AND_ASSIGN(WebSocketPerProcessThrottler);
+};
+
+// This class is for throttling WebSocket connections. WebSocketThrottler is
+// a set of per-renderer throttlers.
+// This class is only used in the network service. content::WebSocketManager
+// uses WebSocketPerProcessThrottler directly.
+class COMPONENT_EXPORT(NETWORK_SERVICE) WebSocketThrottler final {
+ public:
+  using PendingConnection = WebSocketPerProcessThrottler::PendingConnection;
+
+  WebSocketThrottler();
+  ~WebSocketThrottler();
+
+  // Returns true if there are too many pending connections for |process_id|.
+  bool HasTooManyPendingConnections(int process_id) const;
+
+  // Calculates connection delay for |process_id|.
+  base::TimeDelta CalculateDelay(int process_id) const;
+
+  // Returns a pending connection for |process_id|. This function can be called
+  // only when |HasTooManyPendingConnections(process_id)| is false.
+  PendingConnection IssuePendingConnectionTracker(int process_id);
+
+  size_t GetSizeForTesting() const { return per_process_throttlers_.size(); }
+
+ private:
+  void OnTimer();
+
+  std::map<int, std::unique_ptr<WebSocketPerProcessThrottler>>
+      per_process_throttlers_;
+  base::RepeatingTimer throttling_period_timer_;
+
+  DISALLOW_COPY_AND_ASSIGN(WebSocketThrottler);
+};
+
+}  // namespace network
+
+#endif  // SERVICES_NETWORK_WEBSOCKET_THROTTLER_H_

third_party/WebKit/LayoutTests/FlagExpectations/enable-features=NetworkService

@@ -87,8 +87,6 @@ crbug.com/764474 plugins/plugin-document-back-forward.html [ Crash Failure Timeo
 # Started failing @ r529490
 Bug(none) virtual/layout_ng/fast/inline/positioned-object-between-replaced-elements.html [ Failure ]
 
-# http://crbug.com/721400 get WebSockets working with network service.
-crbug.com/721400 http/tests/websocket/multiple-connections-throttled.html [ Failure ]
-crbug.com/721400 http/tests/devtools/websocket/websocket-handshake.js [ Failure ]
+crbug.com/825687 http/tests/devtools/websocket/websocket-handshake.js [ Failure ]
 
 crbug.com/816556 external/wpt/html/semantics/text-level-semantics/the-a-element/a-download-click-404.html [ Failure ]