Poll CanPredictNetworkActions in Predictor class.

chrome/browser/net/predictor.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 "chrome/browser/net/predictor.h"
 
 #include <algorithm>
 #include <cmath>
 #include <set>
 #include <sstream>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/containers/mru_cache.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/net/preconnect.h"
+#include "chrome/browser/net/prediction_options.h"
 #include "chrome/browser/net/spdyproxy/proxy_advisor.h"
 #include "chrome/browser/prefs/session_startup_pref.h"
+#include "chrome/browser/profiles/profile_io_data.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "components/data_reduction_proxy/browser/data_reduction_proxy_settings.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
@@ skipping 85 matching lines @@
 
   Predictor* predictor_;  // The predictor which started us.
 
   const GURL url_;  // Hostname to resolve.
   net::SingleRequestHostResolver resolver_;
   net::AddressList addresses_;
 
   DISALLOW_COPY_AND_ASSIGN(LookupRequest);
 };
 
-Predictor::Predictor(bool preconnect_enabled)
+Predictor::Predictor(bool preconnect_enabled, bool predictor_enabled)
     : url_request_context_getter_(NULL),
-      predictor_enabled_(true),
+      predictor_enabled_(predictor_enabled),
+      user_prefs_(NULL),
+      profile_io_data_(NULL),
       peak_pending_lookups_(0),
       shutdown_(false),
       max_concurrent_dns_lookups_(g_max_parallel_resolves),
       max_dns_queue_delay_(
           TimeDelta::FromMilliseconds(g_max_queueing_delay_ms)),
       host_resolver_(NULL),
       transport_security_state_(NULL),
       ssl_config_service_(NULL),
       preconnect_enabled_(preconnect_enabled),
       consecutive_omnibox_preconnect_count_(0),
       next_trim_time_(base::TimeTicks::Now() +
                       TimeDelta::FromHours(kDurationBetweenTrimmingsHours)),
       observer_(NULL) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 Predictor::~Predictor() {
   // TODO(rlp): Add DCHECK for CurrentlyOn(BrowserThread::IO) when the
   // ProfileManagerTest has been updated with a mock profile.
   DCHECK(shutdown_);
 }
 
 // static
 Predictor* Predictor::CreatePredictor(bool preconnect_enabled,
+                                      bool predictor_enabled,
                                       bool simple_shutdown) {
   if (simple_shutdown)
-    return new SimplePredictor(preconnect_enabled);
-  return new Predictor(preconnect_enabled);
+    return new SimplePredictor(preconnect_enabled, predictor_enabled);
+  return new Predictor(preconnect_enabled, predictor_enabled);
 }
 
 void Predictor::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterListPref(prefs::kDnsPrefetchingStartupList,
                              user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterListPref(prefs::kDnsPrefetchingHostReferralList,
                              user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 // --------------------- Start UI methods. ------------------------------------
 
 void Predictor::InitNetworkPredictor(PrefService* user_prefs,
                                      PrefService* local_state,
                                      IOThread* io_thread,
-                                     net::URLRequestContextGetter* getter) {
+                                     net::URLRequestContextGetter* getter,
+                                     ProfileIOData* profile_io_data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  bool predictor_enabled =
-      user_prefs->GetBoolean(prefs::kNetworkPredictionEnabled);
-
+  user_prefs_ = user_prefs;
   url_request_context_getter_ = getter;
 
   // Gather the list of hostnames to prefetch on startup.
   UrlList urls = GetPredictedUrlListAtStartup(user_prefs, local_state);
 
   base::ListValue* referral_list =
       static_cast<base::ListValue*>(user_prefs->GetList(
           prefs::kDnsPrefetchingHostReferralList)->DeepCopy());
 
   // Now that we have the statistics in memory, wipe them from the Preferences
@@ skipping 15 matching lines @@
   }
 #endif
 
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(
           &Predictor::FinalizeInitializationOnIOThread,
           base::Unretained(this),
           urls, referral_list,
-          io_thread, predictor_enabled));
+          io_thread, profile_io_data));
 }
 
 void Predictor::AnticipateOmniboxUrl(const GURL& url, bool preconnectable) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!predictor_enabled_)
     return;
   if (!url.is_valid() || !url.has_host())
     return;
   std::string host = url.HostNoBrackets();
   bool is_new_host_request = (host != last_omnibox_host_);
   last_omnibox_host_ = host;
 
   UrlInfo::ResolutionMotivation motivation(UrlInfo::OMNIBOX_MOTIVATED);
   base::TimeTicks now = base::TimeTicks::Now();
 
