Modifying prefetch to account for multi-profile.

chrome/browser/io_thread.cc

 // Copyright (c) 2011 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/io_thread.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/debug/leak_tracker.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_event_router_forwarder.h"
 #include "chrome/browser/media/media_internals.h"
 #include "chrome/browser/net/chrome_network_delegate.h"
 #include "chrome/browser/net/chrome_net_log.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/net/connect_interceptor.h"
 #include "chrome/browser/net/passive_log_collector.h"
-#include "chrome/browser/net/predictor_api.h"
+#include "chrome/browser/net/predictor.h"
 #include "chrome/browser/net/pref_proxy_config_service.h"
 #include "chrome/browser/net/proxy_service_factory.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/in_process_webkit/indexed_db_key_utility_client.h"
 #include "content/common/url_fetcher.h"
 #include "net/base/cert_verifier.h"
@@ skipping 295 matching lines @@
 // |local_state| is passed in explicitly in order to (1) reduce implicit
 // dependencies and (2) make IOThread more flexible for testing.
 IOThread::IOThread(
     PrefService* local_state,
     ChromeNetLog* net_log,
     ExtensionEventRouterForwarder* extension_event_router_forwarder)
     : BrowserProcessSubThread(BrowserThread::IO),
       net_log_(net_log),
       extension_event_router_forwarder_(extension_event_router_forwarder),
       globals_(NULL),
-      speculative_interceptor_(NULL),
-      predictor_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
   // We call RegisterPrefs() here (instead of inside browser_prefs.cc) to make
   // sure that everything is initialized in the right order.
   RegisterPrefs(local_state);
   auth_schemes_ = local_state->GetString(prefs::kAuthSchemes);
   negotiate_disable_cname_lookup_ = local_state->GetBoolean(
       prefs::kDisableAuthNegotiateCnameLookup);
   negotiate_enable_port_ = local_state->GetBoolean(
       prefs::kEnableAuthNegotiatePort);
   auth_server_whitelist_ = local_state->GetString(prefs::kAuthServerWhitelist);
@@ skipping 21 matching lines @@
 
 IOThread::Globals* IOThread::globals() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return globals_;
 }
 
 ChromeNetLog* IOThread::net_log() {
   return net_log_;
 }
 
 void IOThread::InitNetworkPredictor(

[willchan no longer on Chromium, 2011/08/10 16:10:35]

Please kill off IOThread::InitNetworkPredictor(). It's only caller is Predictor,
but IOThread::InitNetworkPredictorOnIOThread() just calls back into
Predictor::FinalizeInitializationOnIOThread(). There's no reason to bounce these
calls through IOThread, just have Predictor do the PostTask internally.

[rpetterson, 2011/08/12 03:12:36]

Done.

-    bool prefetching_enabled,
-    base::TimeDelta max_dns_queue_delay,
-    size_t max_speculative_parallel_resolves,
     const chrome_common_net::UrlList& startup_urls,
     ListValue* referral_list,
-    bool preconnect_enabled) {
+    chrome_browser_net::Predictor* predictor) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   message_loop()->PostTask(
       FROM_HERE,
       NewRunnableMethod(
           this,
           &IOThread::InitNetworkPredictorOnIOThread,
-          prefetching_enabled, max_dns_queue_delay,
-          max_speculative_parallel_resolves,
-          startup_urls, referral_list, preconnect_enabled));
-}
-
-void IOThread::ChangedToOnTheRecord() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  message_loop()->PostTask(
-      FROM_HERE,
-      NewRunnableMethod(
-          this,
-          &IOThread::ChangedToOnTheRecordOnIOThread));
+          startup_urls, referral_list, predictor));
 }
 
 net::URLRequestContextGetter* IOThread::system_url_request_context_getter() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!system_url_request_context_getter_) {
     InitSystemRequestContext();
   }
   return system_url_request_context_getter_;
 }
 
