Don't clear the net predictors prefs on startup

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>
@@ skipping 128 matching lines @@
                                      net::URLRequestContextGetter* getter,
                                      ProfileIOData* profile_io_data) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   user_prefs_ = user_prefs;
   url_request_context_getter_ = getter;
 
   // Gather the list of hostnames to prefetch on startup.
   std::vector<GURL> urls = GetPredictedUrlListAtStartup(user_prefs);
 
-  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
-  // file. They will be serialized back on a clean shutdown. This way we only
-  // have to worry about clearing our in-memory state when Clearing Browsing

[eroman, 2016/06/25 01:12:53]

(Not familiar with this previous code, but the previous design seems a bit odd
if this was the only motivation)

[Charlie Harrison, 2016/06/27 18:57:12]

Yeah this was my impression as well. It makes some sense considering some of the
complications here (i.e. having to jump to the UI thread to ensure deletion).
But still, I think this is saner.

-  // Data.
-  user_prefs->ClearPref(prefs::kDnsPrefetchingStartupList);
-  user_prefs->ClearPref(prefs::kDnsPrefetchingHostReferralList);
+  const base::ListValue* referral_list =
+      user_prefs->GetList(prefs::kDnsPrefetchingHostReferralList);
 
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(
           &Predictor::FinalizeInitializationOnIOThread,
           base::Unretained(this),
           urls, referral_list,
           io_thread, profile_io_data));
 }
@@ skipping 398 matching lines @@
         NOTREACHED();
         return;
       }
 
       referrers_.Put(GURL(motivating_url_spec), Referrer())
           ->second.Deserialize(*subresource_list);
     }
   }
 }
 
-void Predictor::DeserializeReferrersThenDelete(
-    base::ListValue* referral_list) {
-  DeserializeReferrers(*referral_list);
-  delete referral_list;
-}
-
 void Predictor::DiscardInitialNavigationHistory() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (initial_observer_.get())
     initial_observer_->DiscardInitialNavigationHistory();
 }
 
 void Predictor::FinalizeInitializationOnIOThread(
     const std::vector<GURL>& startup_urls,
-    base::ListValue* referral_list,
+    const base::ListValue* referral_list,
     IOThread* io_thread,
     ProfileIOData* profile_io_data) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   profile_io_data_ = profile_io_data;
   initial_observer_.reset(new 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. The predictor lives on the IO thread and will die
   // from there so now that we're on the IO thread we need to properly
   // initialize the base::WeakPtrFactory.
   // TODO(groby): Check if WeakPtrFactory has the same constraint.
   weak_factory_.reset(new base::WeakPtrFactory<Predictor>(this));
 
   // Prefetch these hostnames on startup.
   DnsPrefetchMotivatedList(startup_urls, UrlInfo::STARTUP_LIST_MOTIVATED);
 
-  DeserializeReferrersThenDelete(referral_list);
+  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.
 //-----------------------------------------------------------------------------
@@ skipping 216 matching lines @@
 
 bool Predictor::CanPreresolveAndPreconnect() const {
   if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     return chrome_browser_net::CanPreresolveAndPreconnectUI(user_prefs_);
   } else {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     return chrome_browser_net::CanPreresolveAndPreconnectIO(profile_io_data_);
   }
 }
 
+void Predictor::ClearPrefsOnUIThread() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  user_prefs_->ClearPref(prefs::kDnsPrefetchingStartupList);
+  user_prefs_->ClearPref(prefs::kDnsPrefetchingHostReferralList);
+}
+
+void Predictor::DiscardAllResultAndClearPrefs() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DiscardAllResults();
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(&Predictor::ClearPrefsOnUIThread,
+                                     weak_factory_->GetWeakPtr()));
+}
+
 enum SubresourceValue {
   PRECONNECTION,
   PRERESOLUTION,
   TOO_NEW,
   SUBRESOURCE_VALUE_MAX
 };
 
 void Predictor::PrepareFrameSubresources(const GURL& original_url,
                                          const GURL& first_party_for_cookies) {
   // Apply HSTS redirect early so it is taken into account when looking up
@@ skipping 364 matching lines @@
 }
 
 void SimplePredictor::ShutdownOnUIThread() {
   SetShutdown(true);
 }
 
 bool SimplePredictor::CanPrefetchAndPrerender() const { return true; }
 bool SimplePredictor::CanPreresolveAndPreconnect() const { return true; }
 
 }  // namespace chrome_browser_net