Always read and write Google Update registry values from the 32-bit hive, even on 64-bit systems.

chrome/installer/util/google_update_settings.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 "chrome/installer/util/google_update_settings.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/command_line.h"
@@ skipping 71 matching lines @@
     // how the values of multiple users are to be combined.
     std::wstring uniquename;  // presubmit: allow wstring
     if (!base::win::GetUserSidString(&uniquename)) {
       NOTREACHED();
       return false;
     }
 
     base::string16 reg_path(app_reg_data.GetStateMediumKey());
     reg_path.append(L"\\");
     reg_path.append(name);
-    RegKey key(HKEY_LOCAL_MACHINE, reg_path.c_str(), KEY_SET_VALUE);
+    RegKey key(
+        HKEY_LOCAL_MACHINE, reg_path.c_str(), KEY_SET_VALUE | KEY_WOW64_32KEY);
     key.WriteValue(google_update::kRegAggregateMethod, aggregate);
     return (key.WriteValue(uniquename.c_str(), value.c_str()) == ERROR_SUCCESS);
   } else {
     // User installs are easy: just write the values to HKCU tree.
     RegKey key(HKEY_CURRENT_USER, app_reg_data.GetStateKey().c_str(),

[grt (UTC plus 2), 2014/06/04 17:20:05]

although you and i know that this isn't currently affected by WoW, it may be
hard for readers to see that this is obviously true. since the WOW64_32 flag is
applied elsewhere regardless of HKLM vs. HKCU, would you mind doing that here as
well? it may simplify things to put a:
  const REGSAM kAccess = KEY_SET_VALUE | KEY_WOW64_32KEY;
at the top of the function and use it in both places.

[Will Harris, 2014/06/04 17:48:07]

Done.

                KEY_SET_VALUE);
     return (key.WriteValue(name, value.c_str()) == ERROR_SUCCESS);
   }
 }
 
 bool WriteGoogleUpdateStrKey(const wchar_t* const name,
                              const std::wstring& value) {
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   return WriteGoogleUpdateStrKeyInternal(
       dist->GetAppRegistrationData(), false, name, value, NULL);
@@ skipping 116 matching lines @@
   }
 
   RegKey key;
   DWORD value = 0;
   bool have_value = false;
 
   // For system-level installs, try ClientStateMedium first.
   have_value =
       system_install &&
       key.Open(HKEY_LOCAL_MACHINE, dist->GetStateMediumKey().c_str(),
-               KEY_QUERY_VALUE) == ERROR_SUCCESS &&
+               KEY_QUERY_VALUE | KEY_WOW64_32KEY) == ERROR_SUCCESS &&

[grt (UTC plus 2), 2014/06/04 17:20:05]

i like
  const REGSAM kAccess = KEY_QUERY_VALUE | KEY_WOW64_32KEY;
for use here and below, too.

[Will Harris, 2014/06/04 17:48:07]