-void IOThread::ClearNetworkingHistory() {
+void IOThread::ClearNetworkingHistory(
+    chrome_browser_net::Predictor* predictor) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   ClearHostCache();
   // Discard acrued data used to speculate in the future.
-  chrome_browser_net::DiscardInitialNavigationHistory();
-  if (predictor_)
-    predictor_->DiscardAllResults();
+  if (predictor) {
+    predictor->DiscardInitialNavigationHistory();
+    predictor->DiscardAllResults();
+  }
 }
 
 void IOThread::Init() {
   // Though this thread is called the "IO" thread, it actually just routes
   // messages around; it shouldn't be allowed to perform any blocking disk I/O.
   base::ThreadRestrictions::SetIOAllowed(false);
 
   BrowserProcessSubThread::Init();
 
   DCHECK_EQ(MessageLoop::TYPE_IO, message_loop()->type());
@@ skipping 71 matching lines @@
   BrowserChildProcessHost::TerminateAll();
 
   system_url_request_context_getter_ = NULL;
 
   // Step 2: Release objects that the net::URLRequestContext could have been
   // pointing to.
 
   // This must be reset before the ChromeNetLog is destroyed.
   network_change_observer_.reset();
 
-  // Not initialized in Init().  May not be initialized.
-  if (predictor_) {
-    predictor_->Shutdown();
-
-    // TODO(willchan): Stop reference counting Predictor.  It's owned by
-    // IOThread now.
-    predictor_->Release();
-    predictor_ = NULL;
-    chrome_browser_net::FreePredictorResources();
-  }
-
-  // Deletion will unregister this interceptor.
-  delete speculative_interceptor_;
-  speculative_interceptor_ = NULL;
-
   system_proxy_config_service_.reset();
 
   delete globals_;
   globals_ = NULL;
 
   // net::URLRequest instances must NOT outlive the IO thread.
   base::debug::LeakTracker<net::URLRequest>::CheckForLeaks();
 
   base::debug::LeakTracker<SystemURLRequestContextGetter>::CheckForLeaks();
 
@@ skipping 37 matching lines @@
   return net::HttpAuthHandlerRegistryFactory::Create(
       supported_schemes,
       globals_->url_security_manager.get(),
       resolver,
       gssapi_library_name_,
       negotiate_disable_cname_lookup_,
       negotiate_enable_port_);
 }
 
 void IOThread::InitNetworkPredictorOnIOThread(
-    bool prefetching_enabled,
-    base::TimeDelta max_dns_queue_delay,
-    size_t max_speculative_parallel_resolves,
     const chrome_common_net::UrlList& startup_urls,
     ListValue* referral_list,
-    bool preconnect_enabled) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  CHECK(!predictor_);
-
-  chrome_browser_net::EnablePredictor(prefetching_enabled);
-
-  predictor_ = new chrome_browser_net::Predictor(

[jar (doing other things), 2011/08/16 01:19:09]

Code like this is what caused us to have such a method.  This is where
predictor_ was constructed.  Now the method takes a constructed predictor as an
argument... so the name has to change... or else we should let this method do
its work  to constract and return, or save, or post the new predictor.

-      globals_->host_resolver.get(),
-      max_dns_queue_delay,
-      max_speculative_parallel_resolves,
-      preconnect_enabled);
-  predictor_->AddRef();
-
-  // Speculative_interceptor_ is used to predict subresource usage.
-  DCHECK(!speculative_interceptor_);
-  speculative_interceptor_ = new chrome_browser_net::ConnectInterceptor;
-
-  FinalizePredictorInitialization(predictor_, startup_urls, referral_list);
-}
-
-void IOThread::ChangedToOnTheRecordOnIOThread() {
+    chrome_browser_net::Predictor* predictor) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  if (predictor_) {
-    // Destroy all evidence of our OTR session.
-    // Note: OTR mode never saves InitialNavigationHistory data.
-    predictor_->Predictor::DiscardAllResults();
-  }
-
-  // Clear the host cache to avoid showing entries from the OTR session
-  // in about:net-internals.
-  ClearHostCache();
-
-  // Clear all of the passively logged data.
-  // TODO(eroman): this is a bit heavy handed, really all we need to do is
-  //               clear the data pertaining to incognito context.
-  net_log_->ClearAllPassivelyCapturedEvents();
+  predictor->FinalizeInitializationOnIOThread(startup_urls, referral_list,

[jar (doing other things), 2011/08/16 01:19:09]

This method name should be reflected in the name of the method on line 561... or
perhaps we should not even bother to pass through the IOThread class, as it does
not (currently) appear that the class is benefiting (recording values or
pointers as they pass through?) from this indirection.

[willchan no longer on Chromium, 2011/08/16 01:42:57]

I think I may have commented on this before (I hope I did, hehe). Yes, this
indirection is unnecessary. We should remove the call to IOThread and just have
the predictor post a task to BrowserThread::IO directly.

[rpetterson, 2011/08/16 03:52:12]

Yes, this has already been pulled out.

+                                              globals_->host_resolver.get());
 }
 
 void IOThread::ClearHostCache() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (globals_->host_resolver->GetAsHostResolverImpl()) {
     net::HostCache* host_cache =
         globals_->host_resolver.get()->GetAsHostResolverImpl()->cache();
     if (host_cache)
       host_cache->clear();
@@ skipping 47 matching lines @@
   system_params.network_delegate = globals_->system_network_delegate.get();
   system_params.net_log = net_log_;
   globals_->system_http_transaction_factory.reset(
       new net::HttpNetworkLayer(
           new net::HttpNetworkSession(system_params)));
   globals_->system_ftp_transaction_factory.reset(
       new net::FtpNetworkLayer(globals_->host_resolver.get()));
   globals_->system_request_context =
       ConstructSystemRequestContext(globals_, net_log_);
 }