Delay resource scheduling decisions until network access.

content/browser/loader/resource_scheduler_unittest.cc

Index: content/browser/loader/resource_scheduler_unittest.cc
diff --git a/content/browser/loader/resource_scheduler_unittest.cc b/content/browser/loader/resource_scheduler_unittest.cc
index 9c7fe92250fa5f903d9041d581f9c23f1d8e0685..6eb9f2551e16f4c07f6c4364c7f057bc8eb90be4 100644
--- a/content/browser/loader/resource_scheduler_unittest.cc
+++ b/content/browser/loader/resource_scheduler_unittest.cc
@@ -52,7 +52,10 @@ class TestRequest : public ResourceController {
   TestRequest(scoped_ptr<net::URLRequest> url_request,
               scoped_ptr<ResourceThrottle> throttle,
               ResourceScheduler* scheduler)
-      : started_(false),
+      : starting_(false),
+        started_(false),
+        sending_(false),
+        sent_(false),
         url_request_(std::move(url_request)),
         throttle_(std::move(throttle)),
         scheduler_(scheduler) {
@@ -65,11 +68,20 @@ class TestRequest : public ResourceController {
   }
 
   bool started() const { return started_; }
+  bool sent() const { return sent_; }
 
   void Start() {
     bool deferred = false;
     throttle_->WillStartRequest(&deferred);
     started_ = !deferred;
+    starting_ = !started_;
+  }
+
+  void Send() {

[mmenke, 2016/02/25 18:09:51]

I want to spend some time mulling over this change...This way of testing
requests seems pretty hideous to me, and adding more weirdness to it doesn't
seem like a good direction to me.

+    bool deferred = false;
+    throttle_->WillStartUsingNetwork(&deferred);
+    sent_ = !deferred;
+    sending_ = !sent_;
   }
 
   void ChangePriority(net::RequestPriority new_priority, int intra_priority) {
@@ -88,10 +100,19 @@ class TestRequest : public ResourceController {
   // ResourceController interface:
   void CancelAndIgnore() override {}
   void CancelWithError(int error_code) override {}
-  void Resume() override { started_ = true; }
+  void Resume() override {
+    if (starting_) {
+      started_ = true;
+    } else if (sending_) {
+      sent_ = true;
+    }
+  }
 
  private:
+  bool starting_;
   bool started_;
+  bool sending_;
+  bool sent_;
   scoped_ptr<net::URLRequest> url_request_;
   scoped_ptr<ResourceThrottle> throttle_;
   ResourceScheduler* scheduler_;
@@ -234,6 +255,8 @@ class ResourceSchedulerTest : public testing::Test {
     TestRequest* request = new TestRequest(std::move(url_request),
                                            std::move(throttle), scheduler());
     request->Start();
+    EXPECT_TRUE(request->started());
+    request->Send();

[mmenke, 2016/02/25 18:09:51]

We have four types of requests now:

1) Those that have not yet reached WillStartUsingNetwork
2) Those that have reached it, and were let through immediately.
3) Those that have reached it, and were paused.
4) Those that have reached it, were paused, and were then let through.

With this approach, 2-4 have analogs in the old code / tests.  1) does not.

In particular, we should test at least these cases:
1) A request is in state 1) when it's cancelled.
2) A request is in state 1) when we detach the client and start all requests for
it.  We should make sure the request is allowed through when it does reach the
network, and completes happily.
3) A low priority request in state 1) has no impact on letting another low
priority request through when that other request is about to reach the network.
4) A high priority request in state 1) *does* prevent low priority requests from
going through (whenever the condition is for that logic is true).

     return request;
   }
 
