ResourceScheduler: remove dependency on ResourceRequestInfo and request_id

content/browser/loader/resource_dispatcher_host_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 <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 928 matching lines @@
 
   // Generates a request using the given filter and resource type.
   void MakeTestRequestWithResourceType(ResourceMessageFilter* filter,
                                        int render_view_id,
                                        int request_id,
                                        const GURL& url,
                                        ResourceType type);
 
   void MakeWebContentsAssociatedTestRequest(int request_id, const GURL& url);
 
+  // Generates a request with the given priority.
+  void MakeTestRequestWithPriority(int render_view_id,
+                                   int request_id,
+                                   net::RequestPriority priority);
+
   void CancelRequest(int request_id);
   void RendererCancelRequest(int request_id) {
     ResourceMessageFilter* old_filter = SetFilter(filter_.get());
     host_.OnCancelRequest(request_id);
     SetFilter(old_filter);
   }
 
   void CompleteStartRequest(int request_id);
   void CompleteStartRequest(ResourceMessageFilter* filter, int request_id);
 
@@ skipping 106 matching lines @@
   ResourceHostMsg_Request request =
       CreateResourceRequest("GET", RESOURCE_TYPE_SUB_RESOURCE, url);
   request.origin_pid = web_contents_->GetRenderProcessHost()->GetID();
   request.render_frame_id = web_contents_->GetMainFrame()->GetRoutingID();
   ResourceHostMsg_RequestResource msg(web_contents_->GetRoutingID(), request_id,
                                       request);
   host_.OnMessageReceived(msg, web_contents_filter_.get());
   KickOffRequest();
 }
 
+void ResourceDispatcherHostTest::MakeTestRequestWithPriority(
+    int render_view_id,
+    int request_id,
+    net::RequestPriority priority) {
+  ResourceHostMsg_Request request = CreateResourceRequest(
+      "GET", RESOURCE_TYPE_SUB_RESOURCE, GURL("http://example.com/priority"));
+  request.priority = priority;
+  ResourceHostMsg_RequestResource msg(render_view_id, request_id, request);
+  host_.OnMessageReceived(msg, filter_.get());
+}
+
 void ResourceDispatcherHostTest::CancelRequest(int request_id) {
   host_.CancelRequest(filter_->child_id(), request_id);
 }
 
 void ResourceDispatcherHostTest::CompleteStartRequest(int request_id) {
   CompleteStartRequest(filter_.get(), request_id);
 }
 
 void ResourceDispatcherHostTest::CompleteStartRequest(
     ResourceMessageFilter* filter,
@@ skipping 2237 matching lines @@
   int initial_count = web_contents_observer_->resource_request_redirect_count();
 
   MakeWebContentsAssociatedTestRequest(
       1, net::URLRequestTestJob::test_url_redirect_to_url_2());
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(initial_count + 1,
             web_contents_observer_->resource_request_redirect_count());
 }
 
+// Confirm that DidChangePriority messages are respected.
+TEST_F(ResourceDispatcherHostTest, DidChangePriority) {
+  // ResourceScheduler only throttles http and https requests.
+  HandleScheme("http");
+
+  // Needed to enable scheduling for this child.
+  host_.OnRenderViewHostCreated(filter_->child_id(),  // child_id
+                                0,                    // route_id
+                                true,                 // is_visible
+                                false);               // is_audible
+
+  // Prevent any of these requests from completing.
+  job_factory_->SetDelayedCompleteJobGeneration(true);
+  SetResponse("HTTP/1.1 200 OK\n\n", "<title>Dummy body</title>");
+
+  // Only one idle priority request will run while a high-priority request
+  // exists.
+  MakeTestRequestWithPriority(0, 1, net::HIGHEST);
+  MakeTestRequestWithPriority(0, 2, net::IDLE);
+  MakeTestRequestWithPriority(0, 3, net::IDLE);
+
+  KickOffRequest();
+
+  EXPECT_EQ(2, job_factory_->url_request_jobs_created_count());
+

[davidben, 2015/08/13 23:08:52]

This probably deserves a comment:

// Increase the priority of the second idle priority request. It was
// scheduled later, so it is not currently running.

(So it's clear you're assuming the ResourceScheduler does them in order.)

[Adam Rice, 2015/08/13 23:42:28]

Done.

It's unfortunate that this test depends on the exact behaviour of the
ResourceScheduler, but I don't know how to make it more general without adding a
lot more complexity.

At some point it's cheaper to have a simple test that someone can fix if the
behaviour changes than a complex test that will be very hard to debug if it
breaks.

[davidben, 2015/08/14 02:14:28]

Agreed. I think a comment's worthwhile so that, if it breaks, it'll be clear
what the hidden assumption was, but I don't think it's worth sweating much about
the assumption itself.

+  ResourceHostMsg_DidChangePriority priority_msg(3, net::MAXIMUM_PRIORITY, 0);
+  host_.OnMessageReceived(priority_msg, filter_.get());
+  base::MessageLoop::current()->RunUntilIdle();
+
+  EXPECT_EQ(3, job_factory_->url_request_jobs_created_count());
+
+  // Cleanup.
+  host_.OnRenderViewHostDeleted(filter_->child_id(),  // child_id
+                                0);                   // route_id
+}
+
 net::URLRequestJob* TestURLRequestJobFactory::MaybeCreateJobWithProtocolHandler(
       const std::string& scheme,
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const {
   url_request_jobs_created_count_++;
   if (test_fixture_->wait_for_request_create_loop_)
     test_fixture_->wait_for_request_create_loop_->Quit();
   if (test_fixture_->loader_test_request_info_) {
     DCHECK_EQ(test_fixture_->loader_test_request_info_->url, request->url());
     scoped_ptr<LoadInfoTestRequestInfo> info =
@@ skipping 41 matching lines @@
   return nullptr;
 }
 
 net::URLRequestJob* TestURLRequestJobFactory::MaybeInterceptResponse(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate) const {
   return nullptr;
 }
 
 }  // namespace content