Reduce the complexity of WebSocketThrottle's wakeup code

net/websockets/websocket_job_unittest.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 "net/websockets/websocket_job.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 374 matching lines @@
     // MockHostResolver resolves all hosts to 127.0.0.1; however, when we create
     // a WebSocketJob purely to block another one in a throttling test, we don't
     // perform a real connect. In that case, the following address is used
     // instead.
     IPAddressNumber ip;
     ParseIPLiteralToNumber("127.0.0.1", &ip);
     websocket_->addresses_ = AddressList::CreateFromIPAddress(ip, 80);
   }
   void SkipToConnecting() {
     websocket_->state_ = WebSocketJob::CONNECTING;
-    WebSocketThrottle::GetInstance()->PutInQueue(websocket_.get());
+    ASSERT_TRUE(WebSocketThrottle::GetInstance()->PutInQueue(websocket_.get()));
   }
   WebSocketJob::State GetWebSocketJobState() {
     return websocket_->state_;
   }
   void CloseWebSocketJob() {
     if (websocket_->socket_.get()) {
       websocket_->socket_->DetachDelegate();
       WebSocketThrottle::GetInstance()->RemoveFromQueue(websocket_.get());
     }
     websocket_->state_ = WebSocketJob::CLOSED;
@@ skipping 19 matching lines @@
   }
 
   void TestSimpleHandshake();
   void TestSlowHandshake();
   void TestHandshakeWithCookie();
   void TestHandshakeWithCookieButNotAllowed();
   void TestHSTSUpgrade();
   void TestInvalidSendData();
   void TestConnectByWebSocket(ThrottlingOption throttling);
   void TestConnectBySpdy(SpdyOption spdy, ThrottlingOption throttling);
+  void TestThrottlingLimit();
 
   SpdyWebSocketTestUtil spdy_util_;
   StreamType stream_type_;
   scoped_refptr<MockCookieStore> cookie_store_;
   scoped_ptr<MockURLRequestContext> context_;
   scoped_refptr<WebSocketJob> websocket_;
   scoped_refptr<SocketStream> socket_;
   scoped_ptr<MockClientSocketFactory> socket_factory_;
   scoped_ptr<OrderedSocketData> data_;
   TestCompletionCallback sync_test_callback_;
@@ skipping 369 matching lines @@
       base::Bind(&WebSocketJobTest::DoSendData, base::Unretained(test)));
   delegate.SetOnClose(
       base::Bind(&WebSocketJobTest::DoSync, base::Unretained(test)));
   InitWebSocketJob(url, &delegate, STREAM_SOCKET);
 
   scoped_refptr<WebSocketJob> block_websocket;
   if (throttling == THROTTLING_ON) {
     // Create former WebSocket object which obstructs the latter one.
     block_websocket = new WebSocketJob(NULL);
     block_websocket->addresses_ = AddressList(websocket_->address_list());
-    WebSocketThrottle::GetInstance()->PutInQueue(block_websocket.get());
+    ASSERT_TRUE(
+        WebSocketThrottle::GetInstance()->PutInQueue(block_websocket.get()));
   }
 
   websocket_->Connect();
 
   if (throttling == THROTTLING_ON) {
     EXPECT_EQ(OK, WaitForResult());
     EXPECT_TRUE(websocket_->IsWaiting());
 
     // Remove the former WebSocket object from throttling queue to unblock the
     // latter.
+    block_websocket->state_ = WebSocketJob::CLOSED;
     WebSocketThrottle::GetInstance()->RemoveFromQueue(block_websocket.get());
-    block_websocket->state_ = WebSocketJob::CLOSED;
     block_websocket = NULL;
-    WebSocketThrottle::GetInstance()->WakeupSocketIfNecessary();
   }
 
   EXPECT_EQ(OK, WaitForResult());
   EXPECT_TRUE(data_->at_read_eof());
   EXPECT_TRUE(data_->at_write_eof());
   EXPECT_EQ(WebSocketJob::CLOSED, GetWebSocketJobState());
 }
 
 void WebSocketJobTest::TestConnectBySpdy(
     SpdyOption spdy, ThrottlingOption throttling) {
@@ skipping 94 matching lines @@
       base::Bind(&WebSocketJobTest::DoSendData, base::Unretained(test)));
   delegate.SetOnClose(
       base::Bind(&WebSocketJobTest::DoSync, base::Unretained(test)));
   InitWebSocketJob(url, &delegate, STREAM_SPDY_WEBSOCKET);
 
   scoped_refptr<WebSocketJob> block_websocket;
   if (throttling == THROTTLING_ON) {
     // Create former WebSocket object which obstructs the latter one.
     block_websocket = new WebSocketJob(NULL);
     block_websocket->addresses_ = AddressList(websocket_->address_list());
-    WebSocketThrottle::GetInstance()->PutInQueue(block_websocket.get());
+    ASSERT_TRUE(
+        WebSocketThrottle::GetInstance()->PutInQueue(block_websocket.get()));
   }
 
   websocket_->Connect();
 
   if (throttling == THROTTLING_ON) {
     EXPECT_EQ(OK, WaitForResult());
     EXPECT_TRUE(websocket_->IsWaiting());
 
     // Remove the former WebSocket object from throttling queue to unblock the
     // latter.
+    block_websocket->state_ = WebSocketJob::CLOSED;
     WebSocketThrottle::GetInstance()->RemoveFromQueue(block_websocket.get());
-    block_websocket->state_ = WebSocketJob::CLOSED;
     block_websocket = NULL;
-    WebSocketThrottle::GetInstance()->WakeupSocketIfNecessary();
   }
 
   EXPECT_EQ(OK, WaitForResult());
   EXPECT_TRUE(data_->at_read_eof());
   EXPECT_TRUE(data_->at_write_eof());
   EXPECT_EQ(WebSocketJob::CLOSED, GetWebSocketJobState());
 }
 
