Add a browsertest suite for net predictor

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 20 matching lines @@
 
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/net/prediction_options.h"
 #include "chrome/browser/net/referrer.h"
 #include "chrome/browser/net/timed_cache.h"
 #include "chrome/browser/net/url_info.h"
 #include "components/network_hints/common/network_hints_common.h"
 #include "net/base/host_port_pair.h"
+#include "url/gurl.h"
 
 class IOThread;
 class PrefService;
 class Profile;
 class ProfileIOData;
 
 namespace base {
 class ListValue;
 class WaitableEvent;
 }
@@ skipping 17 matching lines @@
 typedef std::map<GURL, UrlInfo> Results;
 
 // An observer for testing.
 class PredictorObserver {
  public:
   virtual ~PredictorObserver() {}
 
   virtual void OnPreconnectUrl(const GURL& original_url,
                                const GURL& first_party_for_cookies,
                                UrlInfo::ResolutionMotivation motivation,
-                               int count) = 0;
+                               int count) {}
+  virtual void OnLearnFromNavigation(const GURL& referring_url,
+                                     const GURL& target_url) {}
 };
 
 // Predictor is constructed during Profile construction (on the UI thread),
 // but it is destroyed on the IO thread when ProfileIOData goes away. All of
 // its core state and functionality happens on the IO thread. The only UI
 // methods are initialization / shutdown related (including preconnect
 // initialization), or convenience methods that internally forward calls to
 // the IO thread.
 class Predictor {
  public:
@@ skipping 203 matching lines @@
   }
   // Used for testing.
   void SetObserver(PredictorObserver* observer) {
     observer_ = observer;
   }
 
   ProfileIOData* profile_io_data() const {
     return profile_io_data_;
   }
 
   bool preconnect_enabled() const {

[mmenke, 2016/05/12 16:30:23]

Naming scheme should be changed, and method de-inlined since we're grabbing a
lock.

[mmenke, 2016/05/12 16:30:23]

optional:  Could use an atomic instead of a lock here.  Doesn't really matter, I
suppose.  (Naming scheme should still change, even if we switch)

[Charlie Harrison, 2016/05/12 20:17:03]

Done.

[Charlie Harrison, 2016/05/12 20:17:03]

Kept the lock for simplicity.

+    base::AutoLock lock(lock_);
     return preconnect_enabled_;
   }
 
   bool predictor_enabled() const {
     return predictor_enabled_;
   }
 
+  // Used only for testing. Overrides command line flag to disable preconnect,
+  // which is added in the browser test fixture.
+  void set_preconnect_enabled_for_test(bool preconnect_enabled) {

[mmenke, 2016/05/12 16:30:22]

Again, naming scheme should be changed, and should be de-inlined.

[Charlie Harrison, 2016/05/12 20:17:03]

Done.

+    base::AutoLock lock(lock_);
+    preconnect_enabled_ = preconnect_enabled;
+  }
+
+  net::URLRequestContextGetter* url_request_context_getter_for_test() {
+    return url_request_context_getter_.get();
+  }
 
  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);
   FRIEND_TEST_ALL_PREFIXES(PredictorTest, MassiveConcurrentLookupTest);
   FRIEND_TEST_ALL_PREFIXES(PredictorTest, PriorityQueuePushPopTest);
   FRIEND_TEST_ALL_PREFIXES(PredictorTest, PriorityQueueReorderTest);
   FRIEND_TEST_ALL_PREFIXES(PredictorTest, ReferrerSerializationTrimTest);
@@ skipping 237 matching lines @@
   // The SSLConfigService we query SNI support from (used in querying HSTS
   // redirects).
   net::SSLConfigService* ssl_config_service_;
 
   // The ProxyService, used to determine whether preresolve is useful.
   net::ProxyService* proxy_service_;
 
   // Are we currently using preconnection, rather than just DNS resolution, for
   // subresources and omni-box search URLs.
   // This is false if and only if disabled by a command line switch.
-  const bool preconnect_enabled_;
+  bool preconnect_enabled_;

[mmenke, 2016/05/12 16:30:23]

Should mention it's protected by the lock.  Or make it atomic, per above
suggestions.

[Charlie Harrison, 2016/05/12 20:17:03]

Done.

 
   // 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 12 matching lines @@
   std::vector<GURL> urls_being_trimmed_;
 
   // A time after which we need to do more trimming of referrers.
   base::TimeTicks next_trim_time_;
 
   // An observer for testing.
   PredictorObserver* observer_;
 
   std::unique_ptr<base::WeakPtrFactory<Predictor>> weak_factory_;
 
+  mutable base::Lock lock_;

[mmenke, 2016/05/12 16:30:23]

Should mention what this protects, and could even call it
preconnect_enabled_lock_.

[Charlie Harrison, 2016/05/12 20:17:03]

Done.

+
   DISALLOW_COPY_AND_ASSIGN(Predictor);
 };
 
 // This version of the predictor is used for testing.
 class SimplePredictor : public Predictor {
  public:
   explicit SimplePredictor(bool preconnect_enabled, bool predictor_enabled)
       : Predictor(preconnect_enabled, predictor_enabled) {}
   ~SimplePredictor() override {}
   void InitNetworkPredictor(PrefService* user_prefs,
                             IOThread* io_thread,
                             net::URLRequestContextGetter* getter,
                             ProfileIOData* profile_io_data) override;
   void ShutdownOnUIThread() override;
 
  private:
   // These member functions return True for unittests.
   bool CanPrefetchAndPrerender() const override;
   bool CanPreresolveAndPreconnect() const override;
 };
 
 }  // namespace chrome_browser_net
 
 #endif  // CHROME_BROWSER_NET_PREDICTOR_H_