DNS: Support reprioritization of requests.

net/dns/host_resolver_impl.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 <memory>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
@@ skipping 556 matching lines @@
   // NetLog for the source, passed in HostResolver::Resolve.
   const BoundNetLog& source_net_log() {
     return source_net_log_;
   }
 
   const RequestInfo& info() const {
     return info_;
   }
 
   RequestPriority priority() const { return priority_; }
+  void set_priority(RequestPriority priority) { priority_ = priority; }
 
   base::TimeTicks request_time() const { return request_time_; }
 
  private:
   const BoundNetLog source_net_log_;
 
   // The request info that started the request.
   const RequestInfo info_;
 
-  // TODO(akalin): Support reprioritization.
-  const RequestPriority priority_;
+  RequestPriority priority_;
 
   // The resolve job that this request is dependent on.
   Job* job_;
 
   // The user's callback to invoke when the request completes.
   CompletionCallback callback_;
 
   // The address list to save result into.
   AddressList* addresses_;
 
@@ skipping 762 matching lines @@
       had_non_speculative_request_ = true;
       if (proc_task_.get())
         proc_task_->set_had_non_speculative_request();
     }
 
     requests_.push_back(std::move(req));
 
     UpdatePriority();
   }
 
+  void ChangeRequestPriority(Request* req, RequestPriority priority) {
+    DCHECK_EQ(key_.hostname, req->info().hostname());
+    DCHECK(!req->was_canceled());
+
+    priority_tracker_.Remove(req->priority());
+    req->set_priority(priority);
+    priority_tracker_.Add(req->priority());
+    UpdatePriority();
+  }
+
   // Marks |req| as cancelled. If it was the last active Request, also finishes
   // this Job, marking it as cancelled, and deletes it.
   void CancelRequest(Request* req) {
     DCHECK_EQ(key_.hostname, req->info().hostname());
     DCHECK(!req->was_canceled());
 
     // Don't remove it from |requests_| just mark it canceled.
     req->MarkAsCanceled();
     LogCancelRequest(req->source_net_log(), req->info());
 
@@ skipping 87 matching lines @@
     if (is_queued()) {
       resolver_->dispatcher_->Cancel(handle_);
       handle_.Reset();
     } else if (num_occupied_job_slots_ > 1) {
       resolver_->dispatcher_->OnJobFinished();
       --num_occupied_job_slots_;
     }
     DCHECK_EQ(1u, num_occupied_job_slots_);
   }
 
+  AddressList MakeAddressListForRequest(const AddressList& list) const {
+    if (requests_.empty())
+      return list;
+    return AddressList::CopyWithPort(list, requests_.front()->info().port());
+  }
+
   void UpdatePriority() {
     if (is_queued()) {
       if (priority() != static_cast<RequestPriority>(handle_.priority()))
         priority_change_time_ = base::TimeTicks::Now();
       handle_ = resolver_->dispatcher_->ChangePriority(handle_, priority());
     }
   }
 
-  AddressList MakeAddressListForRequest(const AddressList& list) const {
-    if (requests_.empty())
-      return list;
-    return AddressList::CopyWithPort(list, requests_.front()->info().port());
-  }
-
   // PriorityDispatch::Job:
   void Start() override {
     DCHECK_LE(num_occupied_job_slots_, 1u);
 
     handle_.Reset();
     ++num_occupied_job_slots_;
 
     if (num_occupied_job_slots_ == 2) {
       StartSecondDnsTransaction();
       return;
@@ skipping 537 matching lines @@
   if (ip_address.AssignFromIPLiteral(info.hostname()))
     ip_address_ptr = &ip_address;
 
   Key key = GetEffectiveKeyForRequest(info, ip_address_ptr, source_net_log);
 
   int rv = ResolveHelper(key, info, ip_address_ptr, addresses, source_net_log);
   LogFinishRequest(source_net_log, info, rv);
   return rv;
 }
 
+void HostResolverImpl::ChangeRequestPriority(RequestHandle req_handle,
+                                             RequestPriority priority) {
+  DCHECK(CalledOnValidThread());
+  Request* req = reinterpret_cast<Request*>(req_handle);
+  DCHECK(req);
+  Job* job = req->job();
+  DCHECK(job);
+  job->ChangeRequestPriority(req, priority);
+}
+
 void HostResolverImpl::CancelRequest(RequestHandle req_handle) {
   DCHECK(CalledOnValidThread());
   Request* req = reinterpret_cast<Request*>(req_handle);
   DCHECK(req);
   Job* job = req->job();
   DCHECK(job);
   job->CancelRequest(req);
 }
 
 void HostResolverImpl::SetDnsClientEnabled(bool enabled) {
@@ skipping 404 matching lines @@
     dns_client_->SetConfig(dns_config);
     num_dns_failures_ = 0;
     if (dns_client_->GetConfig())
       UMA_HISTOGRAM_BOOLEAN("AsyncDNS.DnsClientEnabled", true);
   }
 
   AbortDnsTasks();
 }
 
 }  // namespace net