android: Disable the startup DNS resolutions.

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 <iterator>
 #include <set>
 #include <sstream>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/containers/mru_cache.h"
 #include "base/feature_list.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
+#include "base/trace_event/trace_event.h"
 #include "base/values.h"
+#include "build/build_config.h"
 #include "chrome/browser/io_thread.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/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/resource_hints.h"
@@ skipping 12 matching lines @@
 using base::TimeDelta;
 using content::BrowserThread;
 
 namespace chrome_browser_net {
 
 namespace {
 
 const base::Feature kNetworkPrediction{"NetworkPrediction",
                                        base::FEATURE_ENABLED_BY_DEFAULT};
 
+#if defined(OS_ANDROID)
+// Disabled on Android, as there are no "pinned tabs", meaning that a startup
+// is unlikely to request the same URL, and hence to resolve the same domains
+// as the previous one.
+constexpr bool kInitialDnsPrefetchListEnabled = false;
+#else
+constexpr bool kInitialDnsPrefetchListEnabled = true;
+#endif  // defined(OS_ANDROID)
+
 }  // namespace
 
+// The InitialObserver monitors navigations made by the network stack. This
+// is only used to identify startup time resolutions (for re-resolution
+// during our next process startup).
+// TODO(jar): Consider preconnecting at startup, which may be faster than
+// waiting for render process to start and request a connection.
+class InitialObserver {
+ public:
+  InitialObserver();
+  ~InitialObserver();
+  // Recording of when we observed each navigation.
+  typedef std::map<GURL, base::TimeTicks> FirstNavigations;
+
+  // Potentially add a new URL to our startup list.
+  void Append(const GURL& url, Predictor* predictor);
+
+  // Get an HTML version of our current planned first_navigations_.
+  void GetFirstResolutionsHtml(std::string* output);
+
+  // Persist the current first_navigations_ for storage in a list.
+  void GetInitialDnsResolutionList(base::ListValue* startup_list);
+
+  // Discards all initial loading history.
+  void DiscardInitialNavigationHistory() { first_navigations_.clear(); }
+
+ private:
+  // List of the first N URL resolutions observed in this run.
+  FirstNavigations first_navigations_;
+
+  // The number of URLs we'll save for pre-resolving at next startup.
+  static const size_t kStartupResolutionCount = 10;
+};
+
 // static
 const int Predictor::kPredictorReferrerVersion = 2;
 const double Predictor::kPreconnectWorthyExpectedValue = 0.8;
 const double Predictor::kDNSPreresolutionWorthyExpectedValue = 0.1;
 const double Predictor::kDiscardableExpectedValue = 0.05;
 const size_t Predictor::kMaxSpeculativeParallelResolves = 3;
 const int Predictor::kMaxUnusedSocketLifetimeSecondsWithoutAGet = 10;
 
 // This number was obtained by the Net.Predictor.MRUIndex histogram on Canary
 // and Dev channel (M53). The database size was initialized to 1000, and the
@@ skipping 424 matching lines @@
           static_cast<int>(future_url->second.preresolution_count()),
           static_cast<double>(future_url->second.subresource_use_rate()),
           future_url->first.spec().c_str());
     }
   }
   output->append("</table>");
 }
 
 void Predictor::GetHtmlInfo(std::string* output) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (initial_observer_.get())
+  if (kInitialDnsPrefetchListEnabled && initial_observer_)
     initial_observer_->GetFirstResolutionsHtml(output);
   // Show list of subresource predictions and stats.
   GetHtmlReferrerLists(output);
 
   // Local lists for calling UrlInfo
   UrlInfo::UrlInfoTable name_not_found;
   UrlInfo::UrlInfoTable name_preresolved;
 
   // UrlInfo supports value semantics, so we can do a shallow copy.
   for (Results::iterator it(results_.begin()); it != results_.end(); it++) {
@@ skipping 60 matching lines @@
       }
 
       referrers_.Put(GURL(motivating_url_spec), Referrer())
           ->second.Deserialize(*subresource_list);
     }
   }
 }
 
 void Predictor::DiscardInitialNavigationHistory() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (initial_observer_.get())
