tools: Local tests for the speculative prefetch predictor.

chrome/browser/predictors/resource_prefetch_common.cc

 // Copyright 2014 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 "chrome/browser/predictors/resource_prefetch_common.h"
 
 #include <stdlib.h>
 #include <tuple>
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_split.h"
 #include "chrome/browser/net/prediction_options.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 
 using base::FieldTrialList;
 using std::string;
 using std::vector;
 
 namespace predictors {
 
-const char kSpeculativePrefetchingTrialName[] =
+namespace {
+constexpr int kUrlHostLearningMode =
+    ResourcePrefetchPredictorConfig::URL_LEARNING |
+    ResourcePrefetchPredictorConfig::HOST_LEARNING;
+constexpr int kUrlHostPrefetchingMode =
+    ResourcePrefetchPredictorConfig::URL_PREFETCHING |
+    ResourcePrefetchPredictorConfig::HOST_PREFETCHING;
+
+constexpr char kSpeculativePrefetchingTrialName[] =
     "SpeculativeResourcePrefetching";
+}  // namespace
 
 /*
  * SpeculativeResourcePrefetching is a field trial, and its value must have the
  * following format: key1=value1:key2=value2:key3=value3
  * e.g. "Prefetching=Enabled:Predictor=Url:Confidence=High"
  * The function below extracts the value corresponding to a key provided from
  * the SpeculativeResourcePrefetching field trial.
  */
 std::string GetFieldTrialSpecValue(string key) {
   std::string trial_name =
@@ skipping 21 matching lines @@
   // set. The command line with just enable them with the default params.
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kSpeculativeResourcePrefetching)) {
     const std::string value =
         base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
             switches::kSpeculativeResourcePrefetching);
 
     if (value == switches::kSpeculativeResourcePrefetchingDisabled) {
       return false;
     } else if (value == switches::kSpeculativeResourcePrefetchingLearning) {
-      config->mode |= ResourcePrefetchPredictorConfig::URL_LEARNING;
-      config->mode |= ResourcePrefetchPredictorConfig::HOST_LEARNING;
+      config->mode |= kUrlHostLearningMode;
+      return true;
+    } else if (value ==
+               switches::kSpeculativeResourceExternalPrefetchingEnabled) {
+      config->mode |= kUrlHostLearningMode | kUrlHostPrefetchingMode;

[pasko, 2016/11/24 19:31:16]

why setting kUrlHostPrefetchingMode bit here? I thought it would be ignored via
EXTERNAL_ONLY. Is it going to be ignored only sometimes?

+      config->mode |= ResourcePrefetchPredictorConfig::EXTERNAL_ONLY;
       return true;
     } else if (value == switches::kSpeculativeResourcePrefetchingEnabled) {
-      config->mode |= ResourcePrefetchPredictorConfig::URL_LEARNING;
-      config->mode |= ResourcePrefetchPredictorConfig::HOST_LEARNING;
-      config->mode |= ResourcePrefetchPredictorConfig::URL_PREFETCHING;
-      config->mode |= ResourcePrefetchPredictorConfig::HOST_PRFETCHING;
+      config->mode |= kUrlHostLearningMode;

[pasko, 2016/11/24 19:31:16]

why only learning is enabled here?

[Benoit L, 2016/11/30 12:08:27]

Done.

       return true;
     }
   }
 
   // Disable if no field trial is specified.
   std::string trial = base::FieldTrialList::FindFullName(
         kSpeculativePrefetchingTrialName);
   if (trial.empty())
     return false;
 
   // Enabled by field trial.
   std::string spec_prefetching = GetFieldTrialSpecValue("Prefetching");
   std::string spec_predictor = GetFieldTrialSpecValue("Predictor");
   std::string spec_confidence = GetFieldTrialSpecValue("Confidence");
   std::string spec_more_resources = GetFieldTrialSpecValue("MoreResources");
   std::string spec_small_db = GetFieldTrialSpecValue("SmallDB");
 
   if (spec_prefetching == "Learning") {
     if (spec_predictor == "Url") {
       config->mode |= ResourcePrefetchPredictorConfig::URL_LEARNING;
     } else if (spec_predictor == "Host") {
       config->mode |= ResourcePrefetchPredictorConfig::HOST_LEARNING;
     } else {
       // Default: both Url and Host
-      config->mode |= ResourcePrefetchPredictorConfig::URL_LEARNING;
-      config->mode |= ResourcePrefetchPredictorConfig::HOST_LEARNING;
+      config->mode |= kUrlHostLearningMode;
     }
   } else if (spec_prefetching == "Enabled") {
     if (spec_predictor == "Url") {
       config->mode |= ResourcePrefetchPredictorConfig::URL_LEARNING;
       config->mode |= ResourcePrefetchPredictorConfig::URL_PREFETCHING;
     } else if (spec_predictor == "Host") {
       config->mode |= ResourcePrefetchPredictorConfig::HOST_LEARNING;
-      config->mode |= ResourcePrefetchPredictorConfig::HOST_PRFETCHING;
+      config->mode |= ResourcePrefetchPredictorConfig::HOST_PREFETCHING;
     } else {
       // Default: both Url and Host
-      config->mode |= ResourcePrefetchPredictorConfig::URL_LEARNING;
-      config->mode |= ResourcePrefetchPredictorConfig::HOST_LEARNING;
-      config->mode |= ResourcePrefetchPredictorConfig::URL_PREFETCHING;
-      config->mode |= ResourcePrefetchPredictorConfig::HOST_PRFETCHING;
+      config->mode |= kUrlHostLearningMode | kUrlHostPrefetchingMode;
     }
   } else {
     // Default: spec_prefetching == "Disabled"
     return false;
   }
 
   if (spec_confidence == "Low") {
     config->min_url_visit_count = 1;
     config->min_resource_confidence_to_trigger_prefetch = 0.5f;
     config->min_resource_hits_to_trigger_prefetch = 1;
@@ skipping 84 matching lines @@
 ResourcePrefetchPredictorConfig::ResourcePrefetchPredictorConfig(
     const ResourcePrefetchPredictorConfig& other) = default;
 
 ResourcePrefetchPredictorConfig::~ResourcePrefetchPredictorConfig() {
 }
 
 bool ResourcePrefetchPredictorConfig::IsLearningEnabled() const {
   return IsURLLearningEnabled() || IsHostLearningEnabled();
 }
 
+bool ResourcePrefetchPredictorConfig::ExternalPrefetchingOnly() const {

[pasko, 2016/11/24 19:31:16]

I am confused by this name

"ExternalPrefetchingOnly" suggests to me that only external prefetching is
enabled by this config. At the same time the code asserts that learning is
allowed as well.

+  return (mode & EXTERNAL_ONLY) > 0;
+}
+
 bool ResourcePrefetchPredictorConfig::IsPrefetchingEnabled(
     Profile* profile) const {
   return IsURLPrefetchingEnabled(profile) || IsHostPrefetchingEnabled(profile);
 }
 
 bool ResourcePrefetchPredictorConfig::IsURLLearningEnabled() const {
   return (mode & URL_LEARNING) > 0;
 }
 
 bool ResourcePrefetchPredictorConfig::IsHostLearningEnabled() const {
@@ skipping 12 matching lines @@
 }
 
 bool ResourcePrefetchPredictorConfig::IsHostPrefetchingEnabled(
     Profile* profile) const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (!profile || !profile->GetPrefs() ||
       chrome_browser_net::CanPrefetchAndPrerenderUI(profile->GetPrefs()) !=
       chrome_browser_net::NetworkPredictionStatus::ENABLED) {
     return false;
   }
-  return (mode & HOST_PRFETCHING) > 0;
+  return (mode & HOST_PREFETCHING) > 0;
 }
 
 bool ResourcePrefetchPredictorConfig::IsLowConfidenceForTest() const {
   return min_url_visit_count == 1 &&
       std::abs(min_resource_confidence_to_trigger_prefetch - 0.5f) < 1e-6 &&
       min_resource_hits_to_trigger_prefetch == 1;
 }
 
 bool ResourcePrefetchPredictorConfig::IsHighConfidenceForTest() const {
   return min_url_visit_count == 3 &&
       std::abs(min_resource_confidence_to_trigger_prefetch - 0.9f) < 1e-6 &&
       min_resource_hits_to_trigger_prefetch == 3;
 }
 
 bool ResourcePrefetchPredictorConfig::IsMoreResourcesEnabledForTest() const {
   return max_resources_per_entry == 100;
 }
 
 bool ResourcePrefetchPredictorConfig::IsSmallDBEnabledForTest() const {
   return max_urls_to_track == 200 && max_hosts_to_track == 100;
 }
 
 }  // namespace predictors