@@ -265,56 +288,56 @@ class ResourceSchedulerTest : public testing::Test {
 
 TEST_F(ResourceSchedulerTest, OneIsolatedLowRequest) {
   scoped_ptr<TestRequest> request(NewRequest("http://host/1", net::LOWEST));
-  EXPECT_TRUE(request->started());
+  EXPECT_TRUE(request->sent());
 }
 
 TEST_F(ResourceSchedulerTest, OneLowLoadsUntilIdle) {
   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
   scoped_ptr<TestRequest> low2(NewRequest("http://host/low", net::LOWEST));
-  EXPECT_TRUE(high->started());
-  EXPECT_TRUE(low->started());
-  EXPECT_FALSE(low2->started());
+  EXPECT_TRUE(high->sent());
+  EXPECT_TRUE(low->sent());
+  EXPECT_FALSE(low2->sent());
 
   high.reset();
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(low2->started());
+  EXPECT_TRUE(low2->sent());
 }
 
 TEST_F(ResourceSchedulerTest, OneLowLoadsUntilBodyInserted) {
   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
   scoped_ptr<TestRequest> low2(NewRequest("http://host/low", net::LOWEST));
-  EXPECT_TRUE(high->started());
-  EXPECT_TRUE(low->started());
-  EXPECT_FALSE(low2->started());
+  EXPECT_TRUE(high->sent());
+  EXPECT_TRUE(low->sent());
+  EXPECT_FALSE(low2->sent());
 
   high.reset();
   base::RunLoop().RunUntilIdle();
   // TODO(mmenke):  The name of this test implies this should be false.
   // Investigate if this is now expected, remove or update this test if it is.
-  EXPECT_TRUE(low2->started());
+  EXPECT_TRUE(low2->sent());
 
   scheduler()->OnWillInsertBody(kChildId, kRouteId);
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(low2->started());
+  EXPECT_TRUE(low2->sent());
 }
 
 TEST_F(ResourceSchedulerTest, OneLowLoadsUntilCriticalComplete) {
   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
   scoped_ptr<TestRequest> low2(NewRequest("http://host/low", net::LOWEST));
-  EXPECT_TRUE(high->started());
-  EXPECT_TRUE(low->started());
-  EXPECT_FALSE(low2->started());
+  EXPECT_TRUE(high->sent());
+  EXPECT_TRUE(low->sent());
+  EXPECT_FALSE(low2->sent());
 
   scheduler()->OnWillInsertBody(kChildId, kRouteId);
   base::RunLoop().RunUntilIdle();
-  EXPECT_FALSE(low2->started());
+  EXPECT_FALSE(low2->sent());
 
   high.reset();
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(low2->started());
+  EXPECT_TRUE(low2->sent());
 }
 
 TEST_F(ResourceSchedulerTest, LowDoesNotBlockCriticalComplete) {
@@ -322,13 +345,13 @@ TEST_F(ResourceSchedulerTest, LowDoesNotBlockCriticalComplete) {
   scoped_ptr<TestRequest> lowest(NewRequest("http://host/lowest", net::LOWEST));
   scoped_ptr<TestRequest> lowest2(
       NewRequest("http://host/lowest", net::LOWEST));
-  EXPECT_TRUE(low->started());
-  EXPECT_TRUE(lowest->started());
-  EXPECT_FALSE(lowest2->started());
+  EXPECT_TRUE(low->sent());
+  EXPECT_TRUE(lowest->sent());
+  EXPECT_FALSE(lowest2->sent());
 
   scheduler()->OnWillInsertBody(kChildId, kRouteId);
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(lowest2->started());
+  EXPECT_TRUE(lowest2->sent());
 }
 
 TEST_F(ResourceSchedulerTest, OneLowLoadsUntilBodyInsertedExceptSpdy) {
@@ -339,15 +362,15 @@ TEST_F(ResourceSchedulerTest, OneLowLoadsUntilBodyInsertedExceptSpdy) {
       NewRequest("https://spdyhost/low", net::LOWEST));
   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
   scoped_ptr<TestRequest> low2(NewRequest("http://host/low", net::LOWEST));
-  EXPECT_TRUE(high->started());
-  EXPECT_TRUE(low_spdy->started());
-  EXPECT_TRUE(low->started());
-  EXPECT_FALSE(low2->started());
+  EXPECT_TRUE(high->sent());
+  EXPECT_TRUE(low_spdy->sent());
+  EXPECT_TRUE(low->sent());
+  EXPECT_FALSE(low2->sent());
 
   scheduler()->OnWillInsertBody(kChildId, kRouteId);
   high.reset();
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(low2->started());
+  EXPECT_TRUE(low2->sent());
 }
 
 TEST_F(ResourceSchedulerTest, NavigationResetsState) {
@@ -356,16 +379,16 @@ TEST_F(ResourceSchedulerTest, NavigationResetsState) {
   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
   scoped_ptr<TestRequest> low2(NewRequest("http://host/low", net::LOWEST));
-  EXPECT_TRUE(high->started());
-  EXPECT_TRUE(low->started());
-  EXPECT_FALSE(low2->started());
+  EXPECT_TRUE(high->sent());
+  EXPECT_TRUE(low->sent());
+  EXPECT_FALSE(low2->sent());
 }
 
 TEST_F(ResourceSchedulerTest, BackgroundRequestStartsImmediately) {
   const int route_id = 0;  // Indicates a background request.
   scoped_ptr<TestRequest> request(NewRequestWithRoute("http://host/1",
                                                       net::LOWEST, route_id));
-  EXPECT_TRUE(request->started());
+  EXPECT_TRUE(request->sent());
 }
 
 TEST_F(ResourceSchedulerTest, StartMultipleLowRequestsWhenIdle) {
@@ -373,18 +396,18 @@ TEST_F(ResourceSchedulerTest, StartMultipleLowRequestsWhenIdle) {
   scoped_ptr<TestRequest> high2(NewRequest("http://host/high2", net::HIGHEST));
   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
   scoped_ptr<TestRequest> low2(NewRequest("http://host/low", net::LOWEST));
-  EXPECT_TRUE(high1->started());
-  EXPECT_TRUE(high2->started());
-  EXPECT_TRUE(low->started());
-  EXPECT_FALSE(low2->started());
+  EXPECT_TRUE(high1->sent());
+  EXPECT_TRUE(high2->sent());
+  EXPECT_TRUE(low->sent());
+  EXPECT_FALSE(low2->sent());
 
   high1.reset();
   base::RunLoop().RunUntilIdle();
-  EXPECT_FALSE(low2->started());
+  EXPECT_FALSE(low2->sent());
 
   high2.reset();
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(low2->started());
+  EXPECT_TRUE(low2->sent());
 }
 
 TEST_F(ResourceSchedulerTest, CancelOtherRequestsWhileResuming) {
@@ -398,19 +421,21 @@ TEST_F(ResourceSchedulerTest, CancelOtherRequestsWhileResuming) {
   scoped_ptr<CancelingTestRequest> low2(new CancelingTestRequest(
       std::move(url_request), std::move(throttle), scheduler()));
   low2->Start();
+  EXPECT_TRUE(low2->started());
+  low2->Send();
 
   scoped_ptr<TestRequest> low3(NewRequest("http://host/low3", net::LOWEST));
   low2->set_request_to_cancel(std::move(low3));
   scoped_ptr<TestRequest> low4(NewRequest("http://host/low4", net::LOWEST));
 
-  EXPECT_TRUE(high->started());
-  EXPECT_FALSE(low2->started());
+  EXPECT_TRUE(high->sent());
+  EXPECT_FALSE(low2->sent());
 
   high.reset();
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(low1->started());
-  EXPECT_TRUE(low2->started());
-  EXPECT_TRUE(low4->started());
+  EXPECT_TRUE(low1->sent());
+  EXPECT_TRUE(low2->sent());
+  EXPECT_TRUE(low4->sent());
 }
 
 TEST_F(ResourceSchedulerTest, LimitedNumberOfDelayableRequestsInFlight) {
@@ -419,7 +444,7 @@ TEST_F(ResourceSchedulerTest, LimitedNumberOfDelayableRequestsInFlight) {
 
   // 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());
+  EXPECT_TRUE(high->sent());
 
   const int kMaxNumDelayableRequestsPerClient = 10;  // Should match the .cc.
   const int kMaxNumDelayableRequestsPerHost = 6;
@@ -436,16 +461,16 @@ TEST_F(ResourceSchedulerTest, LimitedNumberOfDelayableRequestsInFlight) {
   scoped_ptr<TestRequest> last_singlehost(NewRequest("http://host/s_last",
                                                      net::LOWEST));
 
-  EXPECT_FALSE(second_last_singlehost->started());
+  EXPECT_FALSE(second_last_singlehost->sent());
 
   high.reset();
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(second_last_singlehost->started());
-  EXPECT_FALSE(last_singlehost->started());
+  EXPECT_TRUE(second_last_singlehost->sent());
+  EXPECT_FALSE(last_singlehost->sent());
 
   lows_singlehost.erase(lows_singlehost.begin());
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(last_singlehost->started());
+  EXPECT_TRUE(last_singlehost->sent());
 
   // Queue more requests from different hosts until we reach the total limit.
   int expected_slots_left =
@@ -456,12 +481,12 @@ TEST_F(ResourceSchedulerTest, LimitedNumberOfDelayableRequestsInFlight) {
   for (int i = 0; i < expected_slots_left; ++i) {
     string url = "http://host" + base::IntToString(i) + "/low";
     lows_different_host.push_back(NewRequest(url.c_str(), net::LOWEST));
-    EXPECT_TRUE(lows_different_host[i]->started());
+    EXPECT_TRUE(lows_different_host[i]->sent());
   }
 
   scoped_ptr<TestRequest> last_different_host(NewRequest("http://host_new/last",
                                                          net::LOWEST));
-  EXPECT_FALSE(last_different_host->started());
+  EXPECT_FALSE(last_different_host->sent());
 }
 
 TEST_F(ResourceSchedulerTest, RaisePriorityAndStart) {
@@ -470,11 +495,11 @@ TEST_F(ResourceSchedulerTest, RaisePriorityAndStart) {
   scoped_ptr<TestRequest> low(NewRequest("http://host/req", net::LOWEST));
 
   scoped_ptr<TestRequest> request(NewRequest("http://host/req", net::LOWEST));
-  EXPECT_FALSE(request->started());
+  EXPECT_FALSE(request->sent());
 
   ChangeRequestPriority(request.get(), net::HIGHEST);
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(request->started());
+  EXPECT_TRUE(request->sent());
 }
 
 TEST_F(ResourceSchedulerTest, RaisePriorityInQueue) {
@@ -484,13 +509,13 @@ TEST_F(ResourceSchedulerTest, RaisePriorityInQueue) {
 
   scoped_ptr<TestRequest> request(NewRequest("http://host/req", net::IDLE));
   scoped_ptr<TestRequest> idle(NewRequest("http://host/idle", net::IDLE));
-  EXPECT_FALSE(request->started());
-  EXPECT_FALSE(idle->started());
+  EXPECT_FALSE(request->sent());
+  EXPECT_FALSE(idle->sent());
 
   ChangeRequestPriority(request.get(), net::LOWEST);
   base::RunLoop().RunUntilIdle();
-  EXPECT_FALSE(request->started());
-  EXPECT_FALSE(idle->started());
+  EXPECT_FALSE(request->sent());
+  EXPECT_FALSE(idle->sent());
 
   const int kMaxNumDelayableRequestsPerClient = 10;  // Should match the .cc.
   ScopedVector<TestRequest> lows;
@@ -503,8 +528,8 @@ TEST_F(ResourceSchedulerTest, RaisePriorityInQueue) {
   high.reset();
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_TRUE(request->started());
-  EXPECT_FALSE(idle->started());
+  EXPECT_TRUE(request->sent());
+  EXPECT_FALSE(idle->sent());
 }
 
 TEST_F(ResourceSchedulerTest, LowerPriority) {
@@ -514,13 +539,13 @@ TEST_F(ResourceSchedulerTest, LowerPriority) {
 
   scoped_ptr<TestRequest> request(NewRequest("http://host/req", net::LOWEST));
   scoped_ptr<TestRequest> idle(NewRequest("http://host/idle", net::IDLE));
-  EXPECT_FALSE(request->started());
-  EXPECT_FALSE(idle->started());
+  EXPECT_FALSE(request->sent());
+  EXPECT_FALSE(idle->sent());
 
   ChangeRequestPriority(request.get(), net::IDLE);
   base::RunLoop().RunUntilIdle();
-  EXPECT_FALSE(request->started());
-  EXPECT_FALSE(idle->started());
+  EXPECT_FALSE(request->sent());
+  EXPECT_FALSE(idle->sent());
 
   const int kMaxNumDelayableRequestsPerClient = 10;  // Should match the .cc.
   // 2 fewer filler requests: 1 for the "low" dummy at the start, and 1 for the
@@ -536,8 +561,8 @@ TEST_F(ResourceSchedulerTest, LowerPriority) {
   high.reset();
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_FALSE(request->started());
-  EXPECT_TRUE(idle->started());
+  EXPECT_FALSE(request->sent());
+  EXPECT_TRUE(idle->sent());
 }
 
 TEST_F(ResourceSchedulerTest, ReprioritizedRequestGoesToBackOfQueue) {
@@ -547,8 +572,8 @@ TEST_F(ResourceSchedulerTest, ReprioritizedRequestGoesToBackOfQueue) {
 
   scoped_ptr<TestRequest> request(NewRequest("http://host/req", net::LOWEST));
   scoped_ptr<TestRequest> idle(NewRequest("http://host/idle", net::IDLE));
-  EXPECT_FALSE(request->started());
-  EXPECT_FALSE(idle->started());
+  EXPECT_FALSE(request->sent());
+  EXPECT_FALSE(idle->sent());
 
   const int kMaxNumDelayableRequestsPerClient = 10;  // Should match the .cc.
   ScopedVector<TestRequest> lows;
@@ -559,18 +584,18 @@ TEST_F(ResourceSchedulerTest, ReprioritizedRequestGoesToBackOfQueue) {
 
   ChangeRequestPriority(request.get(), net::IDLE);
   base::RunLoop().RunUntilIdle();
-  EXPECT_FALSE(request->started());
-  EXPECT_FALSE(idle->started());
+  EXPECT_FALSE(request->sent());
+  EXPECT_FALSE(idle->sent());
 
   ChangeRequestPriority(request.get(), net::LOWEST);
   base::RunLoop().RunUntilIdle();
-  EXPECT_FALSE(request->started());
-  EXPECT_FALSE(idle->started());
+  EXPECT_FALSE(request->sent());
+  EXPECT_FALSE(idle->sent());
 
   scheduler()->OnWillInsertBody(kChildId, kRouteId);
   base::RunLoop().RunUntilIdle();
-  EXPECT_FALSE(request->started());
-  EXPECT_FALSE(idle->started());
+  EXPECT_FALSE(request->sent());
+  EXPECT_FALSE(idle->sent());
 }
 
 TEST_F(ResourceSchedulerTest, HigherIntraPriorityGoesToFrontOfQueue) {
@@ -586,16 +611,16 @@ TEST_F(ResourceSchedulerTest, HigherIntraPriorityGoesToFrontOfQueue) {
   }
 
   scoped_ptr<TestRequest> request(NewRequest("http://host/req", net::IDLE));
-  EXPECT_FALSE(request->started());
+  EXPECT_FALSE(request->sent());
 
   ChangeRequestPriority(request.get(), net::IDLE, 1);
   base::RunLoop().RunUntilIdle();
-  EXPECT_FALSE(request->started());
+  EXPECT_FALSE(request->sent());
 
   scheduler()->OnWillInsertBody(kChildId, kRouteId);
   high.reset();
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(request->started());
+  EXPECT_TRUE(request->sent());
 }
 
 TEST_F(ResourceSchedulerTest, NonHTTPSchedulesImmediately) {
@@ -605,7 +630,7 @@ TEST_F(ResourceSchedulerTest, NonHTTPSchedulesImmediately) {
 
   scoped_ptr<TestRequest> request(
       NewRequest("chrome-extension://req", net::LOWEST));
-  EXPECT_TRUE(request->started());
+  EXPECT_TRUE(request->sent());
 }
 
 TEST_F(ResourceSchedulerTest, SpdyProxySchedulesImmediately) {
@@ -613,14 +638,14 @@ TEST_F(ResourceSchedulerTest, SpdyProxySchedulesImmediately) {
   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
 
   scoped_ptr<TestRequest> request(NewRequest("http://host/req", net::IDLE));
-  EXPECT_FALSE(request->started());
+  EXPECT_FALSE(request->sent());
 
   scheduler()->OnReceivedSpdyProxiedHttpResponse(kChildId, kRouteId);
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(request->started());
+  EXPECT_TRUE(request->sent());
 
   scoped_ptr<TestRequest> after(NewRequest("http://host/after", net::IDLE));
-  EXPECT_TRUE(after->started());
+  EXPECT_TRUE(after->sent());
 }
 
 TEST_F(ResourceSchedulerTest, NewSpdyHostInDelayableRequests) {
@@ -636,25 +661,25 @@ TEST_F(ResourceSchedulerTest, NewSpdyHostInDelayableRequests) {
     lows.push_back(NewRequest(url.c_str(), net::LOWEST));
   }
   scoped_ptr<TestRequest> low1(NewRequest("http://host/low", net::LOWEST));
-  EXPECT_FALSE(low1->started());
+  EXPECT_FALSE(low1->sent());
   http_server_properties_.SetSupportsSpdy(
       net::HostPortPair("spdyhost1", 8080), true);
   low1_spdy.reset();
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(low1->started());
+  EXPECT_TRUE(low1->sent());
 
   low1.reset();
   base::RunLoop().RunUntilIdle();
   scoped_ptr<TestRequest> low2_spdy(
       NewRequest("http://spdyhost2:8080/low", net::IDLE));
   // Reprioritize a request after we learn the server supports SPDY.
-  EXPECT_TRUE(low2_spdy->started());
+  EXPECT_TRUE(low2_spdy->sent());
   http_server_properties_.SetSupportsSpdy(
       net::HostPortPair("spdyhost2", 8080), true);
   ChangeRequestPriority(low2_spdy.get(), net::LOWEST);
   base::RunLoop().RunUntilIdle();
   scoped_ptr<TestRequest> low2(NewRequest("http://host/low", net::LOWEST));
-  EXPECT_TRUE(low2->started());
+  EXPECT_TRUE(low2->sent());
 }
 
 TEST_F(ResourceSchedulerTest, OustandingRequestLimitEnforced) {
@@ -669,13 +694,13 @@ TEST_F(ResourceSchedulerTest, OustandingRequestLimitEnforced) {
   for (int i = 0; i < kRequestLimit; ++i) {
     string url = "http://host/medium";
     requests.push_back(NewRequest(url.c_str(), net::MEDIUM));
-    EXPECT_TRUE(requests[i]->started());
+    EXPECT_TRUE(requests[i]->sent());
   }
 
   // Confirm that another request will indeed fail.
   string url = "http://host/medium";
   requests.push_back(NewRequest(url.c_str(), net::MEDIUM));
-  EXPECT_FALSE(requests[kRequestLimit]->started());
+  EXPECT_FALSE(requests[kRequestLimit]->sent());
 }
 
 // Confirm that outstanding requests limits apply to requests to hosts
@@ -696,13 +721,13 @@ TEST_F(ResourceSchedulerTest,
   for (int i = 0; i < kRequestLimit; ++i) {
     string url = "http://spdyhost/medium";
     requests.push_back(NewRequest(url.c_str(), net::MEDIUM));
-    EXPECT_TRUE(requests[i]->started());
+    EXPECT_TRUE(requests[i]->sent());
   }
 
   // Confirm that another request will indeed fail.
   string url = "http://spdyhost/medium";
   requests.push_back(NewRequest(url.c_str(), net::MEDIUM));
-  EXPECT_FALSE(requests[kRequestLimit]->started());
+  EXPECT_FALSE(requests[kRequestLimit]->sent());
 }
 
 TEST_F(ResourceSchedulerTest, OutstandingRequestLimitDelays) {
@@ -715,14 +740,14 @@ TEST_F(ResourceSchedulerTest, OutstandingRequestLimitDelays) {
   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
   scoped_ptr<TestRequest> low2(NewRequest("http://host/low", net::LOWEST));
-  EXPECT_TRUE(high->started());
-  EXPECT_FALSE(low->started());
-  EXPECT_FALSE(low2->started());
+  EXPECT_TRUE(high->sent());
+  EXPECT_FALSE(low->sent());
+  EXPECT_FALSE(low2->sent());
 
   high.reset();
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(low->started());
-  EXPECT_TRUE(low2->started());
+  EXPECT_TRUE(low->sent());
+  EXPECT_TRUE(low2->sent());
 }
 
 // Async revalidations which are not started when the tab is closed must be
@@ -736,13 +761,13 @@ TEST_F(ResourceSchedulerTest, RequestStartedAfterClientDeleted) {
       "http://host/lowest", net::LOWEST, kChildId2, kRouteId2));
   scoped_ptr<TestRequest> lowest2(NewRequestWithChildAndRoute(
       "http://host/lowest", net::LOWEST, kChildId2, kRouteId2));
-  EXPECT_FALSE(lowest2->started());
+  EXPECT_FALSE(lowest2->sent());
 
   scheduler_->OnClientDeleted(kChildId2, kRouteId2);
   high.reset();
   lowest1.reset();
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(lowest2->started());
+  EXPECT_TRUE(lowest2->sent());
 }
 
 // The ResourceScheduler::Client destructor calls
@@ -761,13 +786,13 @@ TEST_F(ResourceSchedulerTest, RequestStartedAfterClientDeletedManyDelayable) {
   }
   scoped_ptr<TestRequest> lowest(NewRequestWithChildAndRoute(
       "http://host/lowest", net::LOWEST, kChildId2, kRouteId2));
-  EXPECT_FALSE(lowest->started());
+  EXPECT_FALSE(lowest->sent());
 
   scheduler_->OnClientDeleted(kChildId2, kRouteId2);
   high.reset();
   delayable_requests.clear();
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(lowest->started());
+  EXPECT_TRUE(lowest->sent());
 }
 
 TEST_F(ResourceSchedulerTest, DefaultLayoutBlockingPriority) {
@@ -803,18 +828,18 @@ TEST_F(ResourceSchedulerTest, DefaultLayoutBlockingPriority) {
   scoped_ptr<TestRequest> lowest(NewRequest("http://hostlowest/lowest", net::LOWEST));
   scoped_ptr<TestRequest> lowest2(
       NewRequest("http://hostlowest/lowest", net::LOWEST));
-  EXPECT_TRUE(high->started());
-  EXPECT_TRUE(high2->started());
-  EXPECT_TRUE(medium->started());
-  EXPECT_TRUE(medium2->started());
-  EXPECT_TRUE(low->started());
-  EXPECT_TRUE(low2->started());
-  EXPECT_TRUE(lowest->started());
-  EXPECT_FALSE(lowest2->started());
+  EXPECT_TRUE(high->sent());
+  EXPECT_TRUE(high2->sent());
+  EXPECT_TRUE(medium->sent());
+  EXPECT_TRUE(medium2->sent());
+  EXPECT_TRUE(low->sent());
+  EXPECT_TRUE(low2->sent());
+  EXPECT_TRUE(lowest->sent());
+  EXPECT_FALSE(lowest2->sent());
 
   lowest.reset();
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(lowest2->started());
+  EXPECT_TRUE(lowest2->sent());
 }
 
 TEST_F(ResourceSchedulerTest, IncreaseLayoutBlockingPriority) {
@@ -852,29 +877,29 @@ TEST_F(ResourceSchedulerTest, IncreaseLayoutBlockingPriority) {
   scoped_ptr<TestRequest> lowest(NewRequest("http://hostlowest/lowest", net::LOWEST));
   scoped_ptr<TestRequest> lowest2(
       NewRequest("http://hostlowest/lowest", net::LOWEST));
-  EXPECT_TRUE(high->started());
-  EXPECT_TRUE(high2->started());
-  EXPECT_TRUE(medium->started());
-  EXPECT_TRUE(medium2->started());
-  EXPECT_TRUE(low->started());
-  EXPECT_FALSE(low2->started());
-  EXPECT_FALSE(lowest->started());
-  EXPECT_FALSE(lowest2->started());
+  EXPECT_TRUE(high->sent());
+  EXPECT_TRUE(high2->sent());
+  EXPECT_TRUE(medium->sent());
+  EXPECT_TRUE(medium2->sent());
+  EXPECT_TRUE(low->sent());
+  EXPECT_FALSE(low2->sent());
+  EXPECT_FALSE(lowest->sent());
+  EXPECT_FALSE(lowest2->sent());
 
   low.reset();
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(low2->started());
-  EXPECT_FALSE(lowest->started());
-  EXPECT_FALSE(lowest2->started());
+  EXPECT_TRUE(low2->sent());
+  EXPECT_FALSE(lowest->sent());
+  EXPECT_FALSE(lowest2->sent());
 
   low2.reset();
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(lowest->started());
-  EXPECT_FALSE(lowest2->started());
+  EXPECT_TRUE(lowest->sent());
+  EXPECT_FALSE(lowest2->sent());
 
   lowest.reset();
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(lowest2->started());
+  EXPECT_TRUE(lowest2->sent());
 }
 
 TEST_F(ResourceSchedulerTest, UseLayoutBlockingThresholdOne) {
@@ -903,23 +928,23 @@ TEST_F(ResourceSchedulerTest, UseLayoutBlockingThresholdOne) {
   scoped_ptr<TestRequest> high2(NewRequest("http://host/high", net::HIGHEST));
   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
   scoped_ptr<TestRequest> low2(NewRequest("http://host/low", net::LOWEST));
-  EXPECT_TRUE(high->started());
-  EXPECT_TRUE(high2->started());
-  EXPECT_FALSE(low->started());
-  EXPECT_FALSE(low2->started());
+  EXPECT_TRUE(high->sent());
+  EXPECT_TRUE(high2->sent());
+  EXPECT_FALSE(low->sent());
+  EXPECT_FALSE(low2->sent());
 
   high.reset();
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(low->started());
-  EXPECT_FALSE(low2->started());
+  EXPECT_TRUE(low->sent());
+  EXPECT_FALSE(low2->sent());
 
   high2.reset();
   base::RunLoop().RunUntilIdle();
-  EXPECT_FALSE(low2->started());
+  EXPECT_FALSE(low2->sent());
 
   scheduler()->OnWillInsertBody(kChildId, kRouteId);
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(low2->started());
+  EXPECT_TRUE(low2->sent());
 }
 
 TEST_F(ResourceSchedulerTest, UseLayoutBlockingThresholdTwo) {
@@ -949,25 +974,25 @@ TEST_F(ResourceSchedulerTest, UseLayoutBlockingThresholdTwo) {
   scoped_ptr<TestRequest> high3(NewRequest("http://host/high", net::HIGHEST));
   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
   scoped_ptr<TestRequest> low2(NewRequest("http://host/low", net::LOWEST));
-  EXPECT_TRUE(high->started());
-  EXPECT_TRUE(high2->started());
-  EXPECT_TRUE(high3->started());
-  EXPECT_FALSE(low->started());
-  EXPECT_FALSE(low2->started());
+  EXPECT_TRUE(high->sent());
+  EXPECT_TRUE(high2->sent());
+  EXPECT_TRUE(high3->sent());
+  EXPECT_FALSE(low->sent());
+  EXPECT_FALSE(low2->sent());
 
   high.reset();
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(low->started());
-  EXPECT_FALSE(low2->started());
+  EXPECT_TRUE(low->sent());
+  EXPECT_FALSE(low2->sent());
 
   high2.reset();
   high3.reset();
   base::RunLoop().RunUntilIdle();
-  EXPECT_FALSE(low2->started());
+  EXPECT_FALSE(low2->sent());
 
   scheduler()->OnWillInsertBody(kChildId, kRouteId);
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(low2->started());
+  EXPECT_TRUE(low2->sent());
 }
 
 TEST_F(ResourceSchedulerTest, TwoDelayableLoadsUntilBodyInserted) {
@@ -996,15 +1021,15 @@ TEST_F(ResourceSchedulerTest, TwoDelayableLoadsUntilBodyInserted) {
   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
   scoped_ptr<TestRequest> low2(NewRequest("http://host/low", net::LOWEST));
   scoped_ptr<TestRequest> low3(NewRequest("http://host/low", net::LOWEST));
-  EXPECT_TRUE(high->started());
-  EXPECT_TRUE(low->started());
-  EXPECT_TRUE(low2->started());
-  EXPECT_FALSE(low3->started());
+  EXPECT_TRUE(high->sent());
+  EXPECT_TRUE(low->sent());
+  EXPECT_TRUE(low2->sent());
+  EXPECT_FALSE(low3->sent());
 
   high.reset();
   scheduler()->OnWillInsertBody(kChildId, kRouteId);
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(low3->started());
+  EXPECT_TRUE(low3->sent());
 }
 
 TEST_F(ResourceSchedulerTest,
@@ -1036,22 +1061,22 @@ TEST_F(ResourceSchedulerTest,
   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
   scoped_ptr<TestRequest> low2(NewRequest("http://host/low", net::LOWEST));
   scoped_ptr<TestRequest> low3(NewRequest("http://host/low", net::LOWEST));
-  EXPECT_TRUE(high->started());
-  EXPECT_TRUE(high2->started());
-  EXPECT_FALSE(low->started());
-  EXPECT_FALSE(low2->started());
-  EXPECT_FALSE(low3->started());
+  EXPECT_TRUE(high->sent());
+  EXPECT_TRUE(high2->sent());
+  EXPECT_FALSE(low->sent());
+  EXPECT_FALSE(low2->sent());
+  EXPECT_FALSE(low3->sent());
 
   high.reset();
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(low->started());
-  EXPECT_TRUE(low2->started());
-  EXPECT_FALSE(low3->started());
+  EXPECT_TRUE(low->sent());
+  EXPECT_TRUE(low2->sent());
+  EXPECT_FALSE(low3->sent());
 
   high2.reset();
   scheduler()->OnWillInsertBody(kChildId, kRouteId);
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(low3->started());
+  EXPECT_TRUE(low3->sent());
 }
 
 TEST_F(ResourceSchedulerTest, TwentyMaxNumDelayableRequestsPerClient) {
@@ -1085,12 +1110,12 @@ TEST_F(ResourceSchedulerTest, TwentyMaxNumDelayableRequestsPerClient) {
   for (int i = 0; i < kMaxNumDelayableRequestsPerClient; ++i) {
     string url = "http://host" + base::IntToString(i) + "/low";
     lows_different_host.push_back(NewRequest(url.c_str(), net::LOWEST));
-    EXPECT_TRUE(lows_different_host[i]->started());
+    EXPECT_TRUE(lows_different_host[i]->sent());
   }
 
   scoped_ptr<TestRequest> last_different_host(NewRequest("http://host_new/last",
                                                         net::LOWEST));
-  EXPECT_FALSE(last_different_host->started());
+  EXPECT_FALSE(last_different_host->sent());
 }
 
 TEST_F(ResourceSchedulerTest,
@@ -1126,12 +1151,12 @@ TEST_F(ResourceSchedulerTest,
   for (int i = 0; i < kMaxNumDelayableRequestsPerClient; ++i) {
     string url = "http://host" + base::IntToString(i) + "/low";
     lows_different_host.push_back(NewRequest(url.c_str(), net::LOWEST));
-    EXPECT_TRUE(lows_different_host[i]->started());
+    EXPECT_TRUE(lows_different_host[i]->sent());
   }
 
   scoped_ptr<TestRequest> last_different_host(NewRequest("http://host_new/last",
                                                          net::LOWEST));
-  EXPECT_FALSE(last_different_host->started());
+  EXPECT_FALSE(last_different_host->sent());
 }
 
 }  // unnamed namespace