+  if (kInitialDnsPrefetchListEnabled && initial_observer_)
     initial_observer_->DiscardInitialNavigationHistory();
 }
 
 void Predictor::FinalizeInitializationOnIOThread(
     const std::vector<GURL>& startup_urls,
     std::unique_ptr<base::ListValue> referral_list,
     IOThread* io_thread,
     ProfileIOData* profile_io_data) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  TRACE_EVENT0("net", "Predictor::FinalizeInitializationOnIOThread");
 
   profile_io_data_ = profile_io_data;
-  initial_observer_.reset(new InitialObserver());
+  if (kInitialDnsPrefetchListEnabled)
+    initial_observer_ = base::MakeUnique<InitialObserver>();
 
   net::URLRequestContext* context =
       url_request_context_getter_->GetURLRequestContext();
   transport_security_state_ = context->transport_security_state();
   ssl_config_service_ = context->ssl_config_service();
   proxy_service_ = context->proxy_service();
 
   // base::WeakPtrFactory instances need to be created and destroyed
   // on the same thread. Initialize the IO thread weak factory now.
   io_weak_factory_.reset(new base::WeakPtrFactory<Predictor>(this));
 
   // Prefetch these hostnames on startup.
-  DnsPrefetchMotivatedList(startup_urls, UrlInfo::STARTUP_LIST_MOTIVATED);
+  if (kInitialDnsPrefetchListEnabled)
+    DnsPrefetchMotivatedList(startup_urls, UrlInfo::STARTUP_LIST_MOTIVATED);
 
   DeserializeReferrers(*referral_list);
 
   LogStartupMetrics();
 }
 
 //-----------------------------------------------------------------------------
 // This section intermingles prefetch results with actual browser HTTP
 // network activity.  It supports calculating of the benefit of a prefetch, as
 // well as recording what prefetched hostname resolutions might be potentially
 // helpful during the next chrome-startup.
 //-----------------------------------------------------------------------------
 
 void Predictor::LearnAboutInitialNavigation(const GURL& url) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (!PredictorEnabled() || nullptr == initial_observer_.get() ||
-      !CanPreresolveAndPreconnect()) {
+  if (!PredictorEnabled() || !kInitialDnsPrefetchListEnabled ||
+      !initial_observer_ || !CanPreresolveAndPreconnect()) {
     return;
   }
   initial_observer_->Append(url, this);
 }
 
 // This API is only used in the browser process.
 // It is called from an IPC message originating in the renderer.  It currently
 // includes both Page-Scan, and Link-Hover prefetching.
 // TODO(jar): Separate out link-hover prefetching, and page-scan results.
 void Predictor::DnsPrefetchList(const std::vector<std::string>& hostnames) {
@@ skipping 33 matching lines @@
 // Functions to handle saving of hostnames from one session to the next, to
 // expedite startup times.
 
 void Predictor::SaveStateForNextStartup() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!PredictorEnabled())
     return;
   if (!CanPreresolveAndPreconnect())
     return;
 
-  std::unique_ptr<base::ListValue> startup_list(new base::ListValue);
-  std::unique_ptr<base::ListValue> referral_list(new base::ListValue);
+  auto startup_list = base::MakeUnique<base::ListValue>();
+  auto referral_list = base::MakeUnique<base::ListValue>();
 
   // Get raw pointers to pass to the first task. Ownership of the unique_ptrs
   // will be passed to the reply task.
   base::ListValue* startup_list_raw = startup_list.get();
   base::ListValue* referral_list_raw = referral_list.get();
 
   // The first post task here is guaranteed to execute before the post task in
   // ShutdownOnUIThread, because the caller has a valid profile.
   BrowserThread::PostTaskAndReply(
       BrowserThread::IO, FROM_HERE,
       base::BindOnce(&Predictor::WriteDnsPrefetchState, base::Unretained(this),
                      startup_list_raw, referral_list_raw),
       base::BindOnce(&Predictor::UpdatePrefsOnUIThread,
                      ui_weak_factory_->GetWeakPtr(),
                      base::Passed(std::move(startup_list)),
                      base::Passed(std::move(referral_list))));
 }
 
 void Predictor::UpdatePrefsOnUIThread(
     std::unique_ptr<base::ListValue> startup_list,
     std::unique_ptr<base::ListValue> referral_list) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   user_prefs_->Set(prefs::kDnsPrefetchingStartupList, *startup_list);
+  // May be empty if kInitialDnsPrefetchListEnabled is false. Still update the

