Fix Resource Priorities and Scheduling (Chrome Side)

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/base_switches.h"
+#include "base/basictypes.h"
+#include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/time/time.h"
 #include "content/common/resource_messages.h"
 #include "content/browser/loader/resource_message_delegate.h"
 #include "content/public/browser/resource_controller.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/resource_throttle.h"
+#include "content/public/common/content_switches.h"
 #include "ipc/ipc_message_macros.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/load_flags.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_server_properties.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 
 namespace content {
 
@@ skipping 277 matching lines @@
       : is_audible_(is_audible),
         is_visible_(is_visible),
         is_loaded_(false),
         is_paused_(false),
         has_body_(false),
         using_spdy_proxy_(false),
         load_started_time_(base::TimeTicks::Now()),
         scheduler_(scheduler),
         in_flight_delayable_count_(0),
         total_layout_blocking_count_(0),
-        throttle_state_(ResourceScheduler::THROTTLED) {}
+        throttle_state_(ResourceScheduler::THROTTLED),
+        fetch_mode_(0) {
+          std::string fetch_mode_cmd =

[Bryan McQuade, 2015/07/22 17:46:48]

Could we make ResourceScheduler constructor the canonical place for parsing the
command line flag, and have ResourceScheduler pass the fetch mode in to this
constructor when it creates a Client instance?

[Pat Meenan, 2015/07/28 17:14:21]

Done.

+              base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+                  switches::kFetchMode);
+          if (!fetch_mode_cmd.empty()) {
+            int temp;
+            if (base::StringToInt(fetch_mode_cmd, &temp))
+              fetch_mode_ = temp;
+          }
+        }
 
   ~Client() {
     // Update to default state and pause to ensure the scheduler has a
     // correct count of relevant types of clients.
     is_visible_ = false;
     is_audible_ = false;
     is_paused_ = true;
     UpdateThrottleState();
   }
 
   void ScheduleRequest(
       net::URLRequest* url_request,
       ScheduledResourceRequest* request) {
+/*
+    char buff[20];
+    wsprintfA(buff, "[%d] - ", request->get_request_priority_params().priority);
+    OutputDebugStringA(std::string(std::string(buff) + request->url_request()->url().spec()).c_str());
+*/
     if (ShouldStartRequest(request) == START_REQUEST)
       StartRequest(request);
     else
       pending_requests_.Insert(request);
     SetRequestClassification(request, ClassifyRequest(request));
   }
 
   void RemoveRequest(ScheduledResourceRequest* request) {
     if (pending_requests_.IsQueued(request)) {
       pending_requests_.Erase(request);
@@ skipping 127 matching lines @@
       scheduler_->DecrementCoalescedClients();
     }
   }
 
   void OnNavigate() {
     has_body_ = false;
     is_loaded_ = false;
   }
 
   void OnWillInsertBody() {
+//    OutputDebugStringA("************ Inserted Body");
     has_body_ = true;
     LoadAnyStartablePendingRequests();
   }
 
   void OnReceivedSpdyProxiedHttpResponse() {
     if (!using_spdy_proxy_) {
       using_spdy_proxy_ = true;
       LoadAnyStartablePendingRequests();
     }
   }
 
   void ReprioritizeRequest(ScheduledResourceRequest* request,
                            RequestPriorityParams old_priority_params,
                            RequestPriorityParams new_priority_params) {
     request->url_request()->SetPriority(new_priority_params.priority);
     request->set_request_priority_params(new_priority_params);
+/*
+    char buff[30];
+    wsprintfA(buff, "[%d -> %d] - ", old_priority_params.priority, new_priority_params.priority);
+    OutputDebugStringA(std::string(std::string(buff) + request->url_request()->url().spec()).c_str());
+*/
     if (!pending_requests_.IsQueued(request)) {
       DCHECK(ContainsKey(in_flight_requests_, request));
       // The priority of the request and priority support of the server may
       // have changed, so update the delayable count.
       SetRequestClassification(request, ClassifyRequest(request));
       // Request has already started.
       return;
     }
 
     pending_requests_.Erase(request);
@@ skipping 113 matching lines @@
     DCHECK_EQ(
         CountRequestsWithClassification(IN_FLIGHT_DELAYABLE_REQUEST, false),
         in_flight_delayable_count_);
     DCHECK_EQ(CountRequestsWithClassification(LAYOUT_BLOCKING_REQUEST, true),
               total_layout_blocking_count_);
   }
 
   RequestClassification ClassifyRequest(ScheduledResourceRequest* request) {
     // If a request is already marked as layout-blocking make sure to keep the
     // classification across redirects unless the priority was lowered.
-    if (request->classification() == LAYOUT_BLOCKING_REQUEST &&
-        request->url_request()->priority() > net::LOW) {
-      return LAYOUT_BLOCKING_REQUEST;
-    }
+    if (fetch_mode_ == 2) {
+      if (request->classification() == LAYOUT_BLOCKING_REQUEST &&
+          request->url_request()->priority() > net::MEDIUM) {
+        return LAYOUT_BLOCKING_REQUEST;
+      }
 
-    if (!has_body_ && request->url_request()->priority() > net::LOW)
-      return LAYOUT_BLOCKING_REQUEST;
+      if (!has_body_ && request->url_request()->priority() > net::MEDIUM)
+        return LAYOUT_BLOCKING_REQUEST;
 
-    if (request->url_request()->priority() < net::LOW) {
-      net::HostPortPair host_port_pair =
-          net::HostPortPair::FromURL(request->url_request()->url());
-      net::HttpServerProperties& http_server_properties =
-          *request->url_request()->context()->http_server_properties();
-      if (!http_server_properties.SupportsRequestPriority(host_port_pair) &&
-          ContainsKey(in_flight_requests_, request)) {
-        return IN_FLIGHT_DELAYABLE_REQUEST;
+      if (request->url_request()->priority() < net::MEDIUM) {
+        net::HostPortPair host_port_pair =
+            net::HostPortPair::FromURL(request->url_request()->url());
+        net::HttpServerProperties& http_server_properties =
+            *request->url_request()->context()->http_server_properties();
+        if (!http_server_properties.SupportsRequestPriority(host_port_pair) &&
+            ContainsKey(in_flight_requests_, request)) {
+          return IN_FLIGHT_DELAYABLE_REQUEST;
+        }
+      }
+    } else {
+      if (request->classification() == LAYOUT_BLOCKING_REQUEST &&
+          request->url_request()->priority() > net::LOW) {
+        return LAYOUT_BLOCKING_REQUEST;
+      }
+
+      if (!has_body_ && request->url_request()->priority() > net::LOW)
+        return LAYOUT_BLOCKING_REQUEST;
+
+      if (request->url_request()->priority() < net::LOW) {
+        net::HostPortPair host_port_pair =
+            net::HostPortPair::FromURL(request->url_request()->url());
+        net::HttpServerProperties& http_server_properties =
+            *request->url_request()->context()->http_server_properties();
+        if (!http_server_properties.SupportsRequestPriority(host_port_pair) &&
+            ContainsKey(in_flight_requests_, request)) {
+          return IN_FLIGHT_DELAYABLE_REQUEST;
+        }
       }
     }
     return NORMAL_REQUEST;
   }
 
   bool ShouldKeepSearching(
       const net::HostPortPair& active_request_host) const {
     size_t same_host_count = 0;
     for (RequestSet::const_iterator it = in_flight_requests_.begin();
          it != in_flight_requests_.end(); ++it) {
       net::HostPortPair host_port_pair =
           net::HostPortPair::FromURL((*it)->url_request()->url());
       if (active_request_host.Equals(host_port_pair)) {
         same_host_count++;
         if (same_host_count >= kMaxNumDelayableRequestsPerHost)
           return true;
       }
     }
     return false;
   }
 
   void StartRequest(ScheduledResourceRequest* request) {
     InsertInFlightRequest(request);
+/*
+    size_t counts[5];
+    memset(&counts, 0, sizeof(counts));
+    // count the in-flight requests at each priority level
+    for (RequestSet::const_iterator it = in_flight_requests_.begin();
+         it != in_flight_requests_.end(); ++it) {
+      int priority = (*it)->get_request_priority_params().priority;
+      if (priority >= 0 && priority <= 4) {
+        counts[priority]++;
+      }
+    }
+    char buff[80];
+    wsprintfA(buff, "Starting [%d] - %s{%d:%d:%d:%d:%d}%s - ", request->get_request_priority_params().priority, has_body_ ? "" : "*", counts[0], counts[1], counts[2], counts[3], counts[4], has_body_ ? "" : "*");
+    OutputDebugStringA(std::string(std::string(buff) + request->url_request()->url().spec()).c_str());
+*/
     request->Start();
   }
 
   // ShouldStartRequest is the main scheduling algorithm.
   //
   // Requests are evaluated on five attributes:
   //
   // 1. Non-delayable requests:
   //   * Synchronous requests.
   //   * Non-HTTP[S] requests.
@@ skipping 86 matching lines @@
     }
 
     if (throttle_state_ == THROTTLED &&
         in_flight_requests_.size() >= kMaxNumThrottledRequestsPerClient) {
       // There may still be request-priority-capable requests that should be
       // issued.
       return DO_NOT_START_REQUEST_AND_KEEP_SEARCHING;
     }
 
     // High-priority and layout-blocking requests.
-    if (url_request.priority() >= net::LOW) {
-      return START_REQUEST;
+    if (fetch_mode_ == 2) {
+      if (url_request.priority() >= net::MEDIUM) {
+        return START_REQUEST;
+      }
+    } else {
+      if (url_request.priority() >= net::LOW) {
+        return START_REQUEST;
+      }
     }
 
     if (in_flight_delayable_count_ >= kMaxNumDelayableRequestsPerClient) {
       return DO_NOT_START_REQUEST_AND_STOP_SEARCHING;
     }
 
     if (ShouldKeepSearching(host_port_pair)) {
       // There may be other requests for other hosts we'd allow,
       // so keep checking.
       return DO_NOT_START_REQUEST_AND_KEEP_SEARCHING;
     }
 
-    bool have_immediate_requests_in_flight =
-        in_flight_requests_.size() > in_flight_delayable_count_;
-    if (have_immediate_requests_in_flight &&
-        (!has_body_ || total_layout_blocking_count_ != 0) &&
-        // Do not allow a low priority request through in parallel if
-        // we are in a limit field trial.
-        (scheduler_->limit_outstanding_requests() ||
-         in_flight_delayable_count_ != 0)) {
-      return DO_NOT_START_REQUEST_AND_STOP_SEARCHING;
+    if (fetch_mode_ == 2) {
+      // If we are in render-blocking more make sure at least 2 requests
+      // are in-flight. High priority requests would have alreay
+      // been allowed so this just restricts low-priority requests.
+      if ((!has_body_ || total_layout_blocking_count_ != 0) &&
+          in_flight_requests_.size() >= 2) {
+        return DO_NOT_START_REQUEST_AND_STOP_SEARCHING;
+      }
+
+      // only allow 1 lower priority resource while 1 higher priority resource is pending
+      size_t higher_priority = 0;
+      size_t equal_priority = 0;
+      net::RequestPriority priority = url_request.priority();
+      for (RequestSet::const_iterator it = in_flight_requests_.begin();
+           it != in_flight_requests_.end(); ++it) {
+        net::RequestPriority pending_priority = (*it)->get_request_priority_params().priority;
+        if (pending_priority > priority) {
+          higher_priority++;
+        } else if (pending_priority == priority) {
+          equal_priority++;
+        }
+      }
+      if (higher_priority > 1 || (higher_priority == 1 && equal_priority > 0)) {
+        return DO_NOT_START_REQUEST_AND_STOP_SEARCHING;
+      }
+
+    } else {
+      bool have_immediate_requests_in_flight =
+          in_flight_requests_.size() > in_flight_delayable_count_;
+      if (have_immediate_requests_in_flight &&
+          (!has_body_ || total_layout_blocking_count_ != 0) &&
+          // Do not allow a low priority request through in parallel if
+          // we are in a limit field trial.
+          (scheduler_->limit_outstanding_requests() ||
+           in_flight_delayable_count_ != 0)) {
+        return DO_NOT_START_REQUEST_AND_STOP_SEARCHING;
+      }
     }
 
     return START_REQUEST;
   }
 
   void LoadAnyStartablePendingRequests() {
     // We iterate through all the pending requests, starting with the highest
     // priority one. For each entry, one of three things can happen:
     // 1) We start the request, remove it from the list, and keep checking.
     // 2) We do NOT start the request, but ShouldStartRequest() signals us that
@@ skipping 39 matching lines @@
   RequestSet in_flight_requests_;
   base::TimeTicks load_started_time_;
   // The last time the client switched state between active and background.
   base::TimeTicks last_active_switch_time_;
   ResourceScheduler* scheduler_;
   // The number of delayable in-flight requests.
   size_t in_flight_delayable_count_;
   // The number of layout-blocking in-flight requests.
   size_t total_layout_blocking_count_;
   ResourceScheduler::ClientThrottleState throttle_state_;
+  int fetch_mode_;
 };
 
 ResourceScheduler::ResourceScheduler()
     : should_coalesce_(false),
       should_throttle_(false),
       active_clients_loading_(0),
       coalesced_clients_(0),
       limit_outstanding_requests_(false),
       outstanding_request_limit_(0),
+      fetch_mode_(0),
       coalescing_timer_(new base::Timer(true /* retain_user_task */,
                                         true /* is_repeating */)) {
   std::string throttling_trial_group =
       base::FieldTrialList::FindFullName(kThrottleCoalesceFieldTrial);
   if (throttling_trial_group == kThrottleCoalesceFieldTrialThrottle) {
     should_throttle_ = true;
   } else if (throttling_trial_group == kThrottleCoalesceFieldTrialCoalesce) {
     should_coalesce_ = true;
     should_throttle_ = true;
   }
 
   std::string outstanding_limit_trial_group =
       base::FieldTrialList::FindFullName(kRequestLimitFieldTrial);
   std::vector<std::string> split_group(
       base::SplitString(outstanding_limit_trial_group, "=",
                         base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL));
   int outstanding_limit = 0;
   if (split_group.size() == 2 &&
       split_group[0] == kRequestLimitFieldTrialGroupPrefix &&
       base::StringToInt(split_group[1], &outstanding_limit) &&
       outstanding_limit > 0) {
     limit_outstanding_requests_ = true;
     outstanding_request_limit_ = outstanding_limit;
   }
+
+  std::string fetch_mode_cmd =
+      base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+          switches::kFetchMode);
+  if (!fetch_mode_cmd.empty()) {
+    int temp;
+    if (base::StringToInt(fetch_mode_cmd, &temp))
+      fetch_mode_ = temp;
+  }
 }
 
 ResourceScheduler::~ResourceScheduler() {
   DCHECK(unowned_requests_.empty());
   DCHECK(client_map_.empty());
 }
 
 void ResourceScheduler::SetThrottleOptionsForTesting(bool should_throttle,
                                                      bool should_coalesce) {
   should_coalesce_ = should_coalesce;
@@ skipping 283 matching lines @@
     NOTREACHED();
     return;
   }
   RequestPriorityParams new_priority_params(new_priority,
       new_intra_priority_value);
   RequestPriorityParams old_priority_params =
       request->get_request_priority_params();
 
   DCHECK(old_priority_params != new_priority_params);
 
+  // only allow priority promotions
+  if (fetch_mode_ == 2 && old_priority_params.GreaterThan(new_priority_params))
+    return;
+
   ClientMap::iterator client_it = client_map_.find(request->client_id());
   if (client_it == client_map_.end()) {
     // The client was likely deleted shortly before we received this IPC.
     request->url_request()->SetPriority(new_priority_params.priority);
     request->set_request_priority_params(new_priority_params);
     return;
   }
 
   if (old_priority_params == new_priority_params)
     return;
 
   Client *client = client_it->second;
   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