Modifying prefetch to account for multi-profile.

chrome/browser/browser_main.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/browser_main.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 37 matching lines @@
 #include "chrome/browser/jankometer.h"
 #include "chrome/browser/language_usage_metrics.h"
 #include "chrome/browser/metrics/field_trial_synchronizer.h"
 #include "chrome/browser/metrics/histogram_synchronizer.h"
 #include "chrome/browser/metrics/metrics_log.h"
 #include "chrome/browser/metrics/metrics_service.h"
 #include "chrome/browser/metrics/thread_watcher.h"
 #include "chrome/browser/net/chrome_dns_cert_provenance_checker.h"
 #include "chrome/browser/net/chrome_dns_cert_provenance_checker_factory.h"
 #include "chrome/browser/net/chrome_net_log.h"
-#include "chrome/browser/net/predictor_api.h"
+#include "chrome/browser/net/predictor.h"
 #include "chrome/browser/net/sdch_dictionary_fetcher.h"
 #include "chrome/browser/plugin_updater.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/pref_value_store.h"
 #include "chrome/browser/prerender/prerender_field_trial.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service_factory.h"
 #include "chrome/browser/process_singleton.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 527 matching lines @@
                 30));
     const int connect_backup_jobs_enabled = trial->kDefaultGroupNumber;
     trial->AppendGroup("ConnectBackupJobsDisabled",
                        kConnectBackupJobsProbability);
     const int trial_group = trial->group();
     net::internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(
         trial_group == connect_backup_jobs_enabled);
   }
 }
 
