Clear the host cache when closing the last incognito window....

chrome/browser/net/dns_global.cc

 // Copyright (c) 2006-2008 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/dns_global.h"
 
 #include <map>
 #include <string>
 
 #include "base/command_line.h"
@@ skipping 16 matching lines @@
 #include "chrome/common/chrome_switches.h"
 #include "net/base/fixed_host_resolver.h"
 #include "net/base/host_resolver.h"
 #include "net/base/host_resolver_impl.h"
 
 using base::Time;
 using base::TimeDelta;
 
 namespace chrome_browser_net {
 
-static void DiscardAllPrefetchState();
+static void ChangedToOnTheRecord();
 static void DnsMotivatedPrefetch(const std::string& hostname,
                                  DnsHostInfo::ResolutionMotivation motivation);
 static void DnsPrefetchMotivatedList(
     const NameList& hostnames,
     DnsHostInfo::ResolutionMotivation motivation);
 
 // static
-const size_t DnsPrefetcherInit::kMaxConcurrentLookups = 8;
+const size_t DnsGlobalInit::kMaxPrefetchConcurrentLookups = 8;
 
 // static
-const int DnsPrefetcherInit::kMaxQueueingDelayMs = 1000;
+const int DnsGlobalInit::kMaxPrefetchQueueingDelayMs = 1000;
 
 // Host resolver shared by DNS prefetcher, and the main URLRequestContext.
 static net::HostResolver* global_host_resolver = NULL;
 
 //------------------------------------------------------------------------------
 // This section contains all the globally accessable API entry points for the
 // DNS Prefetching feature.
 //------------------------------------------------------------------------------
 
 // Status of prefetch feature, controlling whether any prefetching is done.
 static bool dns_prefetch_enabled = true;
 
 // Cached inverted copy of the off_the_record pref.
 static bool on_the_record_switch = true;
 
 // Enable/disable Dns prefetch activity (either via command line, or via pref).
 void EnableDnsPrefetch(bool enable) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   dns_prefetch_enabled = enable;
 }
 
 void OnTheRecord(bool enable) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   if (on_the_record_switch == enable)
     return;
   on_the_record_switch = enable;
-  if (on_the_record_switch)
-    DiscardAllPrefetchState();  // Destroy all evidence of our OTR session.
+  if (on_the_record_switch) {
+    ChromeThread::PostTask(
+        ChromeThread::IO,
+        FROM_HERE,
+        NewRunnableFunction(ChangedToOnTheRecord));
+  }
 }
 
 void RegisterPrefs(PrefService* local_state) {
   local_state->RegisterListPref(prefs::kDnsStartupPrefetchList);
   local_state->RegisterListPref(prefs::kDnsHostReferralList);
 }
 
 void RegisterUserPrefs(PrefService* user_prefs) {
   user_prefs->RegisterBooleanPref(prefs::kDnsPrefetchingEnabled, true);
 }
@@ skipping 315 matching lines @@
   // then try to shutdown the browser) don't instigate the CHECK about
   // "some slaves have not finished"
   const TimeDelta kAllowableShutdownTime(TimeDelta::FromSeconds(10));
   DCHECK(NULL == dns_master);
   if (!dns_master) {
     // Have the DnsMaster issue resolve requests through a global HostResolver
     // that is shared by the main URLRequestContext, and lives on the IO thread.
     dns_master = new DnsMaster(GetGlobalHostResolver(),
                                max_queue_delay, max_concurrent);
     dns_master->AddRef();
-    // We did the initialization, so we should prime the pump, and set up
-    // the DNS resolution system to run.
-    Singleton<OffTheRecordObserver>::get()->Register();
 
     if (user_prefs) {
       bool enabled = user_prefs->GetBoolean(prefs::kDnsPrefetchingEnabled);
       EnableDnsPrefetch(enabled);
     }
 
     DLOG(INFO) << "DNS Prefetch service started";
 
     // Start observing real HTTP stack resolutions.
     // TODO(eroman): really this should be called from IO thread (since that is
@@ skipping 25 matching lines @@
     global_host_resolver = NULL;
   }
 }
 
 void FreeDnsPrefetchResources() {
   DCHECK(NULL != dns_master);
   dns_master->Release();
   dns_master = NULL;
 }
 
