Store PreRead options obtained from the registry in a global variable.

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 17 matching lines @@
 // 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";
 
 // Registry key in which the PreRead field trial group is stored.
 const base::char16 kPreReadFieldTrialRegistryKey[] = L"\\PreReadFieldTrial";
 
+// Pre-read options to use for the current process. This is initialized by
+// InitializePreReadOptions().
+int g_pre_read_options = PRE_READ_OPTION_UNINITIALIZED;

[grt (UTC plus 2), 2016/01/21 04:24:00]

if i'm reading the build files correctly, this .cc file is linked into both
chrome.exe and chrome.dll. there will be one instance of this global variable in
the process for each of these two, so InitializePreReadOptions will need to be
called once from within each module. how will this be done?

[fdoray, 2016/01/21 16:04:16]

Yes. The call in chrome.exe is added by this CL here [1]. The call in chrome.dll
will be added by another CL [2].

[1]
https://codereview.chromium.org/1610733002/diff/60001/chrome/app/main_dll_loa...
[2]
https://codereview.chromium.org/1612663002/diff/1/chrome/browser/chrome_brows...

+
 // 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) {
+void InitializePreReadOptions(const base::string16& product_registry_path) {
   DCHECK(!product_registry_path.empty());
-  DCHECK(no_pre_read);
-  DCHECK(high_priority);
-  DCHECK(only_if_cold);
-  DCHECK(prefetch_virtual_memory);
+  DCHECK_EQ(g_pre_read_options, PRE_READ_OPTION_UNINITIALIZED);

[grt (UTC plus 2), 2016/01/21 04:24:00]

nit: always put the expected value first when using DCHECK_{EQ,NE} for
consistency with Google Test's {EXPECT,ASSERT}_EQ macro, which requires it.

[fdoray, 2016/01/21 16:04:16]

Done (I removed this line).

+
+  g_pre_read_options = 0;
 
   // 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 {

[grt (UTC plus 2), 2016/01/21 04:24:00]

nit: make this an anonymous struct since the name is unused

[fdoray, 2016/01/21 16:04:16]

Done.

     const base::char16* name;
-    bool* variable;
+    PreReadOptions bit;
   } const variations_mappings[] = {
-      {kNoPreReadVariationName, no_pre_read},
-      {kHighPriorityVariationName, high_priority},
-      {kOnlyIfColdVariationName, only_if_cold},
-      {kPrefetchVirtualMemoryVariationName, prefetch_virtual_memory},
+      {kNoPreReadVariationName, PRE_READ_OPTION_NO_PRE_READ},
+      {kHighPriorityVariationName, PRE_READ_OPTION_HIGH_PRIORITY},
+      {kOnlyIfColdVariationName, PRE_READ_OPTION_ONLY_IF_COLD},
+      {kPrefetchVirtualMemoryVariationName,
+       PRE_READ_OPTION_PREFETCH_VIRTUAL_MEMORY},
   };
 
   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).
     DWORD value = 0;
-    *mapping.variable = key.ReadValueDW(mapping.name, &value) == ERROR_SUCCESS;
-    DCHECK(!*mapping.variable || value == 1);
+    if (key.ReadValueDW(mapping.name, &value) == ERROR_SUCCESS) {
+      DCHECK_EQ(1U, value);
+      g_pre_read_options &= mapping.bit;

[grt (UTC plus 2), 2016/01/21 04:24:00]

|=

[fdoray, 2016/01/21 16:04:16]

Done (now using a struct).

+    }
   }
 }
 
+int GetPreReadOptions() {
+  return g_pre_read_options;
+}
+
 void UpdatePreReadOptions(const base::string16& product_registry_path) {
   DCHECK(!product_registry_path.empty());
 
   const base::string16 registry_path =
       GetPreReadRegistryPath(product_registry_path);
 
   // Clear the experiment key. That way, when the trial is shut down, the
   // registry will be cleaned automatically. Also, this prevents variation
   // params from the previous group to stay in the registry when the group is
   // updated.
@@ skipping 44 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