+void BrowserMainParts::PredictorFieldTrial() {
+  const base::FieldTrial::Probability kDivisor = 1000;
+  // For each option (i.e., non-default), we have a fixed probability.
+  // 0.1% probability.
+  const base::FieldTrial::Probability kProbabilityPerGroup = 1;
+
+  // After June 30, 2011 builds, it will always be in default group
+  // (default_enabled_prefetch).
+  scoped_refptr<base::FieldTrial> trial(
+      new base::FieldTrial("DnsImpact", kDivisor,
+                           "default_enabled_prefetch", 2011, 10, 30));
+
+  // First option is to disable prefetching completely.
+  int disabled_prefetch = trial->AppendGroup("disabled_prefetch",
+                                              kProbabilityPerGroup);
+
+  // We're running two experiments at the same time.  The first set of trials
+  // modulates the delay-time until we declare a congestion event (and purge
+  // our queue).  The second modulates the number of concurrent resolutions
+  // we do at any time.  Users are in exactly one trial (or the default) during
+  // any one run, and hence only one experiment at a time.
+  // Experiment 1:
+  // 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);
+  // Experiment 2:
+  // Set max simultaneous resoultions to 2, 4, or 6, and scale the congestion
+  // limit proportionally (so we don't impact average probability of asserting
+  // congesion very much).
+  int max_2_concurrent_prefetch = trial->AppendGroup(
+      "max_2 concurrent_prefetch", kProbabilityPerGroup);
+  int max_4_concurrent_prefetch = trial->AppendGroup(
+      "max_4 concurrent_prefetch", kProbabilityPerGroup);
+  int max_6_concurrent_prefetch = trial->AppendGroup(
+      "max_6 concurrent_prefetch", kProbabilityPerGroup);
+
+  if (trial->group() != disabled_prefetch) {
+    // Initialize the DNS prefetch system.
+    size_t max_parallel_resolves =
+        chrome_browser_net::Predictor::kMaxSpeculativeParallelResolves;
+    int max_queueing_delay_ms =
+        chrome_browser_net::Predictor::kMaxSpeculativeResolveQueueDelayMs;
+
+    if (trial->group() == max_2_concurrent_prefetch)
+      max_parallel_resolves = 2;
+    else if (trial->group() == max_4_concurrent_prefetch)
+      max_parallel_resolves = 4;
+    else if (trial->group() == max_6_concurrent_prefetch)
+      max_parallel_resolves = 6;
+    chrome_browser_net::Predictor::set_max_parallel_resolves(
+        max_parallel_resolves);
+
+    if (trial->group() == max_250ms_prefetch) {
+      max_queueing_delay_ms =
+         (250 * chrome_browser_net::Predictor::kTypicalSpeculativeGroupSize) /
+         max_parallel_resolves;
+    } else if (trial->group() == max_500ms_prefetch) {
+      max_queueing_delay_ms =
+          (500 * chrome_browser_net::Predictor::kTypicalSpeculativeGroupSize) /
+          max_parallel_resolves;
+    } else if (trial->group() == max_750ms_prefetch) {
+      max_queueing_delay_ms =
+          (750 * chrome_browser_net::Predictor::kTypicalSpeculativeGroupSize) /
+          max_parallel_resolves;
+    } else if (trial->group() == max_2s_prefetch) {
+      max_queueing_delay_ms =
+          (2000 * chrome_browser_net::Predictor::kTypicalSpeculativeGroupSize) /
+          max_parallel_resolves;
+    }
+    chrome_browser_net::Predictor::set_max_queueing_delay(
+        max_queueing_delay_ms);
+  }
+}
+
 // Test the impact on subsequent Google searches of getting suggestions from
 // www.google.TLD instead of clients1.google.TLD.
 void BrowserMainParts::SuggestPrefixFieldTrial() {
   const base::FieldTrial::Probability kSuggestPrefixDivisor = 100;
   // 50% probability.
   const base::FieldTrial::Probability kSuggestPrefixProbability = 50;
   // After Jan 1, 2012, it will always be in default group.
   scoped_refptr<base::FieldTrial> trial(
       new base::FieldTrial("SuggestHostPrefix",
           kSuggestPrefixDivisor, "Default_Prefix", 2012, 1, 1));
@@ skipping 80 matching lines @@
   // If a policy is defining the number of active connections this field test
   // shoud not be performed.
   if (!proxy_policy_is_set)
     ProxyConnectionsFieldTrial();
   prerender::ConfigurePrefetchAndPrerender(parsed_command_line());
   InstantFieldTrial::Activate();
   SpdyFieldTrial();
   ConnectBackupJobsFieldTrial();
   SuggestPrefixFieldTrial();
   WarmConnectionFieldTrial();
+  PredictorFieldTrial();
 }
 
 // -----------------------------------------------------------------------------
 // TODO(viettrungluu): move more/rest of BrowserMain() into above structure
 
 namespace {
 
 // This function provides some ways to test crash and assertion handling
 // behavior of the program.
 void HandleTestParameters(const CommandLine& command_line) {
@@ skipping 1126 matching lines @@
 #if defined(OS_WIN)
   // Registers Chrome with the Windows Restart Manager, which will restore the
   // Chrome session when the computer is restarted after a system update.
   // This could be run as late as WM_QUERYENDSESSION for system update reboots,
   // but should run on startup if extended to handle crashes/hangs/patches.
   // Also, better to run once here than once for each HWND's WM_QUERYENDSESSION.
   if (base::win::GetVersion() >= base::win::VERSION_VISTA)
     RegisterApplicationRestart(parsed_command_line);
 #endif  // OS_WIN
 
-  // Initialize and maintain network predictor module, which handles DNS
-  // pre-resolution, as well as TCP/IP connection pre-warming.
-  // This also registers an observer to discard data when closing incognito
-  // mode.
-  bool preconnect_enabled = true;  // Default status (easy to change!).
-  if (parsed_command_line.HasSwitch(switches::kDisablePreconnect))
-    preconnect_enabled = false;
-  else if (parsed_command_line.HasSwitch(switches::kEnablePreconnect))
-    preconnect_enabled = true;
-  chrome_browser_net::PredictorInit dns_prefetch(

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

This historically has a side effect of starting to pre-resolve the domains which
will probably be used at startup.  Since startup takes a few hundred
milliseconds, it is nice to overlay this DNS stuff (which can take a few hundred
milliseconds!).
Please be sure your new initialization as as aggressively early in the startup
as possible.

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

I think that the new code will actually invoke this even earlier! That's because
everything is moved into the Profile initialization, which is initializing the
Predictor object. CreateProfile() is called on line 1815, which is before this,
so this sounds like we'll have the nice side effect of beginning DNS prefetch
even earlier on in initialization.

-      user_prefs,
-      local_state,
-      preconnect_enabled);
-
 #if defined(OS_WIN)
   base::win::ScopedCOMInitializer com_initializer;
 
 #if defined(GOOGLE_CHROME_BUILD)
   // Init the RLZ library. This just binds the dll and schedules a task on the
   // file thread to be run sometime later. If this is the first run we record
   // the installation event.
   bool google_search_default = false;
   TemplateURLService* template_url_service =
       TemplateURLServiceFactory::GetForProfile(profile);
@@ skipping 282 matching lines @@
 #if defined(OS_CHROMEOS)
   // To be precise, logout (browser shutdown) is not yet done, but the
   // remaining work is negligible, hence we say LogoutDone here.
   chromeos::BootTimesLoader::Get()->AddLogoutTimeMarker("LogoutDone",
                                                         false);
   chromeos::BootTimesLoader::Get()->WriteLogoutTimes();
 #endif
   TRACE_EVENT_END_ETW("BrowserMain", 0, 0);
   return result_code;
 }