-static void DiscardAllPrefetchState() {
-  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
-  if (!dns_master)
-    return;
+static void ChangedToOnTheRecord() {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 
-  ChromeThread::PostTask(
-      ChromeThread::IO,
-      FROM_HERE,
-      NewRunnableMethod(dns_master,
-                        &DnsMaster::DiscardAllResults));
+  if (dns_master) {
+    // Destroy all evidence of our OTR session.
+    dns_master->DnsMaster::DiscardAllResults();
+  }
+
+  // Clear the host cache to avoid showing entries from the OTR session
+  // in about:net-internals.
+  net::HostCache* host_cache = GetGlobalHostResolver()->GetHostCache();
+  if (host_cache)
+    host_cache->clear();
 }
 
 //------------------------------------------------------------------------------
 
 net::HostResolver* GetGlobalHostResolver() {
   // Called from UI thread.
   if (!global_host_resolver) {
     const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
     // The FixedHostResolver allows us to send all network requests through
@@ skipping 123 matching lines @@
       FROM_HERE,
       NewRunnableMethod(dns_master,
                         &DnsMaster::DeserializeReferrersThenDelete,
                         referral_list_copy));
 }
 
 //------------------------------------------------------------------------------
 // Methods for the helper class that is used to startup and teardown the whole
 // DNS prefetch system.
 
-DnsPrefetcherInit::DnsPrefetcherInit(PrefService* user_prefs,
-                                     PrefService* local_state) {
+DnsGlobalInit::DnsGlobalInit(PrefService* user_prefs,
+                             PrefService* local_state) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   // Set up a field trial to see what disabling DNS pre-resolution does to
   // latency of page loads.
   FieldTrial::Probability kDivisor = 100;
   // For each option (i.e., non-default), we have a fixed probability.
   FieldTrial::Probability kProbabilityPerGroup = 10;  // 10% probability.
 
   trial_ = new FieldTrial("DnsImpact", kDivisor);
 
   // First option is to disable prefetching completely.
   int disabled_prefetch = trial_->AppendGroup("_disabled_prefetch",
                                               kProbabilityPerGroup);
   // Set congestion detection at 250, 500, or 750ms, rather than the 1 second
   // default.
   int max_250ms_prefetch = trial_->AppendGroup("_max_250ms_queue_prefetch",
                                                kProbabilityPerGroup);
   int max_500ms_prefetch = trial_->AppendGroup("_max_500ms_queue_prefetch",
                                                kProbabilityPerGroup);
   int max_750ms_prefetch = trial_->AppendGroup("_max_750ms_queue_prefetch",
                                                kProbabilityPerGroup);
   // Set congestion detection at 2 seconds instead of the 1 second default.
   int max_2s_prefetch = trial_->AppendGroup("_max_2s_queue_prefetch",
                                             kProbabilityPerGroup);
 
   trial_->AppendGroup("_default_enabled_prefetch",
       FieldTrial::kAllRemainingProbability);
 
+  // We will register the incognito observer regardless of whether prefetching
+  // is enabled, as it is also used to clear the host cache.
+  Singleton<OffTheRecordObserver>::get()->Register();
+
   if (trial_->group() != disabled_prefetch) {
     // Initialize the DNS prefetch system.
 
-    size_t max_concurrent = kMaxConcurrentLookups;
+    size_t max_concurrent = kMaxPrefetchConcurrentLookups;
 
-    int max_queueing_delay_ms = kMaxQueueingDelayMs;
+    int max_queueing_delay_ms = kMaxPrefetchQueueingDelayMs;
 
     if (trial_->group() == max_250ms_prefetch)
       max_queueing_delay_ms = 250;
     else if (trial_->group() == max_500ms_prefetch)
       max_queueing_delay_ms = 500;
     else if (trial_->group() == max_750ms_prefetch)
       max_queueing_delay_ms = 750;
     else if (trial_->group() == max_2s_prefetch)
       max_queueing_delay_ms = 2000;
 
     TimeDelta max_queueing_delay(
         TimeDelta::FromMilliseconds(max_queueing_delay_ms));
 
     DCHECK(!dns_master);
     InitDnsPrefetch(max_queueing_delay, max_concurrent, user_prefs);
     DCHECK(dns_master);  // Will be checked in destructor.
     DnsPrefetchHostNamesAtStartup(user_prefs, local_state);
     RestoreSubresourceReferrers(local_state);
   }
 }
 
-DnsPrefetcherInit::~DnsPrefetcherInit() {
+DnsGlobalInit::~DnsGlobalInit() {
     if (dns_master)
       FreeDnsPrefetchResources();
   }
 
 }  // namespace chrome_browser_net