Use valid /prefetch arguments for process launches on Windows. - do not submit

components/startup_metric_utils/common/pre_read_field_trial_utils_win.cc

 // Copyright 2015 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 "components/startup_metric_utils/common/pre_read_field_trial_utils_win.h"
 
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_util.h"
@@ skipping 13 matching lines @@
 // registered so that UMA metrics recorded during the current startup are
 // annotated with the pre-read group that is actually used during this startup.
 const char kPreReadSyntheticFieldTrialName[] = "SyntheticPreRead";
 
 // Variation names for the PreRead field trial.
 const base::char16 kNoPreReadVariationName[] = L"NoPreRead";
 const base::char16 kHighPriorityVariationName[] = L"HighPriority";
 const base::char16 kOnlyIfColdVariationName[] = L"OnlyIfCold";
 const base::char16 kPrefetchVirtualMemoryVariationName[] =
     L"PrefetchVirtualMemory";
+const base::char16 kPrefetchArgumentVariationName[] = L"PrefetchArgument";
 
 // Registry key in which the PreRead field trial group is stored.
 const base::char16 kPreReadFieldTrialRegistryKey[] = L"\\PreReadFieldTrial";
 
 // Returns the registry path in which the PreRead group is stored.
 base::string16 GetPreReadRegistryPath(
     const base::string16& product_registry_path) {
   return product_registry_path + kPreReadFieldTrialRegistryKey;
 }
 
 }  // namespace
 
 void GetPreReadOptions(const base::string16& product_registry_path,
                        bool* no_pre_read,
                        bool* high_priority,
                        bool* only_if_cold,
-                       bool* prefetch_virtual_memory) {
+                       bool* prefetch_virtual_memory,
+                       bool* prefetch_argument) {
   DCHECK(!product_registry_path.empty());
   DCHECK(no_pre_read);
   DCHECK(high_priority);
   DCHECK(only_if_cold);
   DCHECK(prefetch_virtual_memory);
+  DCHECK(prefetch_argument);
 
   // Open the PreRead field trial's registry key.
   const base::string16 registry_path =
       GetPreReadRegistryPath(product_registry_path);
   const base::win::RegKey key(HKEY_CURRENT_USER, registry_path.c_str(),
                               KEY_QUERY_VALUE);
 
   // Set the PreRead field trial's options.
   struct VariationMapping {
     const base::char16* name;
     bool* variable;
   } const variations_mappings[] = {
       {kNoPreReadVariationName, no_pre_read},
       {kHighPriorityVariationName, high_priority},
       {kOnlyIfColdVariationName, only_if_cold},
       {kPrefetchVirtualMemoryVariationName, prefetch_virtual_memory},
+      {kPrefetchArgumentVariationName, prefetch_argument},

[gab, 2016/01/18 19:10:52]

Actually, /prefetch applies only to processes launched after the initial startup
phase during which we can't use Finch... so we could use the regular Finch
groups (no registry) for this one... WDYT?

I guess since we want to mix it with other prefetch experiments it's still best
to keep it here even though it's not necessary for this specific variation,
it'll make for easier analysis of variation mixes.

   };
 
   for (const auto& mapping : variations_mappings) {
     // Set the option variable to true if the corresponding value is found in
     // the registry. Set to false otherwise (default behavior).

[gab, 2016/01/18 19:10:52]

Would be nice to see /prefetch in action on the waterfall, there is a config
somewhere to specify what the Finch defaults should be on the waterfall, let's
try to enable /prefetch on the waterfall as well as part of this change?

     DWORD value = 0;
     *mapping.variable = key.ReadValueDW(mapping.name, &value) == ERROR_SUCCESS;
     DCHECK(!*mapping.variable || value == 1);
   }
 }
 
 void UpdatePreReadOptions(const base::string16& product_registry_path) {
   DCHECK(!product_registry_path.empty());
 
   const base::string16 registry_path =
@@ skipping 50 matching lines @@
   base::string16 group;
   key.ReadValue(L"", &group);
 
   if (!group.empty()) {
     register_synthetic_field_trial.Run(kPreReadSyntheticFieldTrialName,
                                        base::UTF16ToUTF8(group));
   }
 }
 
 }  // namespace startup_metric_utils