Re-enable pre-read experiment as a finch field trial.

chrome/app/client_util.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 <windows.h>
 #include <shlwapi.h>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/environment.h"
 #include "base/file_version_info.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/rand_util.h"  // For PreRead experiment.
+#include "base/sha1.h"  // For PreRead experiment.
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/version.h"
 #include "base/win/windows_version.h"
 #include "chrome/app/breakpad_win.h"
 #include "chrome/app/client_util.h"
 #include "chrome/app/image_pre_reader_win.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_result_codes.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/env_vars.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/channel_info.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/util_constants.h"
 
 namespace {
 // The entry point signature of chrome.dll.
 typedef int (*DLL_MAIN)(HINSTANCE, sandbox::SandboxInterfaceInfo*);
 
 typedef void (*RelaunchChromeBrowserWithNewCommandLineIfNeededFunc)();
 
+bool PreReadExpirementHasExpired() {
+  static const int kPreReadExpiryYear = 2014;
+  static const int kPreReadExpiryMonth = 7;
+  static const int kPreReadExpiryDay = 1;
+  static const char kBuildTimeStr[] = __DATE__ " " __TIME__;
+
+  // Get the timestamp of the build.
+  base::Time build_time;
+  bool result = base::Time::FromString(kBuildTimeStr, &build_time);
+  DCHECK(result);
+
+  // Get the timestamp at which the experiment expires.
+  base::Time::Exploded exploded = {0};
+  exploded.year = kPreReadExpiryYear;
+  exploded.month = kPreReadExpiryMonth;
+  exploded.day_of_month = kPreReadExpiryDay;
+  base::Time expiration_time = base::Time::FromLocalExploded(exploded);
+
+  // Return true if the experiment is expired.
+  return (build_time > expiration_time);
+}
+
+uint8 GetPreReadPercentage() {
+  // By default use the old behaviour: read 100%.
+  const uint8 kDefaultPercentage = 100;
+  COMPILE_ASSERT(kDefaultPercentage <= 100, default_percentage_too_large);
+  COMPILE_ASSERT(kDefaultPercentage % 5 == 0, default_percentage_not_mult_5);
+
+  scoped_ptr<base::Environment> env(base::Environment::Create());
+  env->SetVar(chrome::kPreReadEnvironmentVariable,
+              base::StringPrintf("%d%%-Default", kDefaultPercentage));
+
+  // If the expirement has expired use the default pre-read level.
+  if (PreReadExpirementHasExpired())
+    return kDefaultPercentage;
+
+  // If this user isn't reporting metrics, use the default pre-read leve.

[Alexei Svitkine (slow), 2013/08/28 17:30:50]

The general rule is to avoid giving different behaviour to users depending on
whether UMA is enabled. Because if you do, then it may encourage people to
opt-out of UMA to change the behaviour, which we really don't want.

As such, you should make everyone eligible for your experiment.

[Roger McFarlane (Chromium), 2013/08/29 15:28:37]

Fair enough.

I copied this "opt-out" logic from the original experiment. Is it a reasonable
concern that metrics_id might be empty? If so, should I be using something else
as the random data source?

+  base::string16 metrics_id;
+  if (!GoogleUpdateSettings::GetMetricsId(&metrics_id) || metrics_id.empty())
+    return kDefaultPercentage;
+
+  // Otherwise, use the metrics id as the basis for deriving what level or
+  // pre-read to do. To interpret the metrics id as a random number we hash
+  // it and intepret the first 8 bytes of it as a unit-interval representing
+  // die-toss for being in the experiment population and the second 8 bytes
+  // as the die-toss for the experiment group.
+  unsigned char sha1_hash[base::kSHA1Length];
+  base::SHA1HashBytes(
+      reinterpret_cast<const unsigned char*>(metrics_id.c_str()),

[Alexei Svitkine (slow), 2013/08/28 17:30:50]

Do the results need to be persistent?

i.e. does the fact that my last startup was done via pre-read cause a problem if
my next startup isn't or vice versa?

If they're independent, I suggest just tossing a coin rather than hashing a
persistent value to determine if the user should be in the trial. You can do
this via a simple call to base::RandDouble() and compare that result.

[Roger McFarlane (Chromium), 2013/08/29 15:28:37]

Yes, they need to be persistent.

The OS pre-fetcher is learning the access patterns of the binary; so, from run
to run, the pre-read should be consistent, as this will be a factor affecting
the times being meassured.

+      metrics_id.size() * sizeof(metrics_id[0]),
+      sha1_hash);
+  COMPILE_ASSERT(2 * sizeof(uint64) < sizeof(sha1_hash), need_more_data);
+  const uint64* population_bits = reinterpret_cast<uint64*>(&sha1_hash[0]);
+  const uint64* group_bits = population_bits + 1;
+
+  // We limit experiment populations to 1% of the Stable and 10% of the Beta
+  // and Dev channels.
+  double population = base::BitsToOpenEndedUnitInterval(*population_bits);
+  const string16 channel(GoogleUpdateSettings::GetChromeChannel(
+      GoogleUpdateSettings::IsSystemInstall()));
+  if ((channel == installer::kChromeChannelStable && population > 0.01) ||
+      ((channel == installer::kChromeChannelBeta ||
+        channel == installer::kChromeChannelDev) && population > 0.10)) {
+    return kDefaultPercentage;
+  }
+
+  // We divide the experiment population into groups pre-reading at 5 percent
+  // increments. This is 21 groups of 5 -- to include the range [100, 105) --
+  // rounded down to the nearest 5.
+  double group = base::BitsToOpenEndedUnitInterval(*group_bits);
+  uint8 percentage = static_cast<uint8>(group * 21.0) * 5;
+  DCHECK_GE(100, percentage);
+  DCHECK_EQ(0, percentage % 5);
+
+  const char* format_str =
+    (percentage == kDefaultPercentage) ? "%d%%-Control" : "%d%%";
+
+  env->SetVar(chrome::kPreReadEnvironmentVariable,
+              base::StringPrintf(format_str, percentage));
+
+  return percentage;
+}
+
 // Expects that |dir| has a trailing backslash. |dir| is modified so it
 // contains the full path that was tried. Caller must check for the return
 // value not being null to determine if this path contains a valid dll.
 HMODULE LoadChromeWithDirectory(string16* dir) {
   ::SetCurrentDirectoryW(dir->c_str());
   const CommandLine& cmd_line = *CommandLine::ForCurrentProcess();
 #if !defined(CHROME_MULTIPLE_DLL)
   const wchar_t* dll_name = installer::kChromeDll;
 #else
   const wchar_t* dll_name = cmd_line.HasSwitch(switches::kProcessType) ?
       installer::kChromeChildDll : installer::kChromeDll;
 #endif
   dir->append(dll_name);
 
 #if !defined(WIN_DISABLE_PREREAD)
   // On Win7 with Syzygy, pre-read is a win. There've very little difference
   // between 25% and 100%. For cold starts, with or without prefetch 25%
   // performs slightly better than 100%. On XP, pre-read is generally a
   // performance loss.
   if (!cmd_line.HasSwitch(switches::kProcessType)) {
-    const size_t kStepSize = 1024 * 1024;
-    uint8 percent = base::win::GetVersion() > base::win::VERSION_XP ? 25 : 0;
-    ImagePreReader::PartialPreReadImage(dir->c_str(), percent, kStepSize);
+    static const size_t kStepSize = 1024 * 1024;
+    uint8 percentage = GetPreReadPercentage();
+    ImagePreReader::PartialPreReadImage(dir->c_str(), percentage, kStepSize);
   }
 #endif
 
   return ::LoadLibraryExW(dir->c_str(), NULL,
                           LOAD_WITH_ALTERED_SEARCH_PATH);
 }
 
 void RecordDidRun(const string16& dll_path) {
   bool system_level = !InstallUtil::IsPerUserInstall(dll_path.c_str());
   GoogleUpdateSettings::UpdateDidRunState(true, system_level);
@@ skipping 165 matching lines @@
   }
 };
 
 MainDllLoader* MakeMainDllLoader() {
 #if defined(GOOGLE_CHROME_BUILD)
   return new ChromeDllLoader();
 #else
   return new ChromiumDllLoader();
 #endif
 }