-  if (preconnect_enabled()) {
+  if (preconnect_enabled_ &&
+      chrome_browser_net::CanPredictNetworkActionsUI(user_prefs_)) {

[battre, 2014/07/01 08:27:48]

This approach looks a little bit strange to me. The PrefService has its own
mechanism to declare a preference that can be overridden by a command line flag.
Can't you use that?

See for example command_line_pref_store.cc -> ApplyBackgroundModeSwitches. You
could check the command line flag and set the prefs::kNetworkPredictionOptions
and prefs::kNetworkPredictionEnabled preferences.

base/prefs/pref_value_store.h has documentation on the precedence of various
pref stores. If you implement this as suggested, policies and extensions could
still override the setting.

     if (preconnectable && !is_new_host_request) {
       ++consecutive_omnibox_preconnect_count_;
       // The omnibox suggests a search URL (for which we can preconnect) after
       // one or two characters are typed, even though such typing often (1 in
       // 3?) becomes a real URL.  This code waits till is has more evidence of a
       // preconnectable URL (search URL) before forming a preconnection, so as
       // to reduce the useless preconnect rate.
       // Perchance this logic should be pushed back into the omnibox, where the
       // actual characters typed, such as a space, can better forcast whether
       // we need to search/preconnect or not.  By waiting for at least 4
@@ skipping 42 matching lines @@
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&Predictor::Resolve, base::Unretained(this),
                  CanonicalizeUrl(url), motivation));
 }
 
 void Predictor::PreconnectUrlAndSubresources(const GURL& url,
     const GURL& first_party_for_cookies) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
-  if (!predictor_enabled_ || !preconnect_enabled() ||
+  if (!predictor_enabled_ || !preconnect_enabled_ ||
+      !chrome_browser_net::CanPredictNetworkActionsUI(user_prefs_) ||
       !url.is_valid() || !url.has_host())
     return;
 
   UrlInfo::ResolutionMotivation motivation(UrlInfo::EARLY_LOAD_MOTIVATED);
   const int kConnectionsNeeded = 1;
   PreconnectUrl(CanonicalizeUrl(url), first_party_for_cookies,
                 motivation, kConnectionsNeeded);
   PredictFrameSubresources(url.GetWithEmptyPath(), first_party_for_cookies);
 }
 
@@ skipping 161 matching lines @@
 // This section supports the about:dns page.
 
 void Predictor::PredictorGetHtmlInfo(Predictor* predictor,
                                      std::string* output) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   output->append("<html><head><title>About DNS</title>"
                  // We'd like the following no-cache... but it doesn't work.
                  // "<META HTTP-EQUIV=\"Pragma\" CONTENT=\"no-cache\">"
                  "</head><body>");
