Reduce the complexity of WebSocketThrottle's wakeup code

net/websockets/websocket_job.cc

 // Copyright (c) 2012 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/websockets/websocket_job.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 130 matching lines @@
 }
 
 void WebSocketJob::RestartWithAuth(const AuthCredentials& credentials) {
   state_ = CONNECTING;
   socket_->RestartWithAuth(credentials);
 }
 
 void WebSocketJob::DetachDelegate() {
   state_ = CLOSED;
   WebSocketThrottle::GetInstance()->RemoveFromQueue(this);
-  WebSocketThrottle::GetInstance()->WakeupSocketIfNecessary();
 
   scoped_refptr<WebSocketJob> protect(this);
   weak_ptr_factory_.InvalidateWeakPtrs();
   weak_ptr_factory_for_send_pending_.InvalidateWeakPtrs();
 
   delegate_ = NULL;
   if (socket_.get())
     socket_->DetachDelegate();
   socket_ = NULL;
   if (!callback_.is_null()) {
     waiting_ = false;
     callback_.Reset();
     Release();  // Balanced with OnStartOpenConnection().
   }
 }
 
 int WebSocketJob::OnStartOpenConnection(
     SocketStream* socket, const CompletionCallback& callback) {
   DCHECK(callback_.is_null());
   state_ = CONNECTING;
+
   addresses_ = socket->address_list();
-  WebSocketThrottle::GetInstance()->PutInQueue(this);
+  if (!WebSocketThrottle::GetInstance()->PutInQueue(this)) {
+    return ERR_WS_THROTTLE_QUEUE_TOO_LARGE;
+  }
+
   if (delegate_) {
     int result = delegate_->OnStartOpenConnection(socket, callback);
     DCHECK_EQ(OK, result);
   }
   if (waiting_) {
     // PutInQueue() may set |waiting_| true for throttling. In this case,
     // Wakeup() will be called later.
     callback_ = callback;
     AddRef();  // Balanced when callback_ is cleared.
     return ERR_IO_PENDING;
@@ skipping 55 matching lines @@
     return;
   }
   DCHECK(state_ == OPEN || state_ == CLOSING);
   if (delegate_ && len > 0)
     delegate_->OnReceivedData(socket, data, len);
 }
 
 void WebSocketJob::OnClose(SocketStream* socket) {
   state_ = CLOSED;
   WebSocketThrottle::GetInstance()->RemoveFromQueue(this);
-  WebSocketThrottle::GetInstance()->WakeupSocketIfNecessary();
 
   scoped_refptr<WebSocketJob> protect(this);
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   SocketStream::Delegate* delegate = delegate_;
   delegate_ = NULL;
   socket_ = NULL;
   if (!callback_.is_null()) {
     waiting_ = false;
     callback_.Reset();
@@ skipping 230 matching lines @@
   received_data_after_handshake_.clear();
 
   state_ = OPEN;
 
   DCHECK(!received_data.empty());
   if (delegate_)
     delegate_->OnReceivedData(
         socket_.get(), &received_data.front(), received_data.size());
 
   WebSocketThrottle::GetInstance()->RemoveFromQueue(this);
-  WebSocketThrottle::GetInstance()->WakeupSocketIfNecessary();
 }
 
 void WebSocketJob::SaveNextCookie() {
   if (!socket_.get() || !delegate_ || state_ != CONNECTING)
     return;
 
   callback_pending_ = false;
   save_next_cookie_running_ = true;
 
   if (socket_->context()->cookie_store()) {
@@ skipping 184 matching lines @@
 
   scoped_refptr<IOBufferWithSize> next_buffer = send_buffer_queue_.front();
   send_buffer_queue_.pop_front();
   current_send_buffer_ =
       new DrainableIOBuffer(next_buffer.get(), next_buffer->size());
   SendDataInternal(current_send_buffer_->data(),
                    current_send_buffer_->BytesRemaining());
 }
 
 }  // namespace net