Add a delay when unlocking WebSocket endpoints.

net/socket/websocket_endpoint_lock_manager.cc

 // Copyright 2014 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/socket/websocket_endpoint_lock_manager.h"
 
 #include <utility>
 
+#include "base/bind.h"
 #include "base/logging.h"
+#include "base/message_loop/message_loop.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 
 namespace net {
 
+namespace {
+
+// This delay prevents DoS attacks.
+// TODO(ricea): Replace this with randomised truncated exponential backoff.
+// See crbug.com/377613.
+const int kUnlockDelayInMs = 10;
+
+}  // namespace
+
 WebSocketEndpointLockManager::Waiter::~Waiter() {
   if (next()) {
     DCHECK(previous());
     RemoveFromList();
   }
 }
 
 WebSocketEndpointLockManager* WebSocketEndpointLockManager::GetInstance() {
   return Singleton<WebSocketEndpointLockManager>::get();
 }
@@ skipping 33 matching lines @@
   SocketLockInfoMap::iterator socket_it = socket_lock_info_map_.find(socket);
   if (socket_it == socket_lock_info_map_.end())
     return;
 
   LockInfoMap::iterator lock_info_it = socket_it->second;
 
   DVLOG(3) << "Unlocking (StreamSocket*)" << socket << " for "
            << lock_info_it->first.ToString() << " ("
            << socket_lock_info_map_.size() << " socket(s) left)";
   socket_lock_info_map_.erase(socket_it);
-  DCHECK(socket == lock_info_it->second.socket);
+  DCHECK_EQ(socket, lock_info_it->second.socket);
   lock_info_it->second.socket = NULL;
-  UnlockEndpointByIterator(lock_info_it);
+  UnlockEndpointAfterDelay(lock_info_it->first);
 }
 
 void WebSocketEndpointLockManager::UnlockEndpoint(const IPEndPoint& endpoint) {
   LockInfoMap::iterator lock_info_it = lock_info_map_.find(endpoint);
   if (lock_info_it == lock_info_map_.end())
     return;
-
-  UnlockEndpointByIterator(lock_info_it);
+  if (lock_info_it->second.socket)
+    EraseSocket(lock_info_it);
+  UnlockEndpointAfterDelay(endpoint);
 }
 
 bool WebSocketEndpointLockManager::IsEmpty() const {
   return lock_info_map_.empty() && socket_lock_info_map_.empty();
 }
 
+base::TimeDelta WebSocketEndpointLockManager::SetUnlockDelayForTesting(
+    base::TimeDelta new_delay) {
+  base::TimeDelta old_delay = unlock_delay_;
+  unlock_delay_ = new_delay;
+  return old_delay;
+}
+
 WebSocketEndpointLockManager::LockInfo::LockInfo() : socket(NULL) {}
 WebSocketEndpointLockManager::LockInfo::~LockInfo() {
   DCHECK(!socket);
 }
 
 WebSocketEndpointLockManager::LockInfo::LockInfo(const LockInfo& rhs)
     : socket(rhs.socket) {
   DCHECK(!rhs.queue);
 }
 
-WebSocketEndpointLockManager::WebSocketEndpointLockManager() {}
+WebSocketEndpointLockManager::WebSocketEndpointLockManager()
+    : unlock_delay_(base::TimeDelta::FromMilliseconds(kUnlockDelayInMs)),
+      pending_unlock_count_(0),
+      weak_factory_(this) {
+}
 
 WebSocketEndpointLockManager::~WebSocketEndpointLockManager() {
-  DCHECK(lock_info_map_.empty());
+  DCHECK_EQ(lock_info_map_.size(), pending_unlock_count_);
   DCHECK(socket_lock_info_map_.empty());
 }
 
-void WebSocketEndpointLockManager::UnlockEndpointByIterator(
-    LockInfoMap::iterator lock_info_it) {
-  if (lock_info_it->second.socket)
-    EraseSocket(lock_info_it);
+void WebSocketEndpointLockManager::UnlockEndpointAfterDelay(
+    const IPEndPoint& endpoint) {
+  DVLOG(3) << "Delaying " << unlock_delay_.InMilliseconds()
+           << "ms before unlocking endpoint " << endpoint.ToString();
+  ++pending_unlock_count_;
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&WebSocketEndpointLockManager::DelayedUnlockEndpoint,
+                 weak_factory_.GetWeakPtr(), endpoint),
+      unlock_delay_);
+}
+
+void WebSocketEndpointLockManager::DelayedUnlockEndpoint(
+    const IPEndPoint& endpoint) {
+  LockInfoMap::iterator lock_info_it = lock_info_map_.find(endpoint);
+  DCHECK_GT(pending_unlock_count_, 0U);
+  --pending_unlock_count_;
+  if (lock_info_it == lock_info_map_.end())
+    return;
+  DCHECK(!lock_info_it->second.socket);
   LockInfo::WaiterQueue* queue = lock_info_it->second.queue.get();
   DCHECK(queue);
   if (queue->empty()) {
     DVLOG(3) << "Unlocking endpoint " << lock_info_it->first.ToString();
     lock_info_map_.erase(lock_info_it);
     return;
   }
 
   DVLOG(3) << "Unlocking endpoint " << lock_info_it->first.ToString()
            << " and activating next waiter";
   Waiter* next_job = queue->head()->value();
   next_job->RemoveFromList();
-  // This must be last to minimise the excitement caused by re-entrancy.
   next_job->GotEndpointLock();
 }
 
 void WebSocketEndpointLockManager::EraseSocket(
     LockInfoMap::iterator lock_info_it) {
   DVLOG(3) << "Removing (StreamSocket*)" << lock_info_it->second.socket
            << " for " << lock_info_it->first.ToString() << " ("
            << socket_lock_info_map_.size() << " socket(s) left)";
   size_t erased = socket_lock_info_map_.erase(lock_info_it->second.socket);
   DCHECK_EQ(1U, erased);
   lock_info_it->second.socket = NULL;
 }
 
 }  // namespace net