Make omaha, gcapi and uninstall registry accesses use Wow6432Node on 64-bit

chrome/installer/util/installation_state.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/installation_state.h"
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/version.h"
@@ skipping 18 matching lines @@
                               BrowserDistribution::Type type) {
   return Initialize(system_install,
                     BrowserDistribution::GetSpecificDistribution(type));
 }
 
 // Initializes |commands| from the "Commands" subkey of |version_key|.
 // Returns false if there is no "Commands" subkey or on error.
 // static
 bool ProductState::InitializeCommands(const base::win::RegKey& version_key,
                                       AppCommands* commands) {
-  static const DWORD kAccess = KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE;
+  static const DWORD kAccess =
+      KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE | KEY_WOW64_32KEY;
   base::win::RegKey commands_key;
 
   if (commands_key.Open(version_key.Handle(), google_update::kRegCommandsKey,
                         kAccess) == ERROR_SUCCESS)
     return commands->Initialize(commands_key);
   return false;
 }
 
 bool ProductState::Initialize(bool system_install,
                               BrowserDistribution* distribution) {
+  static const DWORD kAccess = KEY_QUERY_VALUE | KEY_WOW64_32KEY;
   const std::wstring version_key(distribution->GetVersionKey());
   const std::wstring state_key(distribution->GetStateKey());
   const HKEY root_key = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   base::win::RegKey key;
 
   // Clear the runway.
   Clear();
 
   // Read from the Clients key.
-  if (key.Open(root_key, version_key.c_str(),
-               KEY_QUERY_VALUE) == ERROR_SUCCESS) {
+  if (key.Open(root_key, version_key.c_str(), kAccess) == ERROR_SUCCESS) {
     base::string16 version_str;
     if (key.ReadValue(google_update::kRegVersionField,
                       &version_str) == ERROR_SUCCESS) {
       version_.reset(new Version(base::UTF16ToASCII(version_str)));
       if (!version_->IsValid())
         version_.reset();
     }
 
     // Attempt to read the other values even if the "pv" version value was
     // absent. Note that ProductState instances containing these values will
     // only be accessible via InstallationState::GetNonVersionedProductState.
     if (key.ReadValue(google_update::kRegOldVersionField,
                       &version_str) == ERROR_SUCCESS) {
       old_version_.reset(new Version(base::UTF16ToASCII(version_str)));
       if (!old_version_->IsValid())
         old_version_.reset();
     }
 
     key.ReadValue(google_update::kRegRenameCmdField, &rename_cmd_);
     if (!InitializeCommands(key, &commands_))
       commands_.Clear();
   }
 
   // Read from the ClientState key.
-  if (key.Open(root_key, state_key.c_str(),
-               KEY_QUERY_VALUE) == ERROR_SUCCESS) {
+  if (key.Open(root_key, state_key.c_str(), kAccess) == ERROR_SUCCESS) {
     std::wstring setup_path;
     std::wstring uninstall_arguments;
     // "ap" will be absent if not managed by Google Update.
     channel_.Initialize(key);
 
     // Read in the brand code, it may be absent
     key.ReadValue(google_update::kRegBrandField, &brand_);
 
     // "UninstallString" will be absent for the multi-installer package.
     key.ReadValue(kUninstallStringField, &setup_path);
@@ skipping 20 matching lines @@
     // Multi-install is implied or is derived from the command-line.
     if (distribution->GetType() == BrowserDistribution::CHROME_BINARIES)
       multi_install_ = true;
     else
       multi_install_ = uninstall_command_.HasSwitch(switches::kMultiInstall);
   }
 
   // Read from the ClientStateMedium key.  Values here override those in
   // ClientState.
   if (system_install &&
-      key.Open(root_key, distribution->GetStateMediumKey().c_str(),
-               KEY_QUERY_VALUE) == ERROR_SUCCESS) {
+      key.Open(root_key, distribution->GetStateMediumKey().c_str(), kAccess) ==
+          ERROR_SUCCESS) {
     DWORD dword_value = 0;
 
     if (key.ReadValueDW(google_update::kRegUsageStatsField,
                         &dword_value) == ERROR_SUCCESS) {
       has_usagestats_ = true;
       usagestats_ = dword_value;
     }
 
     if (key.ReadValueDW(google_update::kRegEULAAceptedField,
                         &dword_value) == ERROR_SUCCESS) {
@@ skipping 130 matching lines @@
 }
 
 const ProductState* InstallationState::GetProductState(
     bool system_install,
     BrowserDistribution::Type type) const {
   const ProductState* product_state =
       GetNonVersionedProductState(system_install, type);
   return product_state->version_.get() == NULL ? NULL : product_state;
 }
 }  // namespace installer