DNS: Support reprioritization of requests.

net/dns/host_resolver_impl_unittest.cc

Index: net/dns/host_resolver_impl_unittest.cc
diff --git a/net/dns/host_resolver_impl_unittest.cc b/net/dns/host_resolver_impl_unittest.cc
index c5c047a66a5e7ac97509f592ab73686f793e9a82..6e62d05339e880083351b656123ce2b414b5b8cb 100644
--- a/net/dns/host_resolver_impl_unittest.cc
+++ b/net/dns/host_resolver_impl_unittest.cc
@@ -244,6 +244,13 @@ class Request {
     return resolver_->ResolveFromCache(info_, &list_, BoundNetLog());
   }
 
+  void ChangePriority(RequestPriority priority) {
+    DCHECK(resolver_);
+    DCHECK(handle_);
+    resolver_->ChangeRequestPriority(handle_, priority);
+    priority_ = priority;
+  }
+
   void Cancel() {
     DCHECK(resolver_);
     DCHECK(handle_);
@@ -1191,6 +1198,41 @@ TEST_F(HostResolverImplTest, HigherPriorityRequestsStartedFirst) {
   EXPECT_EQ("req6", capture_list[6].hostname);
 }
 
+// Test that changing a job's priority affects the dequeueing order.
+TEST_F(HostResolverImplTest, ChangePriority) {
+  CreateSerialResolver();
+
+  // req0 starts immediately; without ChangePriority, req1 and then req2 should
+  // run.

[Randy Smith (Not in Mondays), 2016/04/28 18:04:40]

I'm failing to understand the test infrastructure despite 5-10m of poking.  Why
does req0 start immediately?  All the implementations of CreateRequest I could
find just create objects and queue things.

[Julia Tuttle, 2016/05/04 14:43:20]

They queue things, but a serial resolver is willing to run one request at a
time, so the first request will start and the rest will be queued. (There's no
reason *for* it to wait, so it starts immediately.)

[Randy Smith (Not in Mondays), 2016/05/05 00:07:25]

I think I get it.  But wouldn't this comment be more appropriate down next to
the first Resolve call below?  Isn't that when the first request actually
starts?

[Julia Tuttle, 2016/05/05 12:47:56]

Done.

+  CreateRequest("req0", 80, MEDIUM);
+  CreateRequest("req1", 80, LOW);
+  CreateRequest("req2", 80, LOWEST);
+
+  ASSERT_EQ(3u, requests_.size());
+
+  EXPECT_EQ(ERR_IO_PENDING, requests_[0]->Resolve());
+  EXPECT_EQ(ERR_IO_PENDING, requests_[1]->Resolve());
+  EXPECT_EQ(ERR_IO_PENDING, requests_[2]->Resolve());
+
+  // Changing req2 to HIGH should make it run before req1.
+  // (It can't run before req0, since req0 starts immediately.)
+  requests_[2]->ChangePriority(HIGHEST);
+
+  // Let all 3 requests finish.
+  proc_->SignalMultiple(3u);
+
+  EXPECT_EQ(OK, requests_[0]->WaitForResult());
+  EXPECT_EQ(OK, requests_[1]->WaitForResult());
+  EXPECT_EQ(OK, requests_[2]->WaitForResult());
+
+  MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList();
+  ASSERT_EQ(3u, capture_list.size());
+
+  EXPECT_EQ("req0", capture_list[0].hostname);
+  EXPECT_EQ("req2", capture_list[1].hostname);
+  EXPECT_EQ("req1", capture_list[2].hostname);
+}
+
 // Try cancelling a job which has not started yet.
 TEST_F(HostResolverImplTest, CancelPendingRequest) {
   CreateSerialResolver();