Remove HostResolver::RequestInfo's priority parameter

Make it part of the HostResolver::Resolve() call instead.

This makes it possible for RequestInfo to remain constant for the
lifetime of a request.

This also has the nice side effect for not needing to pass a priority
for ResolveFromCache() calls.

BUG=166689
TBR=asargent@chromium.org, mmenke@chromium.org, sergeyu@chromium.org

Review URL: https://codereview.chromium.org/22824022

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@218525 0039d316-1c4b-4281-b951-d872f2087c98

13 files changed, 134 insertions, 110 deletions

diff --git a/net/dns/host_resolver.cc b/net/dns/host_resolver.cc
index 1f3e309..9b1e331 100644
--- a/net/dns/host_resolver.cc
+++ b/net/dns/host_resolver.cc
@@ -93,14 +93,12 @@ HostResolver::Options::Options()
       enable_caching(true) {
 }
 
-HostResolver::RequestInfo::RequestInfo(const HostPortPair& host_port_pair,
-                                       RequestPriority priority)
+HostResolver::RequestInfo::RequestInfo(const HostPortPair& host_port_pair)
     : host_port_pair_(host_port_pair),
       address_family_(ADDRESS_FAMILY_UNSPECIFIED),
       host_resolver_flags_(0),
       allow_cached_response_(true),
-      is_speculative_(false),
-      priority_(priority) {}
+      is_speculative_(false) {}
 
 HostResolver::~HostResolver() {
 }
diff --git a/net/dns/host_resolver.h b/net/dns/host_resolver.h
index 8d3c228..2964fe6 100644
--- a/net/dns/host_resolver.h
+++ b/net/dns/host_resolver.h
@@ -53,12 +53,11 @@ class NET_EXPORT HostResolver {
     bool enable_caching;
   };
 
