Poll CanPredictNetworkActions in Predictor class.

chrome/browser/net/predictor.h

 // 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.
 
 // A Predictor object is instantiated once in the browser process, and manages
 // both preresolution of hostnames, as well as TCP/IP preconnection to expected
 // subresources.
 // Most hostname lists are provided by the renderer processes, and include URLs
 // that *might* be used in the near future by the browsing user.  One goal of
 // this class is to cause the underlying DNS structure to lookup a hostname
@@ skipping 10 matching lines @@
 
 #include <map>
 #include <queue>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
+#include "chrome/browser/net/prediction_options.h"
 #include "chrome/browser/net/referrer.h"
 #include "chrome/browser/net/spdyproxy/proxy_advisor.h"
 #include "chrome/browser/net/timed_cache.h"
 #include "chrome/browser/net/url_info.h"
 #include "chrome/common/net/predictor_common.h"
 #include "net/base/host_port_pair.h"
 
 class IOThread;
 class PrefService;
 class Profile;
+class ProfileIOData;
 
 namespace base {
 class ListValue;
 class WaitableEvent;
 }
 
 namespace net {
 class HostResolver;
 class SSLConfigService;
 class TransportSecurityState;
@@ skipping 57 matching lines @@
 
   // We don't bother learning to preconnect via a GET if the original URL
   // navigation was so long ago, that a preconnection would have been dropped
   // anyway.  We believe most servers will drop the connection in 10 seconds, so
   // we currently estimate this time-till-drop at 10 seconds.
   // TODO(jar): We should do a persistent field trial to validate/optimize this.
   static const int kMaxUnusedSocketLifetimeSecondsWithoutAGet;
 
   // |max_concurrent| specifies how many concurrent (parallel) prefetches will
   // be performed. Host lookups will be issued through |host_resolver|.
-  explicit Predictor(bool preconnect_enabled);
+  explicit Predictor(bool preconnect_enabled, bool predictor_enabled);
 
   virtual ~Predictor();
 
   // This function is used to create a predictor. For testing, we can create
   // a version which does a simpler shutdown.
   static Predictor* CreatePredictor(bool preconnect_enabled,
+                                    bool predictor_enabled,
                                     bool simple_shutdown);
 
   static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
 
   // ------------- Start UI thread methods.
 
   virtual void InitNetworkPredictor(PrefService* user_prefs,
                                     PrefService* local_state,
                                     IOThread* io_thread,
-                                    net::URLRequestContextGetter* getter);
+                                    net::URLRequestContextGetter* getter,
+                                    ProfileIOData* profile_io_data);
 
   // The Omnibox has proposed a given url to the user, and if it is a search
   // URL, then it also indicates that this is preconnectable (i.e., we could
   // preconnect to the search server).
   void AnticipateOmniboxUrl(const GURL& url, bool preconnectable);
 
   // Preconnect a URL and all of its subresource domains.
   void PreconnectUrlAndSubresources(const GURL& url,
                                     const GURL& first_party_for_cookies);
 
@@ skipping 60 matching lines @@
   void DeserializeReferrers(const base::ListValue& referral_list);
 
   void DeserializeReferrersThenDelete(base::ListValue* referral_list);
 
   void DiscardInitialNavigationHistory();
 
   void FinalizeInitializationOnIOThread(
       const std::vector<GURL>& urls_to_prefetch,
       base::ListValue* referral_list,
       IOThread* io_thread,
-      bool predictor_enabled);
+      ProfileIOData* profile_io_data);
 
   // During startup, we learn what the first N urls visited are, and then
   // resolve the associated hosts ASAP during our next startup.
   void LearnAboutInitialNavigation(const GURL& url);
 
   // Renderer bundles up list and sends to this browser API via IPC.
   // TODO(jar): Use UrlList instead to include port and scheme.
   void DnsPrefetchList(const NameList& hostnames);
 
   // May be called from either the IO or UI thread and will PostTask
   // to the IO thread if necessary.
   void DnsPrefetchMotivatedList(const UrlList& urls,
                                 UrlInfo::ResolutionMotivation motivation);
 
   // May be called from either the IO or UI thread and will PostTask
   // to the IO thread if necessary.
-  void SaveStateForNextStartupAndTrim(PrefService* prefs);
+  void SaveStateForNextStartupAndTrim();
 
   void SaveDnsPrefetchStateForNextStartupAndTrim(
       base::ListValue* startup_list,
       base::ListValue* referral_list,
       base::WaitableEvent* completion);
 
   // May be called from either the IO or UI thread and will PostTask
   // to the IO thread if necessary.
-  void EnablePredictor(bool enable);
-
-  void EnablePredictorOnIOThread(bool enable);
-
-  // May be called from either the IO or UI thread and will PostTask
-  // to the IO thread if necessary.
   void PreconnectUrl(const GURL& url, const GURL& first_party_for_cookies,
                      UrlInfo::ResolutionMotivation motivation, int count);
 
   void PreconnectUrlOnIOThread(const GURL& url,
                                const GURL& first_party_for_cookies,
                                UrlInfo::ResolutionMotivation motivation,
                                int count);
 
   // ------------- End IO thread methods.
 
@@ skipping 31 matching lines @@
   }
   // Used for testing.
   void SetShutdown(bool shutdown) {
     shutdown_ = shutdown;
   }
   // Used for testing.
   void SetObserver(PredictorObserver* observer) {
     observer_ = observer;
   }
 
