Construct a field trial to see if HIGH or MEDIUM memory model "works better"...

chrome/browser/browser_main.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 <windows.h>
 #include <shellapi.h>
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/gfx/vector_canvas.h"
 #include "base/histogram.h"
 #include "base/path_service.h"
 #include "base/registry.h"
 #include "base/string_util.h"
 #include "base/tracked_objects.h"
 #include "base/win_util.h"
 #include "chrome/app/result_codes.h"
 #include "chrome/browser/automation/automation_provider.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_init.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_prefs.h"
 #include "chrome/browser/browser_process_impl.h"
 #include "chrome/browser/browser_shutdown.h"
+#include "chrome/browser/browser_trial.h"
 #include "chrome/browser/cert_store.h"
 #include "chrome/browser/dom_ui/chrome_url_data_manager.h"
 #include "chrome/browser/first_run.h"
 #include "chrome/browser/jankometer.h"
 #include "chrome/browser/metrics_service.h"
 #include "chrome/browser/net/dns_global.h"
 #include "chrome/browser/net/sdch_dictionary_fetcher.h"
 #include "chrome/browser/plugin_service.h"
 #include "chrome/browser/printing/print_job_manager.h"
 #include "chrome/browser/rlz/rlz.h"
@@ skipping 194 matching lines @@
 bool CheckMachineLevelInstall() {
   scoped_ptr<installer::Version> version(InstallUtil::GetChromeVersion(true));
   if (version.get()) {
     std::wstring exe;
     PathService::Get(base::DIR_EXE, &exe);
     std::transform(exe.begin(), exe.end(), exe.begin(), tolower);
     std::wstring user_exe_path = installer::GetChromeInstallPath(false);
     std::transform(user_exe_path.begin(), user_exe_path.end(),
                    user_exe_path.begin(), tolower);
     if (exe == user_exe_path) {
-      const std::wstring text = 
+      const std::wstring text =
           l10n_util::GetString(IDS_MACHINE_LEVEL_INSTALL_CONFLICT);
       const std::wstring caption = l10n_util::GetString(IDS_PRODUCT_NAME);
       const UINT flags = MB_OK | MB_ICONERROR | MB_TOPMOST;
       win_util::MessageBox(NULL, text, caption, flags);
       std::wstring uninstall_cmd = InstallUtil::GetChromeUninstallCmd(false);
       if (!uninstall_cmd.empty()) {
         uninstall_cmd.append(L" --");
         uninstall_cmd.append(installer_util::switches::kForceUninstall);
         uninstall_cmd.append(L" --");
         uninstall_cmd.append(installer_util::switches::kDoNotRemoveSharedItems);
@@ skipping 21 matching lines @@
                 sandbox::BrokerServices* broker_services) {
   // WARNING: If we get a WM_ENDSESSION objects created on the stack here
   // are NOT deleted. If you need something to run during WM_ENDSESSION add it
   // to browser_shutdown::Shutdown or BrowserProcess::EndSession.
 
   // TODO(beng, brettw): someday, break this out into sub functions with well
   //                     defined roles (e.g. pre/post-profile startup, etc).
 
   MessageLoop main_message_loop(MessageLoop::TYPE_UI);
 
+  // Initialize statistical testing infrastructure.
+  FieldTrialList field_trial;
+
   std::wstring app_name = chrome::kBrowserAppName;
   std::string thread_name_string = WideToASCII(app_name + L"_BrowserMain");
 
   const char* thread_name = thread_name_string.c_str();
   PlatformThread::SetName(thread_name);
   main_message_loop.set_thread_name(thread_name);
   bool already_running = CreateUniqueChromeEvent();
 
 #if defined(OS_WIN)
   // Make the selection of network stacks early on before any consumers try to
@@ skipping 20 matching lines @@
   // BrowserProcessImpl's constructor should set g_browser_process.
   DCHECK(g_browser_process);
 
   // Load local state.  This includes the application locale so we know which
   // locale dll to load.
   PrefService* local_state = browser_process->local_state();
   DCHECK(local_state);
 
   bool is_first_run = FirstRun::IsChromeFirstRun() ||
       parsed_command_line.HasSwitch(switches::kFirstRun);
-  bool first_run_ui_bypass = false; 
+  bool first_run_ui_bypass = false;
 
   // Initialize ResourceBundle which handles files loaded from external
   // sources. This has to be done before uninstall code path and before prefs
   // are registered.
   local_state->RegisterStringPref(prefs::kApplicationLocale, L"");
   local_state->RegisterBooleanPref(prefs::kMetricsReportingEnabled, false);
 
   // During first run we read the google_update registry key to find what
   // language the user selected when downloading the installer. This
   // becomes our default language in the prefs.
   if (is_first_run) {
     std::wstring install_lang;
     if (GoogleUpdateSettings::GetLanguage(&install_lang))
       local_state->SetString(prefs::kApplicationLocale, install_lang);
     if (GoogleUpdateSettings::GetCollectStatsConsent())
       local_state->SetBoolean(prefs::kMetricsReportingEnabled, true);
     // On first run, we  need to process the master preferences before the
     // browser's profile_manager object is created.
-    FirstRun::MasterPrefResult master_pref_res = 
+    FirstRun::MasterPrefResult master_pref_res =
         FirstRun::ProcessMasterPreferences(user_data_dir, std::wstring());
     first_run_ui_bypass =
         (master_pref_res == FirstRun::MASTER_PROFILE_NO_FIRST_RUN_UI);
   }
 
   ResourceBundle::InitSharedInstance(
       local_state->GetString(prefs::kApplicationLocale));
   // We only load the theme dll in the browser process.
   ResourceBundle::GetSharedInstance().LoadThemeResources();
 
@@ skipping 145 matching lines @@
 
   // Register our global network handler for chrome-resource:// URLs.
   RegisterURLRequestChromeJob();
 
   // TODO(brettw): we may want to move this to the browser window somewhere so
   // that if it pops up a dialog box, the user gets it as the child of the
   // browser window instead of a disembodied floating box blocking startup.
   ShellIntegration::VerifyInstallation();
 
   browser_process->InitBrokerServices(broker_services);
-  
+
   // In unittest mode, this will do nothing.  In normal mode, this will create
   // the global GoogleURLTracker instance, which will promptly go to sleep for
   // five seconds (to avoid slowing startup), and wake up afterwards to see if
   // it should do anything else.  If we don't cause this creation now, it won't
   // happen until someone else asks for the tracker, at which point we may no
   // longer want to sleep for five seconds.
   //
   // A simpler way of doing all this would be to have some function which could
   // give the time elapsed since startup, and simply have the tracker check that
   // when asked to initialize itself, but this doesn't seem to exist.
@@ skipping 18 matching lines @@
   }
 
   MetricsService* metrics = NULL;
   if (!parsed_command_line.HasSwitch(switches::kDisableMetrics)) {
     if (parsed_command_line.HasSwitch(switches::kMetricsRecordingOnly)) {
       local_state->transient()->SetBoolean(prefs::kMetricsReportingEnabled,
                                            false);
     }
     metrics = browser_process->metrics_service();
     DCHECK(metrics);
-    
-    // If we're testing then we don't care what the user 
-    // preference is, we turn on recording, but not reporting, otherwise tests
-    // fail.
+
+    // If we're testing then we don't care what the user preference is, we turn
+    // on recording, but not reporting, otherwise tests fail.
     if (parsed_command_line.HasSwitch(switches::kMetricsRecordingOnly)) {
       metrics->StartRecordingOnly();
     } else {
       // If the user permits metrics reporting with the checkbox in the
       // prefs, we turn on recording.
       bool enabled = local_state->GetBoolean(prefs::kMetricsReportingEnabled);
 
       metrics->SetUserPermitsUpload(enabled);
       if (enabled)
         metrics->Start();
@@ skipping 34 matching lines @@
   // unsafe to do this cleanup if other threads are still active.
   // It is also very unnecessary, so I'm only doing this in debug to satisfy
   // purify.
   if (tracking_objects)
     tracked_objects::ThreadData::ShutdownSingleThreadedCleanup();
 #endif  // NDEBUG
 
   return result_code;
 }