Add a cap of six in-flight requests per host to the ResourceScheduler

content/browser/loader/resource_scheduler_unittest.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 "content/browser/loader/resource_scheduler.h"
 
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/browser/browser_thread_impl.h"
@@ skipping 300 matching lines @@
 
 TEST_F(ResourceSchedulerTest, LimitedNumberOfDelayableRequestsInFlight) {
   // We only load low priority resources if there's a body.
   scheduler_.OnWillInsertBody(kChildId, kRouteId);
 
   // Throw in one high priority request to make sure that's not a factor.
   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
   EXPECT_TRUE(high->started());
 
   const int kMaxNumDelayableRequestsPerClient = 10;  // Should match the .cc.
-  ScopedVector<TestRequest> lows;
-  for (int i = 0; i < kMaxNumDelayableRequestsPerClient; ++i) {
+  const int kMaxNumDelayableRequestsPerHost = 6;
+  ScopedVector<TestRequest> lows_singlehost;
+  // Queue up to the per-host limit (we subtract the current high-pri request).
+  for (int i = 0; i < kMaxNumDelayableRequestsPerHost - 1; ++i) {
     string url = "http://host/low" + base::IntToString(i);
-    lows.push_back(NewRequest(url.c_str(), net::LOWEST));
-    EXPECT_TRUE(lows[i]->started());
+    lows_singlehost.push_back(NewRequest(url.c_str(), net::LOWEST));
+    EXPECT_TRUE(lows_singlehost[i]->started());
   }
 
-  scoped_ptr<TestRequest> last(NewRequest("http://host/last", net::LOWEST));
-  EXPECT_FALSE(last->started());
+  scoped_ptr<TestRequest> second_last_singlehost(NewRequest("http://host/last",
+                                                     net::LOWEST));

[James Simonsen, 2013/11/13 01:26:23]

nit: fix indenting

[oystein (OOO til 10th of July), 2013/11/14 00:19:07]

Done.

+  scoped_ptr<TestRequest> last_singlehost(NewRequest("http://host/s_last",
+                                                     net::LOWEST));
+
+  EXPECT_FALSE(second_last_singlehost->started());
   high.reset();
-  EXPECT_FALSE(last->started());
-  lows.erase(lows.begin());
-  EXPECT_TRUE(last->started());
+  EXPECT_TRUE(second_last_singlehost->started());
+  EXPECT_FALSE(last_singlehost->started());
+  lows_singlehost.erase(lows_singlehost.begin());
+  EXPECT_TRUE(last_singlehost->started());
+
+  // Queue more requests from different hosts until we reach the total limit.
+  int expected_slots_left =
+      kMaxNumDelayableRequestsPerClient - kMaxNumDelayableRequestsPerHost;
+  EXPECT_GT(expected_slots_left, 0);
+  ScopedVector<TestRequest> lows_differenthosts;
+  for (int i = 0; i < expected_slots_left; ++i) {
+    string url = "http://host" + base::IntToString(i) + "/low";
+    lows_differenthosts.push_back(NewRequest(url.c_str(), net::LOWEST));
+    EXPECT_TRUE(lows_differenthosts[i]->started());
+  }
+
+  scoped_ptr<TestRequest> last_differenthost(NewRequest("http://host_new/last",
+                                                     net::LOWEST));

[James Simonsen, 2013/11/13 01:26:23]

indent

[oystein (OOO til 10th of July), 2013/11/14 00:19:07]

Done.

+  EXPECT_FALSE(last_differenthost->started());
 }
 
 TEST_F(ResourceSchedulerTest, RaisePriorityAndStart) {
   // Dummies to enforce scheduling.
   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
   scoped_ptr<TestRequest> low(NewRequest("http://host/req", net::LOWEST));
 
   scoped_ptr<TestRequest> request(NewRequest("http://host/req", net::LOWEST));
   EXPECT_FALSE(request->started());
 
@@ skipping 40 matching lines @@
   ChangeRequestPriority(request.get(), net::IDLE);
   EXPECT_FALSE(request->started());
   EXPECT_FALSE(idle->started());
 
   const int kMaxNumDelayableRequestsPerClient = 10;  // Should match the .cc.
   // 2 fewer filler requests: 1 for the "low" dummy at the start, and 1 for the
   // one at the end, which will be tested.
   const int kNumFillerRequests = kMaxNumDelayableRequestsPerClient - 2;
   ScopedVector<TestRequest> lows;
   for (int i = 0; i < kNumFillerRequests; ++i) {
-    string url = "http://host/low" + base::IntToString(i);
+    string url = "http://host" + base::IntToString(i) + "/low";
     lows.push_back(NewRequest(url.c_str(), net::LOWEST));
   }
 
   scheduler_.OnWillInsertBody(kChildId, kRouteId);
   EXPECT_FALSE(request->started());
   EXPECT_TRUE(idle->started());
 }
 
 TEST_F(ResourceSchedulerTest, ReprioritizedRequestGoesToBackOfQueue) {
   // Dummies to enforce scheduling.
@@ skipping 31 matching lines @@
   scoped_ptr<TestRequest> low(NewRequest("http://host/high", net::LOWEST));
 
   scoped_ptr<TestRequest> request(
       NewRequest("chrome-extension://req", net::LOWEST));
   EXPECT_TRUE(request->started());
 }
 
 }  // unnamed namespace
 
 }  // namespace content