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 = 0;
+
+// True once |g_pre_read_options| has been initialized.
+bool g_pre_read_options_initialized = false;

[gab, 2016/01/20 20:09:39]

I'd like to avoid this global in non-dcheck builds.

We could set |g_pre_read_options| to -1 when uninitialized and get rid of
|g_pre_read_options_initialized|?

Or instead of -1 (which indicates that everything is on if this is somehow
returned accidentally in non-dcheck builds), we could have
PRE_READ_OPTION_UNINITIALIZED in the enum and initialize to that..?

(other option is to ifdef this and its usage to "#if (!defined(NDEBUG) ||
defined(DCHECK_ALWAYS_ON))" but I prefer just not having the variable)

[fdoray, 2016/01/20 21:58:53]

Done, I added a PRE_READ_OPTION_UNINITIALIZED bit.

Note: Since startup_metric_utils_common is a static library, there is multiple
versions of g_pre_read_options in a component build. Therefore, I was forced to
remove the DCHECK at the beginning of GetPreReadOptions. One way to avoid this
problem would be to make startup_metric_utils_common a dynamic library... but I
don't think it's worth it just to allow a DCHECK.

+
 // 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(!g_pre_read_options_initialized);
 
   // 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;
+    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(value == 1);

[gab, 2016/01/20 20:09:40]

DCHECK_EQ(1, value)

[fdoray, 2016/01/20 21:58:53]

Done.

+      g_pre_read_options &= mapping.bit;
+    }
   }
+
+  g_pre_read_options_initialized = true;
+}
+
+int GetPreReadOptions() {
+  DCHECK(g_pre_read_options_initialized);
+  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
@@ skipping 46 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