[jkarlin, 2017/06/26 16:47:56]

New line above this

[Benoit L, 2017/06/27 08:37:56]

Done.

+  // prefs to clear the state.
   user_prefs_->Set(prefs::kDnsPrefetchingHostReferralList, *referral_list);
 }
 
 void Predictor::WriteDnsPrefetchState(base::ListValue* startup_list,
                                       base::ListValue* referral_list) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (initial_observer_.get())
+  if (kInitialDnsPrefetchListEnabled && initial_observer_)
     initial_observer_->GetInitialDnsResolutionList(startup_list);
 
   SerializeReferrers(referral_list);
 }
 
 void Predictor::PreconnectUrl(const GURL& url,
                               const GURL& first_party_for_cookies,
                               UrlInfo::ResolutionMotivation motivation,
                               bool allow_credentials,
                               int count) {
@@ skipping 372 matching lines @@
   std::queue<GURL> *queue(rush_queue_.empty() ? &background_queue_
                                               : &rush_queue_);
   GURL url(queue->front());
   queue->pop();
   return url;
 }
 
 //-----------------------------------------------------------------------------
 // Member definitions for InitialObserver class.
 
-Predictor::InitialObserver::InitialObserver() {
-}
+InitialObserver::InitialObserver() = default;
 
-Predictor::InitialObserver::~InitialObserver() {
-}
+InitialObserver::~InitialObserver() = default;
 
-void Predictor::InitialObserver::Append(const GURL& url,
-                                        Predictor* predictor) {
+void InitialObserver::Append(const GURL& url, Predictor* predictor) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (kStartupResolutionCount <= first_navigations_.size())
     return;
 
   DCHECK(url.SchemeIsHTTPOrHTTPS());
   DCHECK_EQ(url, Predictor::CanonicalizeUrl(url));
   if (first_navigations_.find(url) == first_navigations_.end())
     first_navigations_[url] = base::TimeTicks::Now();
 }
 
-void Predictor::InitialObserver::GetInitialDnsResolutionList(
+void InitialObserver::GetInitialDnsResolutionList(
     base::ListValue* startup_list) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(startup_list);
   DCHECK(startup_list->empty());
   DCHECK_EQ(0u, startup_list->GetSize());
   startup_list->AppendInteger(kPredictorStartupFormatVersion);
-  for (FirstNavigations::iterator it = first_navigations_.begin();
-       it != first_navigations_.end();
-       ++it) {
-    DCHECK(it->first == Predictor::CanonicalizeUrl(it->first));
-    startup_list->AppendString(it->first.spec());
+  for (const auto& url_time : first_navigations_) {
+    DCHECK(url_time.first == Predictor::CanonicalizeUrl(url_time.first));
+    startup_list->AppendString(url_time.first.spec());
   }
 }
 
-void Predictor::InitialObserver::GetFirstResolutionsHtml(
-    std::string* output) {
+void InitialObserver::GetFirstResolutionsHtml(std::string* output) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   UrlInfo::UrlInfoTable resolution_list;
-  {
-    for (FirstNavigations::iterator it(first_navigations_.begin());
-         it != first_navigations_.end();
-         it++) {
-      UrlInfo info;
-      info.SetUrl(it->first);
-      info.set_time(it->second);
-      resolution_list.push_back(info);
-    }
+  for (const auto& url_time : first_navigations_) {
+    UrlInfo info;
+    info.SetUrl(url_time.first);
+    info.set_time(url_time.second);
+    resolution_list.push_back(info);
   }
   UrlInfo::GetHtmlTable(resolution_list,
-      "Future startups will prefetch DNS records for ", false, output);
+                        "Future startups will prefetch DNS records for ", false,
+                        output);
 }
 
 //-----------------------------------------------------------------------------
 // Helper functions
 //-----------------------------------------------------------------------------
 
 // static
 GURL Predictor::CanonicalizeUrl(const GURL& url) {
   if (!url.has_host())
      return GURL::EmptyGURL();
@@ skipping 26 matching lines @@
 }
 
 void SimplePredictor::ShutdownOnUIThread() {
   SetShutdown(true);
 }
 
 bool SimplePredictor::CanPrefetchAndPrerender() const { return true; }
 bool SimplePredictor::CanPreresolveAndPreconnect() const { return true; }
 
 }  // namespace chrome_browser_net