-  // The parameters for doing a Resolve(). A hostname, port, and
-  // priority are required; the rest are optional (and have reasonable
-  // defaults).
+  // The parameters for doing a Resolve(). A hostname and port are
+  // required; the rest are optional (and have reasonable defaults).
   class NET_EXPORT RequestInfo {
    public:
-    RequestInfo(const HostPortPair& host_port_pair, RequestPriority priority);
+    explicit RequestInfo(const HostPortPair& host_port_pair);
 
     const HostPortPair& host_port_pair() const { return host_port_pair_; }
     void set_host_port_pair(const HostPortPair& host_port_pair) {
@@ -86,8 +85,6 @@ class NET_EXPORT HostResolver {
     bool is_speculative() const { return is_speculative_; }
     void set_is_speculative(bool b) { is_speculative_ = b; }
 
-    RequestPriority priority() const { return priority_; }
-
    private:
     // The hostname to resolve, and the port to use in resulting sockaddrs.
     HostPortPair host_port_pair_;
@@ -103,9 +100,6 @@ class NET_EXPORT HostResolver {
 
     // Whether this request was started by the DNS prefetcher.
     bool is_speculative_;
-
-    // The priority for the request.
-    RequestPriority priority_;
   };
 
   // Opaque type used to cancel a request.
@@ -144,6 +138,7 @@ class NET_EXPORT HostResolver {
   //
   // Profiling information for the request is saved to |net_log| if non-NULL.
   virtual int Resolve(const RequestInfo& info,
+                      RequestPriority priority,
                       AddressList* addresses,
                       const CompletionCallback& callback,
                       RequestHandle* out_req,
diff --git a/net/dns/host_resolver_impl.cc b/net/dns/host_resolver_impl.cc
index 1063177..e5ee4db 100644
--- a/net/dns/host_resolver_impl.cc
+++ b/net/dns/host_resolver_impl.cc
@@ -343,7 +343,6 @@ base::Value* NetLogRequestInfoCallback(const NetLog::Source& source,
                    static_cast<int>(info->address_family()));
   dict->SetBoolean("allow_cached_response", info->allow_cached_response());
   dict->SetBoolean("is_speculative", info->is_speculative());
-  dict->SetInteger("priority", info->priority());
   return dict;
 }
 
@@ -465,16 +464,17 @@ class HostResolverImpl::Request {
   Request(const BoundNetLog& source_net_log,
           const BoundNetLog& request_net_log,
           const RequestInfo& info,
+          RequestPriority priority,
           const CompletionCallback& callback,
           AddressList* addresses)
       : source_net_log_(source_net_log),
         request_net_log_(request_net_log),
         info_(info),
+        priority_(priority),
         job_(NULL),
         callback_(callback),
         addresses_(addresses),
-        request_time_(base::TimeTicks::Now()) {
-  }
+        request_time_(base::TimeTicks::Now()) {}
 
   // Mark the request as canceled.
   void MarkAsCanceled() {
@@ -521,16 +521,19 @@ class HostResolverImpl::Request {
     return info_;
   }
 
-  base::TimeTicks request_time() const {
-    return request_time_;
-  }
+  RequestPriority priority() const { return priority_; }
+
+  base::TimeTicks request_time() const { return request_time_; }
 
  private:
   BoundNetLog source_net_log_;
   BoundNetLog request_net_log_;
 
   // The request info that started the request.
-  RequestInfo info_;
+  const RequestInfo info_;
+
+  // TODO(akalin): Support reprioritization.
+  const RequestPriority priority_;
 
   // The resolve job that this request is dependent on.
   Job* job_;
@@ -1210,7 +1213,7 @@ class HostResolverImpl::Job : public PrioritizedDispatcher::Job {
     DCHECK_EQ(key_.hostname, req->info().hostname());
 
     req->set_job(this);
-    priority_tracker_.Add(req->info().priority());
+    priority_tracker_.Add(req->priority());
 
     req->request_net_log().AddEvent(
         NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_ATTACH,
@@ -1245,12 +1248,11 @@ class HostResolverImpl::Job : public PrioritizedDispatcher::Job {
     LogCancelRequest(req->source_net_log(), req->request_net_log(),
                      req->info());
 
-    priority_tracker_.Remove(req->info().priority());
-    net_log_.AddEvent(
-        NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_REQUEST_DETACH,
-        base::Bind(&NetLogJobAttachCallback,
-                   req->request_net_log().source(),
-                   priority()));
+    priority_tracker_.Remove(req->priority());
+    net_log_.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_REQUEST_DETACH,
+                      base::Bind(&NetLogJobAttachCallback,
+                                 req->request_net_log().source(),
+                                 priority()));
 
     if (num_active_requests() > 0) {
       UpdatePriority();
@@ -1732,6 +1734,7 @@ void HostResolverImpl::SetMaxQueuedJobs(size_t value) {
 }
 
 int HostResolverImpl::Resolve(const RequestInfo& info,
+                              RequestPriority priority,
                               AddressList* addresses,
                               const CompletionCallback& callback,
                               RequestHandle* out_req,
@@ -1768,8 +1771,8 @@ int HostResolverImpl::Resolve(const RequestInfo& info,
   JobMap::iterator jobit = jobs_.find(key);
   Job* job;
   if (jobit == jobs_.end()) {
-    job = new Job(weak_ptr_factory_.GetWeakPtr(), key, info.priority(),
-                  request_net_log);
+    job =
+        new Job(weak_ptr_factory_.GetWeakPtr(), key, priority, request_net_log);
     job->Schedule();
 
     // Check for queue overflow.
@@ -1789,11 +1792,8 @@ int HostResolverImpl::Resolve(const RequestInfo& info,
   }
 
   // Can't complete synchronously. Create and attach request.
-  scoped_ptr<Request> req(new Request(source_net_log,
-                                      request_net_log,
-                                      info,
-                                      callback,
-                                      addresses));
+  scoped_ptr<Request> req(new Request(
+      source_net_log, request_net_log, info, priority, callback, addresses));
   if (out_req)
     *out_req = reinterpret_cast<RequestHandle>(req.get());
 
diff --git a/net/dns/host_resolver_impl.h b/net/dns/host_resolver_impl.h
index 928d07a..aa6421c 100644
--- a/net/dns/host_resolver_impl.h
+++ b/net/dns/host_resolver_impl.h
@@ -131,6 +131,7 @@ class NET_EXPORT HostResolverImpl
 
   // HostResolver methods:
   virtual int Resolve(const RequestInfo& info,
+                      RequestPriority priority,
                       AddressList* addresses,
                       const CompletionCallback& callback,
                       RequestHandle* out_req,
diff --git a/net/dns/host_resolver_impl_unittest.cc b/net/dns/host_resolver_impl_unittest.cc
index dfe0fc8..d604b64 100644
--- a/net/dns/host_resolver_impl_unittest.cc
+++ b/net/dns/host_resolver_impl_unittest.cc
@@ -197,10 +197,12 @@ class Request {
   };
 
   Request(const HostResolver::RequestInfo& info,
+          RequestPriority priority,
           size_t index,
           HostResolver* resolver,
           Handler* handler)
       : info_(info),
+        priority_(priority),
         index_(index),
         resolver_(resolver),
         handler_(handler),
@@ -213,8 +215,12 @@ class Request {
     DCHECK(!handle_);
     list_ = AddressList();
     result_ = resolver_->Resolve(
-        info_, &list_, base::Bind(&Request::OnComplete, base::Unretained(this)),
-        &handle_, BoundNetLog());
+        info_,
+        priority_,
+        &list_,
+        base::Bind(&Request::OnComplete, base::Unretained(this)),
+        &handle_,
+        BoundNetLog());
     if (!list_.empty())
       EXPECT_EQ(OK, result_);
     return result_;
@@ -291,6 +297,7 @@ class Request {
   }
 
   HostResolver::RequestInfo info_;
+  RequestPriority priority_;
   size_t index_;
   HostResolver* resolver_;
   Handler* handler_;
@@ -419,8 +426,9 @@ class HostResolverImplTest : public testing::Test {
     virtual ~Handler() {}
 
     // Proxy functions so that classes derived from Handler can access them.
-    Request* CreateRequest(const HostResolver::RequestInfo& info) {
-      return test->CreateRequest(info);
+    Request* CreateRequest(const HostResolver::RequestInfo& info,
+                           RequestPriority priority) {
+      return test->CreateRequest(info, priority);
     }
     Request* CreateRequest(const std::string& hostname, int port) {
       return test->CreateRequest(hostname, port);
@@ -457,9 +465,10 @@ class HostResolverImplTest : public testing::Test {
 
   // The Request will not be made until a call to |Resolve()|, and the Job will
   // not start until released by |proc_->SignalXXX|.
-  Request* CreateRequest(const HostResolver::RequestInfo& info) {
-    Request* req = new Request(info, requests_.size(), resolver_.get(),
-                               handler_.get());
+  Request* CreateRequest(const HostResolver::RequestInfo& info,
+                         RequestPriority priority) {
+    Request* req = new Request(
+        info, priority, requests_.size(), resolver_.get(), handler_.get());
     requests_.push_back(req);
     return req;
   }
@@ -468,9 +477,9 @@ class HostResolverImplTest : public testing::Test {
                          int port,
                          RequestPriority priority,
                          AddressFamily family) {
-    HostResolver::RequestInfo info(HostPortPair(hostname, port), priority);
+    HostResolver::RequestInfo info(HostPortPair(hostname, port));
     info.set_address_family(family);
-    return CreateRequest(info);
+    return CreateRequest(info, priority);
   }
 
   Request* CreateRequest(const std::string& hostname,
@@ -814,10 +823,10 @@ TEST_F(HostResolverImplTest, BypassCache) {
 
         // Ok good. Now make sure that if we ask to bypass the cache, it can no
         // longer service the request synchronously.
-        HostResolver::RequestInfo info(HostPortPair(hostname, 71),
-                                       DEFAULT_PRIORITY);
+        HostResolver::RequestInfo info(HostPortPair(hostname, 71));
         info.set_allow_cached_response(false);
-        EXPECT_EQ(ERR_IO_PENDING, CreateRequest(info)->Resolve());
+        EXPECT_EQ(ERR_IO_PENDING,
+                  CreateRequest(info, DEFAULT_PRIORITY)->Resolve());
       } else if (71 == req->info().port()) {
         // Test is done.
         base::MessageLoop::current()->Quit();
@@ -1186,18 +1195,18 @@ TEST_F(HostResolverImplTest, ResolveFromCache) {
   proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42");
   proc_->SignalMultiple(1u);  // Need only one.
 
-  HostResolver::RequestInfo info(HostPortPair("just.testing", 80),
-                                 DEFAULT_PRIORITY);
+  HostResolver::RequestInfo info(HostPortPair("just.testing", 80));
 
   // First hit will miss the cache.
-  EXPECT_EQ(ERR_DNS_CACHE_MISS, CreateRequest(info)->ResolveFromCache());
+  EXPECT_EQ(ERR_DNS_CACHE_MISS,
+            CreateRequest(info, DEFAULT_PRIORITY)->ResolveFromCache());
 
   // This time, we fetch normally.
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest(info)->Resolve());
+  EXPECT_EQ(ERR_IO_PENDING, CreateRequest(info, DEFAULT_PRIORITY)->Resolve());
   EXPECT_EQ(OK, requests_[1]->WaitForResult());
 
   // Now we should be able to fetch from the cache.
-  EXPECT_EQ(OK, CreateRequest(info)->ResolveFromCache());
+  EXPECT_EQ(OK, CreateRequest(info, DEFAULT_PRIORITY)->ResolveFromCache());
   EXPECT_TRUE(requests_[2]->HasOneAddress("192.168.1.42", 80));
 }
 
@@ -1228,8 +1237,8 @@ TEST_F(HostResolverImplTest, MultipleAttempts) {
                            NULL));
 
   // Resolve "host1".
-  HostResolver::RequestInfo info(HostPortPair("host1", 70), DEFAULT_PRIORITY);
-  Request* req = CreateRequest(info);
+  HostResolver::RequestInfo info(HostPortPair("host1", 70));
+  Request* req = CreateRequest(info, DEFAULT_PRIORITY);
   EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
 
   // Resolve returns -4 to indicate that 3rd attempt has resolved the host.
@@ -1604,14 +1613,13 @@ TEST_F(HostResolverImplDnsTest, DualFamilyLocalhost) {
   if (!saw_ipv4 && !saw_ipv6)
     return;
 
-  HostResolver::RequestInfo info(HostPortPair("localhost", 80),
-                                 DEFAULT_PRIORITY);
+  HostResolver::RequestInfo info(HostPortPair("localhost", 80));
   info.set_address_family(ADDRESS_FAMILY_UNSPECIFIED);
   info.set_host_resolver_flags(HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6);
 
   // Try without DnsClient.
   ChangeDnsConfig(DnsConfig());
-  Request* req = CreateRequest(info);
+  Request* req = CreateRequest(info, DEFAULT_PRIORITY);
   // It is resolved via getaddrinfo, so expect asynchronous result.
   EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
   EXPECT_EQ(OK, req->WaitForResult());
@@ -1632,7 +1640,7 @@ TEST_F(HostResolverImplDnsTest, DualFamilyLocalhost) {
   config.hosts = hosts;
 
   ChangeDnsConfig(config);
-  req = CreateRequest(info);
+  req = CreateRequest(info, DEFAULT_PRIORITY);
   // Expect synchronous resolution from DnsHosts.
   EXPECT_EQ(OK, req->Resolve());
 
diff --git a/net/dns/mapped_host_resolver.cc b/net/dns/mapped_host_resolver.cc
index 4db7bc9..7b18207 100644
--- a/net/dns/mapped_host_resolver.cc
+++ b/net/dns/mapped_host_resolver.cc
@@ -19,6 +19,7 @@ MappedHostResolver::~MappedHostResolver() {
 }
 
 int MappedHostResolver::Resolve(const RequestInfo& original_info,
+                                RequestPriority priority,
                                 AddressList* addresses,
                                 const CompletionCallback& callback,
                                 RequestHandle* out_req,
@@ -28,7 +29,7 @@ int MappedHostResolver::Resolve(const RequestInfo& original_info,
   if (rv != OK)
     return rv;
 
-  return impl_->Resolve(info, addresses, callback, out_req, net_log);
+  return impl_->Resolve(info, priority, addresses, callback, out_req, net_log);
 }
 
 int MappedHostResolver::ResolveFromCache(const RequestInfo& original_info,
diff --git a/net/dns/mapped_host_resolver.h b/net/dns/mapped_host_resolver.h
index 50062a9..a121d4e 100644
--- a/net/dns/mapped_host_resolver.h
+++ b/net/dns/mapped_host_resolver.h
@@ -46,6 +46,7 @@ class NET_EXPORT MappedHostResolver : public HostResolver {
 
   // HostResolver methods:
   virtual int Resolve(const RequestInfo& info,
+                      RequestPriority priority,
                       AddressList* addresses,
                       const CompletionCallback& callback,
                       RequestHandle* out_req,
diff --git a/net/dns/mapped_host_resolver_unittest.cc b/net/dns/mapped_host_resolver_unittest.cc
index 571392d..fbbfde8 100644
--- a/net/dns/mapped_host_resolver_unittest.cc
+++ b/net/dns/mapped_host_resolver_unittest.cc
@@ -41,8 +41,8 @@ TEST(MappedHostResolverTest, Inclusion) {
   // hits |resolver_impl| and fails.
   TestCompletionCallback callback;
   rv = resolver->Resolve(
-      HostResolver::RequestInfo(HostPortPair("www.google.com", 80),
-                                DEFAULT_PRIORITY),
+      HostResolver::RequestInfo(HostPortPair("www.google.com", 80)),
+      DEFAULT_PRIORITY,
       &address_list,
       callback.callback(),
       NULL,
@@ -56,8 +56,8 @@ TEST(MappedHostResolverTest, Inclusion) {
 
   // Try resolving "www.google.com:80". Should be remapped to "baz.com:80".
   rv = resolver->Resolve(
-      HostResolver::RequestInfo(HostPortPair("www.google.com", 80),
-                                DEFAULT_PRIORITY),
+      HostResolver::RequestInfo(HostPortPair("www.google.com", 80)),
+      DEFAULT_PRIORITY,
       &address_list,
       callback.callback(),
       NULL,
@@ -69,12 +69,12 @@ TEST(MappedHostResolverTest, Inclusion) {
 
   // Try resolving "foo.com:77". This will NOT be remapped, so result
   // is "foo.com:77".
-  rv = resolver->Resolve(
-      HostResolver::RequestInfo(HostPortPair("foo.com", 77), DEFAULT_PRIORITY),
-      &address_list,
-      callback.callback(),
-      NULL,
-      BoundNetLog());
+  rv = resolver->Resolve(HostResolver::RequestInfo(HostPortPair("foo.com", 77)),
+                         DEFAULT_PRIORITY,
+                         &address_list,
+                         callback.callback(),
+                         NULL,
+                         BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
@@ -84,13 +84,13 @@ TEST(MappedHostResolverTest, Inclusion) {
   EXPECT_TRUE(resolver->AddRuleFromString("Map *.org proxy:99"));
 
   // Try resolving "chromium.org:61". Should be remapped to "proxy:99".
-  rv =
-      resolver->Resolve(HostResolver::RequestInfo(
-                            HostPortPair("chromium.org", 61), DEFAULT_PRIORITY),
-                        &address_list,
-                        callback.callback(),
-                        NULL,
-                        BoundNetLog());
+  rv = resolver->Resolve(
+      HostResolver::RequestInfo(HostPortPair("chromium.org", 61)),
+      DEFAULT_PRIORITY,
+      &address_list,
+      callback.callback(),
+      NULL,
+      BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
@@ -120,8 +120,8 @@ TEST(MappedHostResolverTest, Exclusion) {
 
   // Try resolving "www.google.com". Should not be remapped due to exclusion).
   rv = resolver->Resolve(
-      HostResolver::RequestInfo(HostPortPair("www.google.com", 80),
-                                DEFAULT_PRIORITY),
+      HostResolver::RequestInfo(HostPortPair("www.google.com", 80)),
+      DEFAULT_PRIORITY,
       &address_list,
       callback.callback(),
       NULL,
@@ -132,12 +132,13 @@ TEST(MappedHostResolverTest, Exclusion) {
   EXPECT_EQ("192.168.1.3:80", FirstAddress(address_list));
 
   // Try resolving "chrome.com:80". Should be remapped to "baz:80".
-  rv = resolver->Resolve(HostResolver::RequestInfo(
-                             HostPortPair("chrome.com", 80), DEFAULT_PRIORITY),
-                         &address_list,
-                         callback.callback(),
-                         NULL,
-                         BoundNetLog());
+  rv = resolver->Resolve(
+      HostResolver::RequestInfo(HostPortPair("chrome.com", 80)),
+      DEFAULT_PRIORITY,
+      &address_list,
+      callback.callback(),
+      NULL,
+      BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
@@ -163,8 +164,8 @@ TEST(MappedHostResolverTest, SetRulesFromString) {
 
   // Try resolving "www.google.com". Should be remapped to "baz".
   rv = resolver->Resolve(
-      HostResolver::RequestInfo(HostPortPair("www.google.com", 80),
-                                DEFAULT_PRIORITY),
+      HostResolver::RequestInfo(HostPortPair("www.google.com", 80)),
+      DEFAULT_PRIORITY,
       &address_list,
       callback.callback(),
       NULL,
@@ -175,12 +176,13 @@ TEST(MappedHostResolverTest, SetRulesFromString) {
   EXPECT_EQ("192.168.1.7:80", FirstAddress(address_list));
 
   // Try resolving "chrome.net:80". Should be remapped to "bar:60".
-  rv = resolver->Resolve(HostResolver::RequestInfo(
-                             HostPortPair("chrome.net", 80), DEFAULT_PRIORITY),
-                         &address_list,
-                         callback.callback(),
-                         NULL,
-                         BoundNetLog());
+  rv = resolver->Resolve(
+      HostResolver::RequestInfo(HostPortPair("chrome.net", 80)),
+      DEFAULT_PRIORITY,
+      &address_list,
+      callback.callback(),
+      NULL,
+      BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
@@ -219,8 +221,8 @@ TEST(MappedHostResolverTest, MapToError) {
   // Try resolving www.google.com --> Should give an error.
   TestCompletionCallback callback1;
   rv = resolver->Resolve(
-      HostResolver::RequestInfo(HostPortPair("www.google.com", 80),
-                                DEFAULT_PRIORITY),
+      HostResolver::RequestInfo(HostPortPair("www.google.com", 80)),
+      DEFAULT_PRIORITY,
       &address_list,
       callback1.callback(),
       NULL,
@@ -229,12 +231,13 @@ TEST(MappedHostResolverTest, MapToError) {
 
   // Try resolving www.foo.com --> Should succeed.
   TestCompletionCallback callback2;
-  rv = resolver->Resolve(HostResolver::RequestInfo(
-                             HostPortPair("www.foo.com", 80), DEFAULT_PRIORITY),
-                         &address_list,
-                         callback2.callback(),
-                         NULL,
-                         BoundNetLog());
+  rv = resolver->Resolve(
+      HostResolver::RequestInfo(HostPortPair("www.foo.com", 80)),
+      DEFAULT_PRIORITY,
+      &address_list,
+      callback2.callback(),
+      NULL,
+      BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback2.WaitForResult();
   EXPECT_EQ(OK, rv);
diff --git a/net/dns/mock_host_resolver.cc b/net/dns/mock_host_resolver.cc
index 0ddb8cf..703309a 100644
--- a/net/dns/mock_host_resolver.cc
+++ b/net/dns/mock_host_resolver.cc
@@ -67,6 +67,7 @@ MockHostResolverBase::~MockHostResolverBase() {
 }
 
 int MockHostResolverBase::Resolve(const RequestInfo& info,
+                                  RequestPriority priority,
                                   AddressList* addresses,
                                   const CompletionCallback& callback,
                                   RequestHandle* handle,
@@ -401,6 +402,7 @@ RuleBasedHostResolverProc* CreateCatchAllHostResolverProc() {
 //-----------------------------------------------------------------------------
 
 int HangingHostResolver::Resolve(const RequestInfo& info,
+                                 RequestPriority priority,
                                  AddressList* addresses,
                                  const CompletionCallback& callback,
                                  RequestHandle* out_req,
diff --git a/net/dns/mock_host_resolver.h b/net/dns/mock_host_resolver.h
index b73bd0a..691b49c 100644
--- a/net/dns/mock_host_resolver.h
+++ b/net/dns/mock_host_resolver.h
@@ -75,6 +75,7 @@ class MockHostResolverBase : public HostResolver,
 
   // HostResolver methods:
   virtual int Resolve(const RequestInfo& info,
+                      RequestPriority priority,
                       AddressList* addresses,
                       const CompletionCallback& callback,
                       RequestHandle* out_req,
@@ -216,6 +217,7 @@ RuleBasedHostResolverProc* CreateCatchAllHostResolverProc();
 class HangingHostResolver : public HostResolver {
  public:
   virtual int Resolve(const RequestInfo& info,
+                      RequestPriority priority,
                       AddressList* addresses,
                       const CompletionCallback& callback,
                       RequestHandle* out_req,
diff --git a/net/dns/single_request_host_resolver.cc b/net/dns/single_request_host_resolver.cc
index 31ef4c5..7974aba 100644
--- a/net/dns/single_request_host_resolver.cc
+++ b/net/dns/single_request_host_resolver.cc
@@ -25,9 +25,11 @@ SingleRequestHostResolver::~SingleRequestHostResolver() {
   Cancel();
 }
 
-int SingleRequestHostResolver::Resolve(
-    const HostResolver::RequestInfo& info, AddressList* addresses,
-    const CompletionCallback& callback, const BoundNetLog& net_log) {
+int SingleRequestHostResolver::Resolve(const HostResolver::RequestInfo& info,
+                                       RequestPriority priority,
+                                       AddressList* addresses,
+                                       const CompletionCallback& callback,
+                                       const BoundNetLog& net_log) {
   DCHECK(addresses);
   DCHECK_EQ(false, callback.is_null());
   DCHECK(cur_request_callback_.is_null()) << "resolver already in use";
@@ -40,7 +42,7 @@ int SingleRequestHostResolver::Resolve(
       callback.is_null() ? CompletionCallback() : callback_;
 
   int rv = resolver_->Resolve(
-      info, addresses, transient_callback, &request, net_log);
+      info, priority, addresses, transient_callback, &request, net_log);
 
   if (rv == ERR_IO_PENDING) {
     DCHECK_EQ(false, callback.is_null());
diff --git a/net/dns/single_request_host_resolver.h b/net/dns/single_request_host_resolver.h
index 52d0132..3c8ef02 100644
--- a/net/dns/single_request_host_resolver.h
+++ b/net/dns/single_request_host_resolver.h
@@ -5,10 +5,18 @@
 #ifndef NET_DNS_SINGLE_REQUEST_HOST_RESOLVER_H_
 #define NET_DNS_SINGLE_REQUEST_HOST_RESOLVER_H_
 
+#include "base/basictypes.h"
+
+#include "net/base/completion_callback.h"
+#include "net/base/net_export.h"
+#include "net/base/request_priority.h"
 #include "net/dns/host_resolver.h"
 
 namespace net {
 
+class AddressList;
+class BoundNetLog;
+
 // This class represents the task of resolving a hostname (or IP address
 // literal) to an AddressList object.  It wraps HostResolver to resolve only a
 // single hostname at a time and cancels this request when going out of scope.
@@ -25,6 +33,7 @@ class NET_EXPORT SingleRequestHostResolver {
   // Resolves the given hostname (or IP address literal), filling out the
   // |addresses| object upon success. See HostResolver::Resolve() for details.
   int Resolve(const HostResolver::RequestInfo& info,
+              RequestPriority priority,
               AddressList* addresses,
               const CompletionCallback& callback,
               const BoundNetLog& net_log);
diff --git a/net/dns/single_request_host_resolver_unittest.cc b/net/dns/single_request_host_resolver_unittest.cc
index 6512df6..cc20bf3 100644
--- a/net/dns/single_request_host_resolver_unittest.cc
+++ b/net/dns/single_request_host_resolver_unittest.cc
@@ -31,6 +31,7 @@ class HangingHostResolver : public HostResolver {
   }
 
   virtual int Resolve(const RequestInfo& info,
+                      RequestPriority priority,
                       AddressList* addresses,
                       const CompletionCallback& callback,
                       RequestHandle* out_req,
@@ -75,10 +76,9 @@ TEST(SingleRequestHostResolverTest, NormalResolve) {
   // Resolve "watsup:90" using our SingleRequestHostResolver.
   AddressList addrlist;
   TestCompletionCallback callback;
-  HostResolver::RequestInfo request(HostPortPair("watsup", 90),
-                                    DEFAULT_PRIORITY);
+  HostResolver::RequestInfo request(HostPortPair("watsup", 90));
   int rv = single_request_resolver.Resolve(
-      request, &addrlist, callback.callback(), BoundNetLog());
+      request, DEFAULT_PRIORITY, &addrlist, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
@@ -97,10 +97,12 @@ TEST(SingleRequestHostResolverTest, Cancel) {
     // Resolve "watsup:90" using our SingleRequestHostResolver.
     AddressList addrlist;
     TestCompletionCallback callback;
-    HostResolver::RequestInfo request(HostPortPair("watsup", 90),
-                                      DEFAULT_PRIORITY);
-    int rv = single_request_resolver.Resolve(
-        request, &addrlist, callback.callback(), BoundNetLog());
+    HostResolver::RequestInfo request(HostPortPair("watsup", 90));
+    int rv = single_request_resolver.Resolve(request,
+                                             DEFAULT_PRIORITY,
+                                             &addrlist,
+                                             callback.callback(),
+                                             BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
     EXPECT_TRUE(resolver.has_outstanding_request());
   }