Done.

       key.ReadValueDW(google_update::kRegUsageStatsField,
                       &value) == ERROR_SUCCESS;
 
   // Otherwise, try ClientState.
   if (!have_value) {
     have_value =
         key.Open(system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER,
                  dist->GetStateKey().c_str(),
-                 KEY_QUERY_VALUE) == ERROR_SUCCESS &&
+                 KEY_QUERY_VALUE | KEY_WOW64_32KEY) == ERROR_SUCCESS &&
         key.ReadValueDW(google_update::kRegUsageStatsField,
                         &value) == ERROR_SUCCESS;
   }
 
   // Google Update specifically checks that the value is 1, so we do the same.
   return have_value && value == 1;
 }
 
 bool GoogleUpdateSettings::SetCollectStatsConsent(bool consented) {
   return SetCollectStatsConsentAtLevel(IsSystemInstall(), consented);
@@ skipping 10 matching lines @@
   if (InstallUtil::IsMultiInstall(dist, system_install)) {
     dist = BrowserDistribution::GetSpecificDistribution(
         BrowserDistribution::CHROME_BINARIES);
   }
 
   // Write to ClientStateMedium for system-level; ClientState otherwise.
   HKEY root_key = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   std::wstring reg_path =
       system_install ? dist->GetStateMediumKey() : dist->GetStateKey();
   RegKey key;
-  LONG result = key.Create(root_key, reg_path.c_str(), KEY_SET_VALUE);
+  LONG result = key.Create(
+      root_key, reg_path.c_str(), KEY_SET_VALUE | KEY_WOW64_32KEY);
   if (result != ERROR_SUCCESS) {
     LOG(ERROR) << "Failed opening key " << reg_path << " to set "
                << google_update::kRegUsageStatsField << "; result: " << result;
   } else {
     result = key.WriteValue(google_update::kRegUsageStatsField, value);
     LOG_IF(ERROR, result != ERROR_SUCCESS) << "Failed setting "
         << google_update::kRegUsageStatsField << " in key " << reg_path
         << "; result: " << result;
   }
   return (result == ERROR_SUCCESS);
@@ skipping 16 matching lines @@
     const InstallationState& machine_state,
     BrowserDistribution* dist,
     bool consented) {
   DCHECK(dist);
   const DWORD eula_accepted = consented ? 1 : 0;
   std::wstring reg_path = dist->GetStateMediumKey();
   bool succeeded = true;
   RegKey key;
 
   // Write the consent value into the product's ClientStateMedium key.
-  if (key.Create(HKEY_LOCAL_MACHINE, reg_path.c_str(),
-                 KEY_SET_VALUE) != ERROR_SUCCESS ||
+  if (key.Create(HKEY_LOCAL_MACHINE,
+                 reg_path.c_str(),
+                 KEY_SET_VALUE | KEY_WOW64_32KEY) != ERROR_SUCCESS ||

[grt (UTC plus 2), 2014/06/04 17:20:05]

local const for this function, too?

[Will Harris, 2014/06/04 17:48:07]

Done.

       key.WriteValue(google_update::kRegEULAAceptedField,
                      eula_accepted) != ERROR_SUCCESS) {
     succeeded = false;
   }
 
   // If this is a multi-install, also write it into the binaries' key.
   // --mutli-install is not provided on the command-line, so deduce it from
   // the product's state.
   const installer::ProductState* product_state =
       machine_state.GetProductState(true, dist->GetType());
   if (product_state != NULL && product_state->is_multi_install()) {
     dist = BrowserDistribution::GetSpecificDistribution(
         BrowserDistribution::CHROME_BINARIES);
     reg_path = dist->GetStateMediumKey();
     if (key.Create(HKEY_LOCAL_MACHINE, reg_path.c_str(),
-                   KEY_SET_VALUE) != ERROR_SUCCESS ||
+                   KEY_SET_VALUE | KEY_WOW64_32KEY) != ERROR_SUCCESS ||
         key.WriteValue(google_update::kRegEULAAceptedField,
                        eula_accepted) != ERROR_SUCCESS) {
         succeeded = false;
     }
   }
 
   return succeeded;
 }
 
 int GoogleUpdateSettings::GetLastRunTime() {
@@ skipping 351 matching lines @@
                             UPDATE_POLICIES_COUNT);
 }
 
 base::string16 GoogleUpdateSettings::GetUninstallCommandLine(
     bool system_install) {
   const HKEY root_key = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   base::string16 cmd_line;
   RegKey update_key;
 
   if (update_key.Open(root_key, google_update::kRegPathGoogleUpdate,
                       KEY_QUERY_VALUE) == ERROR_SUCCESS) {

[grt (UTC plus 2), 2014/06/04 17:20:05]

 | KEY_WOW64_32KEY

[Will Harris, 2014/06/04 17:48:07]

Good spot.  Done.

     update_key.ReadValue(google_update::kRegUninstallCmdLine, &cmd_line);
   }
 
   return cmd_line;
 }
 
 Version GoogleUpdateSettings::GetGoogleUpdateVersion(bool system_install) {
   const HKEY root_key = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   base::string16 version;
   RegKey key;
@@ skipping 160 matching lines @@
   }
 
   // If the key or value was not present, return the empty string.
   if (result == ERROR_FILE_NOT_FOUND || result == ERROR_PATH_NOT_FOUND) {
     experiment_labels->clear();
     return true;
   }
 
   return result == ERROR_SUCCESS;
 }