DNS: Support reprioritization of requests.

net/dns/host_resolver_impl_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 "net/dns/host_resolver_impl.h"
 
 #include <algorithm>
 #include <memory>
 #include <string>
 #include <tuple>
@@ skipping 226 matching lines @@
       EXPECT_EQ(OK, result_);
     return result_;
   }
 
   int ResolveFromCache() {
     DCHECK(resolver_);
     DCHECK(!handle_);
     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_);
     resolver_->CancelRequest(handle_);
     handle_ = NULL;
   }
 
   const HostResolver::RequestInfo& info() const { return info_; }
   size_t index() const { return index_; }
   const AddressList& list() const { return list_; }
@@ skipping 927 matching lines @@
 
   EXPECT_EQ("req0", capture_list[0].hostname);
   EXPECT_EQ("req4", capture_list[1].hostname);
   EXPECT_EQ("req5", capture_list[2].hostname);
   EXPECT_EQ("req1", capture_list[3].hostname);
   EXPECT_EQ("req2", capture_list[4].hostname);
   EXPECT_EQ("req3", capture_list[5].hostname);
   EXPECT_EQ("req6", capture_list[6].hostname);
 }
 
+// Test that changing a job's priority affects the dequeueing order.
+TEST_F(HostResolverImplTest, ChangePriority) {
+  CreateSerialResolver();
+
+  CreateRequest("req0", 80, MEDIUM);
+  CreateRequest("req1", 80, LOW);
+  CreateRequest("req2", 80, LOWEST);
+
+  ASSERT_EQ(3u, requests_.size());
+
+  // req0 starts immediately; without ChangePriority, req1 and then req2 should
+  // run.
+  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 started 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();
 
   CreateRequest("req0", 80, LOWEST);
   CreateRequest("req1", 80, HIGHEST);  // Will cancel.
   CreateRequest("req2", 80, MEDIUM);
   CreateRequest("req3", 80, LOW);
   CreateRequest("req4", 80, HIGHEST);  // Will cancel.
   CreateRequest("req5", 80, LOWEST);   // Will cancel.
@@ skipping 1070 matching lines @@
   EXPECT_FALSE(ResolveLocalHostname("::1:1", kLocalhostLookupPort, &addresses));
   EXPECT_FALSE(ResolveLocalHostname("0:0:0:0:0:0:0:0:1", kLocalhostLookupPort,
                                     &addresses));
   EXPECT_FALSE(ResolveLocalHostname("foo.localhost.com", kLocalhostLookupPort,
                                     &addresses));
   EXPECT_FALSE(
       ResolveLocalHostname("foo.localhoste", kLocalhostLookupPort, &addresses));
 }
 
 }  // namespace net