-  // Flag setting to use preconnection instead of just DNS pre-fetching.
+  ProfileIOData* profile_io_data() const {
+    return profile_io_data_;
+  }
+
   bool preconnect_enabled() const {
     return preconnect_enabled_;
   }
 
-  // Flag setting for whether we are prefetching dns lookups.
   bool predictor_enabled() const {
     return predictor_enabled_;
   }
 
 
  private:
   FRIEND_TEST_ALL_PREFIXES(PredictorTest, BenefitLookupTest);
   FRIEND_TEST_ALL_PREFIXES(PredictorTest, ShutdownWhenResolutionIsPendingTest);
   FRIEND_TEST_ALL_PREFIXES(PredictorTest, SingleLookupTest);
   FRIEND_TEST_ALL_PREFIXES(PredictorTest, ConcurrentLookupTest);
@@ skipping 114 matching lines @@
   // Only for testing;
   size_t peak_pending_lookups() const { return peak_pending_lookups_; }
 
   // If a proxy advisor is defined, let it know that |url| will be prefetched or
   // preconnected to. Can be called on either UI or IO threads and will post to
   // the IO thread if necessary, invoking AdviseProxyOnIOThread().
   void AdviseProxy(const GURL& url,
                    UrlInfo::ResolutionMotivation motivation,
                    bool is_preconnect);
 
+  // There two members call the corresponding global functions in
+  // prediction_options.cc.
+  virtual bool CanPredictNetworkActionsUI();
+  virtual bool CanPredictNetworkActionsIO();
+
   // ------------- Start IO thread methods.
 
   // Perform actual resolution or preconnection to subresources now.  This is
   // an internal worker method that is reached via a post task from
   // PredictFrameSubresources().
   void PrepareFrameSubresources(const GURL& url,
                                 const GURL& first_party_for_cookies);
 
   // Access method for use by async lookup request to pass resolution result.
   void OnLookupFinished(LookupRequest* request, const GURL& url, bool found);
@@ skipping 53 matching lines @@
 
   // ------------- End IO thread methods.
 
   scoped_ptr<InitialObserver> initial_observer_;
 
   // Reference to URLRequestContextGetter from the Profile which owns the
   // predictor. Used by Preconnect.
   scoped_refptr<net::URLRequestContextGetter> url_request_context_getter_;
 
   // Status of speculative DNS resolution and speculative TCP/IP connection
-  // feature.
-  bool predictor_enabled_;
+  // feature. This is false if and only if disabled by a command line switch.
+  const bool predictor_enabled_;
+
+  // This is set by InitNetworkPredictor and used for calling
+  // chrome_browser_net::CanPredictNetworkActionsUI.
+  PrefService* user_prefs_;
+
+  // This is set by InitNetworkPredictor and used for calling
+  // chrome_browser_net::CanPredictNetworkActionsIO.
+  ProfileIOData* profile_io_data_;
 
   // work_queue_ holds a list of names we need to look up.
   HostNameQueue work_queue_;
 
   // results_ contains information for existing/prior prefetches.
   Results results_;
 
   std::set<LookupRequest*> pending_lookups_;
 
   // For testing, to verify that we don't exceed the limit.
@@ skipping 17 matching lines @@
 
   // The TransportSecurityState instance we query HSTS redirects from.
   net::TransportSecurityState* transport_security_state_;
 
   // The SSLConfigService we query SNI support from (used in querying HSTS
   // redirects).
   net::SSLConfigService* ssl_config_service_;
 
   // Are we currently using preconnection, rather than just DNS resolution, for
   // subresources and omni-box search URLs.
-  bool preconnect_enabled_;
+  // This is false if and only if disabled by a command line switch.
+  const bool preconnect_enabled_;
 
   // Most recent suggestion from Omnibox provided via AnticipateOmniboxUrl().
   std::string last_omnibox_host_;
 
   // The time when the last preresolve was done for last_omnibox_host_.
   base::TimeTicks last_omnibox_preresolve_;
 
   // The number of consecutive requests to AnticipateOmniboxUrl() that suggested
   // preconnecting (because it was to a search service).
   int consecutive_omnibox_preconnect_count_;
@@ skipping 20 matching lines @@
 
   // An observer for testing.
   PredictorObserver* observer_;
 
   DISALLOW_COPY_AND_ASSIGN(Predictor);
 };
 
 // This version of the predictor is used for testing.
 class SimplePredictor : public Predictor {
  public:
-  explicit SimplePredictor(bool preconnect_enabled)
-      : Predictor(preconnect_enabled) {}
+  explicit SimplePredictor(bool preconnect_enabled, bool predictor_enabled)
+      : Predictor(preconnect_enabled, predictor_enabled) {}
   virtual ~SimplePredictor() {}
   virtual void InitNetworkPredictor(
       PrefService* user_prefs,
       PrefService* local_state,
       IOThread* io_thread,
-      net::URLRequestContextGetter* getter) OVERRIDE;
+      net::URLRequestContextGetter* getter,
+      ProfileIOData* profile_io_data) OVERRIDE;
   virtual void ShutdownOnUIThread() OVERRIDE;
+ private:
+  // There member functions return True for unittests.
+  virtual bool CanPredictNetworkActionsUI() OVERRIDE;
+  virtual bool CanPredictNetworkActionsIO() OVERRIDE;
 };
 
 }  // namespace chrome_browser_net
 
 #endif  // CHROME_BROWSER_NET_PREDICTOR_H_