[ABANDONED] [WIP] Schedule async revalidations after other requests.

content/browser/loader/resource_scheduler.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 <set>
 
 #include "content/browser/loader/resource_scheduler.h"
 
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
@@ skipping 149 matching lines @@
   ScheduledResourceRequest(const ClientId& client_id,
                            net::URLRequest* request,
                            ResourceScheduler* scheduler,
                            const RequestPriorityParams& priority)
       : ResourceMessageDelegate(request),
         client_id_(client_id),
         client_state_on_creation_(scheduler->GetClientState(client_id_)),
         request_(request),
         ready_(false),
         deferred_(false),
+        is_async_revalidation_(false),
         classification_(NORMAL_REQUEST),
         scheduler_(scheduler),
         priority_(priority),
         fifo_ordering_(0) {
+    is_async_revalidation_ =
+        ResourceRequestInfo::ForRequest(request)->IsAsyncRevalidation();
   }
 
   ~ScheduledResourceRequest() override { scheduler_->RemoveRequest(this); }
 
   void Start() {
     ready_ = true;
     if (!request_->status().is_success())
       return;
     base::TimeTicks time = base::TimeTicks::Now();
     ClientState current_state = scheduler_->GetClientState(client_id_);
@@ skipping 35 matching lines @@
   uint32 fifo_ordering() const { return fifo_ordering_; }
   void set_fifo_ordering(uint32 fifo_ordering) {
     fifo_ordering_ = fifo_ordering;
   }
   RequestClassification classification() const {
     return classification_;
   }
   void set_classification(RequestClassification classification) {
     classification_ = classification;
   }
+  bool is_async_revalidation() const { return is_async_revalidation_; }
 
  private:
   // ResourceMessageDelegate interface:
   bool OnMessageReceived(const IPC::Message& message) override {
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(ScheduledResourceRequest, message)
       IPC_MESSAGE_HANDLER(ResourceHostMsg_DidChangePriority, DidChangePriority)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
     return handled;
@@ skipping 10 matching lines @@
   void DidChangePriority(int request_id, net::RequestPriority new_priority,
                          int intra_priority_value) {
     scheduler_->ReprioritizeRequest(this, new_priority, intra_priority_value);
   }
 
   const ClientId client_id_;
   const ResourceScheduler::ClientState client_state_on_creation_;
   net::URLRequest* request_;
   bool ready_;
   bool deferred_;
+  bool is_async_revalidation_;
   RequestClassification classification_;
   ResourceScheduler* scheduler_;
   RequestPriorityParams priority_;
   uint32 fifo_ordering_;
   base::TimeTicks time_deferred_;
 
   DISALLOW_COPY_AND_ASSIGN(ScheduledResourceRequest);
 };
 
 bool ResourceScheduler::ScheduledResourceSorter::operator()(
     const ScheduledResourceRequest* a,
     const ScheduledResourceRequest* b) const {
+  // Want all other requests to be ordered before async revalidations.
+  if (a->is_async_revalidation() != b->is_async_revalidation())
+    return b->is_async_revalidation();
+
   // Want the set to be ordered first by decreasing priority, then by
   // decreasing intra_priority.
   // ie. with (priority, intra_priority)
   // [(1, 0), (1, 0), (0, 100), (0, 0)]
   if (a->get_request_priority_params() != b->get_request_priority_params())
     return a->get_request_priority_params().GreaterThan(
         b->get_request_priority_params());
 
   // If priority/intra_priority is the same, fall back to fifo ordering.
   // std::multiset doesn't guarantee this until c++11.
@@ skipping 401 matching lines @@
   //     THROTTLED Client
   //   * If no high priority requests are in flight, start loading low priority
   //     requests.
   //
   //  COALESCED Clients never load requests, with the following exceptions:
   //   * Non-delayable requests are issued imediately.
   //   * On a (currently 5 second) heart beat, they load all requests as an
   //     UNTHROTTLED Client, and then return to the COALESCED state.
   //   * When an active Client makes a request, they are THROTTLED until the
   //     active Client finishes loading.
+  //
+  // 6. Async revalidations
+  //   * Async revalidations come after all other requests, and are never loaded
+  //     until the document has a body.
   ShouldStartReqResult ShouldStartRequest(
       ScheduledResourceRequest* request) const {
     const net::URLRequest& url_request = *request->url_request();
     // Syncronous requests could block the entire render, which could impact
     // user-observable Clients.
     if (!ResourceRequestInfo::ForRequest(&url_request)->IsAsync()) {
       return START_REQUEST;
     }
 
     // TODO(simonjam): This may end up causing disk contention. We should
     // experiment with throttling if that happens.
     // TODO(aiolos): We probably want to Coalesce these as well to avoid
     // waking the disk.
     if (!url_request.url().SchemeIsHTTPOrHTTPS()) {
       return START_REQUEST;
     }
 
+    if (request->is_async_revalidation() && !has_body_) {
+      // Because async revalidations are sorted last, all following requests
+      // will also be async revalidations.
+      return DO_NOT_START_REQUEST_AND_STOP_SEARCHING;
+    }
+
     if (throttle_state_ == COALESCED) {
       return DO_NOT_START_REQUEST_AND_STOP_SEARCHING;
     }
 
     if (using_spdy_proxy_ && url_request.url().SchemeIs(url::kHttpScheme)) {
       return START_REQUEST;
     }
 
     net::HostPortPair host_port_pair =
         net::HostPortPair::FromURL(url_request.url());
@@ skipping 429 matching lines @@
   client->ReprioritizeRequest(
       request, old_priority_params, new_priority_params);
 }
 
 ResourceScheduler::ClientId ResourceScheduler::MakeClientId(
     int child_id, int route_id) {
   return (static_cast<ResourceScheduler::ClientId>(child_id) << 32) | route_id;
 }
 
 }  // namespace content