-  if (predictor && predictor->predictor_enabled()) {
+  if (predictor && predictor->predictor_enabled() &&
+      chrome_browser_net::CanPredictNetworkActionsIO(
+          predictor->profile_io_data())) {
     predictor->GetHtmlInfo(output);
   } else {
     output->append("DNS pre-resolution and TCP pre-connection is disabled.");
   }
   output->append("</body></html>");
 }
 
 // Provide sort order so all .com's are together, etc.
 struct RightToLeftStringSorter {
   bool operator()(const GURL& left, const GURL& right) const {
@@ skipping 176 matching lines @@
 void Predictor::DiscardInitialNavigationHistory() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (initial_observer_.get())
     initial_observer_->DiscardInitialNavigationHistory();
 }
 
 void Predictor::FinalizeInitializationOnIOThread(
     const UrlList& startup_urls,
     base::ListValue* referral_list,
     IOThread* io_thread,
-    bool predictor_enabled) {
+    ProfileIOData* profile_io_data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  predictor_enabled_ = predictor_enabled;
+  profile_io_data_ = profile_io_data;
   initial_observer_.reset(new InitialObserver());
   host_resolver_ = io_thread->globals()->host_resolver.get();
 
   net::URLRequestContext* context =
       url_request_context_getter_->GetURLRequestContext();
   transport_security_state_ = context->transport_security_state();
   ssl_config_service_ = context->ssl_config_service();
 
   // base::WeakPtrFactory instances need to be created and destroyed
   // on the same thread. The predictor lives on the IO thread and will die
@@ skipping 70 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (NULL == predictor) {
     completion->Signal();
     return;
   }
   predictor->SaveDnsPrefetchStateForNextStartupAndTrim(
       startup_list, referral_list, completion);
 }
 
-void Predictor::SaveStateForNextStartupAndTrim(PrefService* prefs) {
+void Predictor::SaveStateForNextStartupAndTrim() {
   if (!predictor_enabled_)
     return;
 
   base::WaitableEvent completion(true, false);
 
-  ListPrefUpdate update_startup_list(prefs, prefs::kDnsPrefetchingStartupList);
-  ListPrefUpdate update_referral_list(prefs,
+  ListPrefUpdate update_startup_list(user_prefs_,
+                                     prefs::kDnsPrefetchingStartupList);
+  ListPrefUpdate update_referral_list(user_prefs_,
                                       prefs::kDnsPrefetchingHostReferralList);
   if (BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     SaveDnsPrefetchStateForNextStartupAndTrimOnIOThread(
         update_startup_list.Get(),
         update_referral_list.Get(),
         &completion,
         this);
   } else {
     bool posted = BrowserThread::PostTask(
         BrowserThread::IO,
@@ skipping 25 matching lines @@
     initial_observer_->GetInitialDnsResolutionList(startup_list);
 
   // Do at least one trim at shutdown, in case the user wasn't running long
   // enough to do any regular trimming of referrers.
   TrimReferrersNow();
   SerializeReferrers(referral_list);
 
   completion->Signal();
 }
 
-void Predictor::EnablePredictor(bool enable) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
-         BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  if (BrowserThread::CurrentlyOn(BrowserThread::IO)) {
-    EnablePredictorOnIOThread(enable);
-  } else {
-    BrowserThread::PostTask(
-        BrowserThread::IO,
-        FROM_HERE,
-        base::Bind(&Predictor::EnablePredictorOnIOThread,
-                   base::Unretained(this), enable));
-  }
-}
-
-void Predictor::EnablePredictorOnIOThread(bool enable) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  predictor_enabled_ = enable;
-}
-
 void Predictor::PreconnectUrl(const GURL& url,
                               const GURL& first_party_for_cookies,
                               UrlInfo::ResolutionMotivation motivation,
                               int count) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     PreconnectUrlOnIOThread(url, first_party_for_cookies, motivation, count);
   } else {
@@ skipping 84 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK_EQ(url.GetWithEmptyPath(), url);
   Referrers::iterator it = referrers_.find(url);
   if (referrers_.end() == it) {
     // Only when we don't know anything about this url, make 2 connections
     // available.  We could do this completely via learning (by prepopulating
     // the referrer_ list with this expected value), but it would swell the
     // size of the list with all the "Leaf" nodes in the tree (nodes that don't
     // load any subresources).  If we learn about this resource, we will instead
     // provide a more carefully estimated preconnection count.
-    if (preconnect_enabled_) {
+    if (preconnect_enabled_ &&
+        chrome_browser_net::CanPredictNetworkActionsIO(profile_io_data_)) {
       PreconnectUrlOnIOThread(url, first_party_for_cookies,
                               UrlInfo::SELF_REFERAL_MOTIVATED, 2);
     }
     return;
   }
 
   Referrer* referrer = &(it->second);
   referrer->IncrementUseCount();
   const UrlInfo::ResolutionMotivation motivation =
       UrlInfo::LEARNED_REFERAL_MOTIVATED;
   for (Referrer::iterator future_url = referrer->begin();
        future_url != referrer->end(); ++future_url) {
     SubresourceValue evalution(TOO_NEW);
     double connection_expectation = future_url->second.subresource_use_rate();
     UMA_HISTOGRAM_CUSTOM_COUNTS("Net.PreconnectSubresourceExpectation",
                                 static_cast<int>(connection_expectation * 100),
                                 10, 5000, 50);
     future_url->second.ReferrerWasObserved();
     if (preconnect_enabled_ &&
+        chrome_browser_net::CanPredictNetworkActionsIO(profile_io_data_) &&
         connection_expectation > kPreconnectWorthyExpectedValue) {
       evalution = PRECONNECTION;
       future_url->second.IncrementPreconnectionCount();
       int count = static_cast<int>(std::ceil(connection_expectation));
       if (url.host() == future_url->first.host())
         ++count;
       PreconnectUrlOnIOThread(future_url->first, first_party_for_cookies,
                               motivation, count);
     } else if (connection_expectation > kDNSPreresolutionWorthyExpectedValue) {
       evalution = PRERESOLUTION;
@@ skipping 317 matching lines @@
   if (url.has_port())
     colon_plus_port = ":" + url.port();
 
   return GURL(scheme + "://" + url.host() + colon_plus_port);
 }
 
 void SimplePredictor::InitNetworkPredictor(
     PrefService* user_prefs,
     PrefService* local_state,
     IOThread* io_thread,
-    net::URLRequestContextGetter* getter) {
+    net::URLRequestContextGetter* getter,
+    ProfileIOData* profile_io_data) {
   // Empty function for unittests.
 }
 
 void SimplePredictor::ShutdownOnUIThread() {
   SetShutdown(true);
 }
 
 }  // namespace chrome_browser_net