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

chrome/installer/gcapi/gcapi.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.
 
 // NOTE: This code is a legacy utility API for partners to check whether
 //       Chrome can be installed and launched. Recent updates are being made
 //       to add new functionality. These updates use code from Chromium, the old
 //       coded against the win32 api directly. If you have an itch to shave a
 //       yak, feel free to re-write the old code too.
 
@@ skipping 185 matching lines @@
     }
 
     ::RegCloseKey(key);
   }
 
   return can_re_offer;
 }
 
 bool IsChromeInstalled(HKEY root_key) {
   RegKey key;
-  return key.Open(root_key, kChromeRegClientsKey, KEY_READ) == ERROR_SUCCESS &&
+  return key.Open(root_key,
+                  kChromeRegClientsKey,
+                  KEY_READ | KEY_WOW64_32KEY) == ERROR_SUCCESS &&
          key.HasValue(kChromeRegVersion);
 }
 
 // Returns true if the |subkey| in |root| has the kC1FKey entry set to 1.
 bool RegKeyHasC1F(HKEY root, const wchar_t* subkey) {
   RegKey key;
   DWORD value;
-  return key.Open(root, subkey, KEY_READ) == ERROR_SUCCESS &&
+  return key.Open(root, subkey, KEY_READ | KEY_WOW64_32KEY) == ERROR_SUCCESS &&
       key.ReadValueDW(kC1FKey, &value) == ERROR_SUCCESS &&
       value == static_cast<DWORD>(1);
 }
 
 bool IsC1FSent() {
   // The C1F RLZ key can either be in HKCU or in HKLM (the HKLM RLZ key is made
   // readable to all-users via rlz_lib::CreateMachineState()) and can either be
   // in sent or pending state. Return true if there is a match for any of these
   // 4 states.
   return RegKeyHasC1F(HKEY_CURRENT_USER, kC1FSentKey) ||
@@ skipping 44 matching lines @@
   return (check == TRUE);
 }
 
 bool VerifyHKLMAccess() {
   wchar_t str[] = L"test";
   bool result = false;
   DWORD disposition = 0;
   HKEY key = NULL;
 
   if (::RegCreateKeyEx(HKEY_LOCAL_MACHINE, kGCAPITempKey, 0, NULL,
-                       REG_OPTION_NON_VOLATILE, KEY_READ | KEY_WRITE, NULL,
+                       REG_OPTION_NON_VOLATILE,
+                       KEY_READ | KEY_WRITE | KEY_WOW64_32KEY, NULL,
                        &key, &disposition) == ERROR_SUCCESS) {
     if (::RegSetValueEx(key, str, 0, REG_SZ, (LPBYTE)str,
         (DWORD)lstrlen(str)) == ERROR_SUCCESS) {
       result = true;
       RegDeleteValue(key, str);
     }
 
     RegCloseKey(key);
 
     //  If we create the main key, delete the entire key.
@@ skipping 298 matching lines @@
 
 BOOL __stdcall LaunchGoogleChromeInBackground() {
   return LaunchGoogleChromeWithDimensions(-1, -1, -1, -1, true);
 }
 
 int __stdcall GoogleChromeDaysSinceLastRun() {
   int days_since_last_run = std::numeric_limits<int>::max();
 
   if (IsChromeInstalled(HKEY_LOCAL_MACHINE) ||
       IsChromeInstalled(HKEY_CURRENT_USER)) {
-    RegKey client_state(
-        HKEY_CURRENT_USER, kChromeRegClientStateKey, KEY_QUERY_VALUE);
+    RegKey client_state(HKEY_CURRENT_USER,
+                        kChromeRegClientStateKey,
+                        KEY_QUERY_VALUE | KEY_WOW64_32KEY);
     if (client_state.Valid()) {
       std::wstring last_run;
       int64 last_run_value = 0;
       if (client_state.ReadValue(google_update::kRegLastRunTimeField,
                                  &last_run) == ERROR_SUCCESS &&
           base::StringToInt64(last_run, &last_run_value)) {
         Time last_run_time = Time::FromInternalValue(last_run_value);
         TimeDelta difference = Time::NowFromSystemTime() - last_run_time;
 
         // We can end up with negative numbers here, given changes in system
@@ skipping 131 matching lines @@
       days_since_last_run < kRelaunchMinDaysDormant) {
     if (error_code)
       *error_code = RELAUNCH_ERROR_NOTDORMANT;
     return FALSE;
   }
 
   // e) a minimum period (6 months) must have passed since the previous
   // relaunch offer for the current user;
   RegKey key;
   DWORD min_relaunch_date;
-  if (key.Open(HKEY_CURRENT_USER, kChromeRegClientStateKey,
-               KEY_QUERY_VALUE) == ERROR_SUCCESS &&
+  if (key.Open(HKEY_CURRENT_USER,
+               kChromeRegClientStateKey,
+               KEY_QUERY_VALUE | KEY_WOW64_32KEY) == ERROR_SUCCESS &&
       key.ReadValueDW(kRelaunchAllowedAfterValue,
                       &min_relaunch_date) == ERROR_SUCCESS &&
       FormatDateOffsetByMonths(0) < min_relaunch_date) {
     if (error_code)
       *error_code = RELAUNCH_ERROR_ALREADY_RELAUNCHED;
     return FALSE;
   }
 
   return TRUE;
 }
 
 BOOL __stdcall SetRelaunchOffered(const wchar_t** partner_brandcode_list,
                                   int partner_brandcode_list_length,
                                   const wchar_t* relaunch_brandcode,
                                   int shell_mode,
                                   DWORD* error_code) {
   if (!CanOfferRelaunch(partner_brandcode_list, partner_brandcode_list_length,
                         shell_mode, error_code))
     return FALSE;
 
   // Store the relaunched brand code and the minimum date for relaunch (6 months
   // from now), and set the Omaha experiment label.
   RegKey key;
-  if (key.Create(HKEY_CURRENT_USER, kChromeRegClientStateKey,
-                 KEY_SET_VALUE) != ERROR_SUCCESS ||
+  if (key.Create(HKEY_CURRENT_USER,
+                 kChromeRegClientStateKey,
+                 KEY_SET_VALUE | KEY_WOW64_32KEY) != ERROR_SUCCESS ||
       key.WriteValue(kRelaunchBrandcodeValue,
                      relaunch_brandcode) != ERROR_SUCCESS ||
       key.WriteValue(kRelaunchAllowedAfterValue,
                      FormatDateOffsetByMonths(6)) != ERROR_SUCCESS ||
       !SetRelaunchExperimentLabels(relaunch_brandcode, shell_mode)) {
     if (error_code)
       *error_code = RELAUNCH_ERROR_RELAUNCH_FAILED;
     return FALSE;
   }
 
   return TRUE;
 }