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"

[Charlie Harrison, 2017/06/20 13:24:29]

Is it used?

[Benoit L, 2017/06/20 13:30:17]

Yes, there is a TRACE_EVENT0() added below.

[Charlie Harrison, 2017/06/20 13:32:22]

Ahh sorry. It's early :)

 #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
 
 // 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;
 
@@ skipping 426 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 (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 (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
+  // 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 (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 469 matching lines @@
 }
 
 void SimplePredictor::ShutdownOnUIThread() {
   SetShutdown(true);
 }
 
 bool SimplePredictor::CanPrefetchAndPrerender() const { return true; }
 bool SimplePredictor::CanPreresolveAndPreconnect() const { return true; }
 
 }  // namespace chrome_browser_net