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

chrome/installer/util/install_util.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.
 //
 // See the corresponding header file for description of the functions in this
 // file.
 
 #include "chrome/installer/util/install_util.h"
 
 #include <shellapi.h>
@@ skipping 203 matching lines @@
   }
   return CommandLine(CommandLine::NO_PROGRAM);
 }
 
 void InstallUtil::GetChromeVersion(BrowserDistribution* dist,
                                    bool system_install,
                                    Version* version) {
   DCHECK(dist);
   RegKey key;
   HKEY reg_root = (system_install) ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
-  LONG result = key.Open(reg_root, dist->GetVersionKey().c_str(),
-                         KEY_QUERY_VALUE);
+  LONG result = key.Open(reg_root,
+                         dist->GetVersionKey().c_str(),
+                         KEY_QUERY_VALUE | KEY_WOW64_32KEY);
 
   base::string16 version_str;
   if (result == ERROR_SUCCESS)
     result = key.ReadValue(google_update::kRegVersionField, &version_str);
 
   *version = Version();
   if (result == ERROR_SUCCESS && !version_str.empty()) {
     VLOG(1) << "Existing " << dist->GetDisplayName() << " version found "
             << version_str;
     *version = Version(base::UTF16ToASCII(version_str));
   } else {
     DCHECK_EQ(ERROR_FILE_NOT_FOUND, result);
     VLOG(1) << "No existing " << dist->GetDisplayName()
             << " install found.";
   }
 }
 
 void InstallUtil::GetCriticalUpdateVersion(BrowserDistribution* dist,
                                            bool system_install,
                                            Version* version) {
   DCHECK(dist);
   RegKey key;
   HKEY reg_root = (system_install) ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
-  LONG result =
-      key.Open(reg_root, dist->GetVersionKey().c_str(), KEY_QUERY_VALUE);
+  LONG result = key.Open(reg_root,
+                         dist->GetVersionKey().c_str(),
+                         KEY_QUERY_VALUE | KEY_WOW64_32KEY);
 
   base::string16 version_str;
   if (result == ERROR_SUCCESS)
     result = key.ReadValue(google_update::kRegCriticalVersionField,
                            &version_str);
 
   *version = Version();
   if (result == ERROR_SUCCESS && !version_str.empty()) {
     VLOG(1) << "Critical Update version for " << dist->GetDisplayName()
             << " found " << version_str;
@@ skipping 18 matching lines @@
 void InstallUtil::AddInstallerResultItems(
     bool system_install,
     const base::string16& state_key,
     installer::InstallStatus status,
     int string_resource_id,
     const base::string16* const launch_cmd,
     WorkItemList* install_list) {
   DCHECK(install_list);
   const HKEY root = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   DWORD installer_result = (GetInstallReturnCode(status) == 0) ? 0 : 1;
-  install_list->AddCreateRegKeyWorkItem(
-      root, state_key, WorkItem::kWow64Default);
+  install_list->AddCreateRegKeyWorkItem(root, state_key, KEY_WOW64_32KEY);
   install_list->AddSetRegValueWorkItem(root,
                                        state_key,
-                                       WorkItem::kWow64Default,
+                                       KEY_WOW64_32KEY,
                                        installer::kInstallerResult,
                                        installer_result,
                                        true);
   install_list->AddSetRegValueWorkItem(root,
                                        state_key,
-                                       WorkItem::kWow64Default,
+                                       KEY_WOW64_32KEY,
                                        installer::kInstallerError,
                                        static_cast<DWORD>(status),
                                        true);
   if (string_resource_id != 0) {
     base::string16 msg = installer::GetLocalizedString(string_resource_id);
     install_list->AddSetRegValueWorkItem(root,
                                          state_key,
-                                         WorkItem::kWow64Default,
+                                         KEY_WOW64_32KEY,
                                          installer::kInstallerResultUIString,
                                          msg,
                                          true);
   }
   if (launch_cmd != NULL && !launch_cmd->empty()) {
     install_list->AddSetRegValueWorkItem(
         root,
         state_key,
-        WorkItem::kWow64Default,
+        KEY_WOW64_32KEY,
         installer::kInstallerSuccessLaunchCmdLine,
         *launch_cmd,
         true);
   }
 }
 
 void InstallUtil::UpdateInstallerStage(bool system_install,
                                        const base::string16& state_key_path,
                                        installer::InstallerStage stage) {
   DCHECK_LE(static_cast<installer::InstallerStage>(0), stage);
   DCHECK_GT(installer::NUM_STAGES, stage);
   const HKEY root = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   RegKey state_key;
-  LONG result = state_key.Open(root, state_key_path.c_str(),
-                               KEY_QUERY_VALUE | KEY_SET_VALUE);
+  LONG result =
+      state_key.Open(root,
+                     state_key_path.c_str(),
+                     KEY_QUERY_VALUE | KEY_SET_VALUE | KEY_WOW64_32KEY);
   if (result == ERROR_SUCCESS) {
     if (stage == installer::NO_STAGE) {
       result = state_key.DeleteValue(installer::kInstallerExtraCode1);
       LOG_IF(ERROR, result != ERROR_SUCCESS && result != ERROR_FILE_NOT_FOUND)
           << "Failed deleting installer stage from " << state_key_path
           << "; result: " << result;
     } else {
       const DWORD extra_code_1 = static_cast<DWORD>(stage);
       result = state_key.WriteValue(installer::kInstallerExtraCode1,
                                     extra_code_1);
@@ skipping 295 matching lines @@
   // Open the program and see if it references the expected file.
   base::File file;
   BY_HANDLE_FILE_INFORMATION info = {};
 
   return (OpenForInfo(path, &file) &&
           GetInfo(file, &info) &&
           info.dwVolumeSerialNumber == file_info_.dwVolumeSerialNumber &&
           info.nFileIndexHigh == file_info_.nFileIndexHigh &&
           info.nFileIndexLow == file_info_.nFileIndexLow);
 }