+void WebSocketJobTest::TestThrottlingLimit() {
+  std::vector<scoped_refptr<WebSocketJob> > jobs;
+  const int kMaxWebSocketJobsThrottled = 1024;
+  IPAddressNumber ip;
+  ParseIPLiteralToNumber("127.0.0.1", &ip);
+  for (int i = 0; i < kMaxWebSocketJobsThrottled + 1; ++i) {
+    scoped_refptr<WebSocketJob> job = new WebSocketJob(NULL);
+    job->addresses_ = AddressList(AddressList::CreateFromIPAddress(ip, 80));
+    if (i >= kMaxWebSocketJobsThrottled)
+      EXPECT_FALSE(WebSocketThrottle::GetInstance()->PutInQueue(job));
+    else
+      EXPECT_TRUE(WebSocketThrottle::GetInstance()->PutInQueue(job));
+    jobs.push_back(job);
+  }
+
+  // Close the jobs in reverse order. Otherwise, We need to make them prepared
+  // for Wakeup call.
+  for (std::vector<scoped_refptr<WebSocketJob> >::reverse_iterator iter =
+           jobs.rbegin();
+       iter != jobs.rend();
+       ++iter) {
+    WebSocketJob* job = (*iter).get();
+    job->state_ = WebSocketJob::CLOSED;
+    WebSocketThrottle::GetInstance()->RemoveFromQueue(job);
+  }
+}
+
 // Execute tests in both spdy-disabled mode and spdy-enabled mode.
 TEST_P(WebSocketJobTest, SimpleHandshake) {
   WebSocketJob::set_websocket_over_spdy_enabled(false);
   TestSimpleHandshake();
 }
 
 TEST_P(WebSocketJobTest, SlowHandshake) {
   WebSocketJob::set_websocket_over_spdy_enabled(false);
   TestSlowHandshake();
 }
@@ skipping 66 matching lines @@
 TEST_P(WebSocketJobTest, ConnectBySpdySpdyEnabled) {
   WebSocketJob::set_websocket_over_spdy_enabled(true);
   TestConnectBySpdy(SPDY_ON, THROTTLING_OFF);
 }
 
 TEST_P(WebSocketJobTest, ThrottlingWebSocket) {
   WebSocketJob::set_websocket_over_spdy_enabled(false);
   TestConnectByWebSocket(THROTTLING_ON);
 }
 
+TEST_P(WebSocketJobTest, ThrottlingMaxNumberOfThrottledJobLimit) {
+  TestThrottlingLimit();
+}
+
 TEST_P(WebSocketJobTest, ThrottlingWebSocketSpdyEnabled) {
   WebSocketJob::set_websocket_over_spdy_enabled(true);
   TestConnectByWebSocket(THROTTLING_ON);
 }
 
 TEST_P(WebSocketJobTest, ThrottlingSpdy) {
   WebSocketJob::set_websocket_over_spdy_enabled(false);
   TestConnectBySpdy(SPDY_OFF, THROTTLING_ON);
 }
 
 TEST_P(WebSocketJobTest, ThrottlingSpdySpdyEnabled) {
   WebSocketJob::set_websocket_over_spdy_enabled(true);
   TestConnectBySpdy(SPDY_ON, THROTTLING_ON);
 }
 
 // TODO(toyoshim): Add tests to verify throttling, SPDY stream limitation.
 // TODO(toyoshim,yutak): Add tests to verify closing handshake.
 }  // namespace net