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

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 37 matching lines @@
     GoogleUpdateSettings::AUTOMATIC_UPDATES;
 #else
     GoogleUpdateSettings::UPDATES_DISABLED;
 #endif
 
 namespace {
 
 bool ReadGoogleUpdateStrKey(const wchar_t* const name, std::wstring* value) {
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   std::wstring reg_path = dist->GetStateKey();
-  RegKey key(HKEY_CURRENT_USER, reg_path.c_str(), KEY_READ);
+  RegKey key(HKEY_CURRENT_USER, reg_path.c_str(), KEY_READ | KEY_WOW64_32KEY);
   if (key.ReadValue(name, value) != ERROR_SUCCESS) {
-    RegKey hklm_key(HKEY_LOCAL_MACHINE, reg_path.c_str(), KEY_READ);
+    RegKey hklm_key(HKEY_LOCAL_MACHINE, reg_path.c_str(),
+                    KEY_READ | KEY_WOW64_32KEY);
     return (hklm_key.ReadValue(name, value) == ERROR_SUCCESS);
   }
   return true;
 }
 
 // Update a state registry key |name| to be |value| for the given browser
 // |dist|.  If this is a |system_install|, then update the value under
 // HKLM (istead of HKCU for user-installs) using a group of keys (one
 // for each OS user) and also include the method to |aggregate| these
 // values when reporting.
@@ skipping 48 matching lines @@
       BrowserDistribution::GetSpecificDistribution(
           BrowserDistribution::CHROME_BINARIES);
   return
       WriteGoogleUpdateStrKeyInternal(multi_dist, false, name, value, NULL) &&
       result;
 }
 
 bool ClearGoogleUpdateStrKey(const wchar_t* const name) {
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   std::wstring reg_path = dist->GetStateKey();
-  RegKey key(HKEY_CURRENT_USER, reg_path.c_str(), KEY_READ | KEY_WRITE);
+  RegKey key(HKEY_CURRENT_USER, reg_path.c_str(),
+             KEY_READ | KEY_WRITE | KEY_WOW64_32KEY);
   std::wstring value;
   if (key.ReadValue(name, &value) != ERROR_SUCCESS)
     return false;
   return (key.WriteValue(name, L"") == ERROR_SUCCESS);
 }
 
 bool RemoveGoogleUpdateStrKey(const wchar_t* const name) {
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   std::wstring reg_path = dist->GetStateKey();
-  RegKey key(HKEY_CURRENT_USER, reg_path.c_str(), KEY_READ | KEY_WRITE);
+  RegKey key(HKEY_CURRENT_USER, reg_path.c_str(),
+             KEY_READ | KEY_WRITE | KEY_WOW64_32KEY);
   if (!key.HasValue(name))
     return true;
   return (key.DeleteValue(name) == ERROR_SUCCESS);
 }
 
 bool GetChromeChannelInternal(bool system_install,
                               bool add_multi_modifier,
                               base::string16* channel) {
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   if (dist->GetChromeChannel(channel)) {
     return true;
   }
 
   HKEY root_key = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   base::string16 reg_path = dist->GetStateKey();
-  RegKey key(root_key, reg_path.c_str(), KEY_READ);
+  RegKey key(root_key, reg_path.c_str(), KEY_READ | KEY_WOW64_32KEY);
 
   installer::ChannelInfo channel_info;
   if (!channel_info.Initialize(key)) {
     channel->assign(installer::kChromeChannelUnknown);
     return false;
   }
 
   if (!channel_info.GetChannelName(channel)) {
     channel->assign(installer::kChromeChannelUnknown);
   }
@@ skipping 261 matching lines @@
   DCHECK(archive_type != installer::UNKNOWN_ARCHIVE_TYPE ||
          install_return_code != 0);
   HKEY reg_root = (system_install) ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 
   RegKey key;
   installer::ChannelInfo channel_info;
   std::wstring reg_key(google_update::kRegPathClientState);
   reg_key.append(L"\\");
   reg_key.append(product_guid);
   LONG result = key.Open(reg_root, reg_key.c_str(),
-                         KEY_QUERY_VALUE | KEY_SET_VALUE);
+                         KEY_QUERY_VALUE | KEY_SET_VALUE | KEY_WOW64_32KEY);
   if (result == ERROR_SUCCESS)
     channel_info.Initialize(key);
   else if (result != ERROR_FILE_NOT_FOUND)
     LOG(ERROR) << "Failed to open " << reg_key << "; Error: " << result;
 
   if (UpdateGoogleUpdateApKey(archive_type, install_return_code,
                               &channel_info)) {
     // We have a modified channel_info value to write.
     // Create the app's ClientState key if it doesn't already exist.
     if (!key.Valid()) {
       result = key.Open(reg_root, google_update::kRegPathClientState,
-                        KEY_CREATE_SUB_KEY);
+                        KEY_CREATE_SUB_KEY | KEY_WOW64_32KEY);
       if (result == ERROR_SUCCESS)
-        result = key.CreateKey(product_guid.c_str(), KEY_SET_VALUE);
+        result = key.CreateKey(product_guid.c_str(),
+                               KEY_SET_VALUE | KEY_WOW64_32KEY);
 
       if (result != ERROR_SUCCESS) {
         LOG(ERROR) << "Failed to create " << reg_key << "; Error: " << result;
         return;
       }
     }
     if (!channel_info.Write(&key)) {
       LOG(ERROR) << "Failed to write to application's ClientState key "
                  << google_update::kRegApField << " = " << channel_info.value();
     }
@@ skipping 50 matching lines @@
                                   google_update::kRegProfilesSignedIn,
                                   base::Int64ToString16(profiles_signedin),
                                   L"sum()");
 }
 
 int GoogleUpdateSettings::DuplicateGoogleUpdateSystemClientKey() {
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   std::wstring reg_path = dist->GetStateKey();
 
   // Minimum access needed is to be able to write to this key.
-  RegKey reg_key(HKEY_LOCAL_MACHINE, reg_path.c_str(), KEY_SET_VALUE);
+  RegKey reg_key(HKEY_LOCAL_MACHINE, reg_path.c_str(),
+                 KEY_SET_VALUE | KEY_WOW64_32KEY);
   if (!reg_key.Valid())
     return 0;
 
   HANDLE target_handle = 0;
   if (!DuplicateHandle(GetCurrentProcess(), reg_key.Handle(),
                        GetCurrentProcess(), &target_handle, KEY_SET_VALUE,
                        TRUE, DUPLICATE_SAME_ACCESS)) {
     return 0;
   }
   return reinterpret_cast<int>(target_handle);
@@ skipping 12 matching lines @@
     const std::wstring& app_guid,
     bool* is_overridden) {
   bool found_override = false;
   UpdatePolicy update_policy = kDefaultUpdatePolicy;
 
 #if defined(GOOGLE_CHROME_BUILD)
   DCHECK(!app_guid.empty());
   RegKey policy_key;
 
   // Google Update Group Policy settings are always in HKLM.
+  // TODO(wfh): Check if policies should go into Wow6432Node or not.
   if (policy_key.Open(HKEY_LOCAL_MACHINE, kPoliciesKey, KEY_QUERY_VALUE) ==
           ERROR_SUCCESS) {
     DWORD value = 0;
     base::string16 app_update_override(kUpdateOverrideValuePrefix);
     app_update_override.append(app_guid);
     // First try to read and comprehend the app-specific override.
     found_override = (policy_key.ReadValueDW(app_update_override.c_str(),
                                              &value) == ERROR_SUCCESS &&
                       GetUpdatePolicyFromDword(value, &update_policy));
 
@@ skipping 131 matching lines @@
   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;
 
   if (key.Open(root_key,
                google_update::kRegPathGoogleUpdate,
-               KEY_QUERY_VALUE) == ERROR_SUCCESS &&
+               KEY_QUERY_VALUE | KEY_WOW64_32KEY) == ERROR_SUCCESS &&
       key.ReadValue(google_update::kRegGoogleUpdateVersion,
                     &version) == ERROR_SUCCESS) {
     return Version(base::UTF16ToUTF8(version));
   }
 
   return Version();
 }
 
 base::Time GoogleUpdateSettings::GetGoogleUpdateLastStartedAU(
     bool system_install) {
   const HKEY root_key = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   RegKey update_key;
 
   if (update_key.Open(root_key, google_update::kRegPathGoogleUpdate,
-                      KEY_QUERY_VALUE) == ERROR_SUCCESS) {
+                      KEY_QUERY_VALUE | KEY_WOW64_32KEY) == ERROR_SUCCESS) {
     DWORD last_start;
     if (update_key.ReadValueDW(google_update::kRegLastStartedAUField,
                                &last_start) == ERROR_SUCCESS) {
       return base::Time::FromTimeT(last_start);
     }
   }
 
   return base::Time();
 }
 
 base::Time GoogleUpdateSettings::GetGoogleUpdateLastChecked(
     bool system_install) {
   const HKEY root_key = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   RegKey update_key;
 
   if (update_key.Open(root_key, google_update::kRegPathGoogleUpdate,
-                      KEY_QUERY_VALUE) == ERROR_SUCCESS) {
+                      KEY_QUERY_VALUE | KEY_WOW64_32KEY) == ERROR_SUCCESS) {
     DWORD last_check;
     if (update_key.ReadValueDW(google_update::kRegLastCheckedField,
                                &last_check) == ERROR_SUCCESS) {
       return base::Time::FromTimeT(last_check);
     }
   }
 
   return base::Time();
 }
 
 bool GoogleUpdateSettings::GetUpdateDetailForApp(bool system_install,
                                                  const wchar_t* app_guid,
                                                  ProductData* data) {
   DCHECK(app_guid);
   DCHECK(data);
 
   bool product_found = false;
 
   const HKEY root_key = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   base::string16 clientstate_reg_path(google_update::kRegPathClientState);
   clientstate_reg_path.append(L"\\");
   clientstate_reg_path.append(app_guid);
 
   RegKey clientstate;
   if (clientstate.Open(root_key, clientstate_reg_path.c_str(),
-                       KEY_QUERY_VALUE) == ERROR_SUCCESS) {
+                       KEY_QUERY_VALUE | KEY_WOW64_32KEY) == ERROR_SUCCESS) {
     base::string16 version;
     DWORD dword_value;
     if ((clientstate.ReadValueDW(google_update::kRegLastCheckSuccessField,
                                  &dword_value) == ERROR_SUCCESS) &&
         (clientstate.ReadValue(google_update::kRegVersionField,
                                &version) == ERROR_SUCCESS)) {
       product_found = true;
       data->version = base::UTF16ToASCII(version);
       data->last_success = base::Time::FromTimeT(dword_value);
       data->last_result = 0;
@@ skipping 42 matching lines @@
   HKEY reg_root = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 
   // Use the browser distribution and install level to write to the correct
   // client state/app guid key.
   bool success = false;
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   if (dist->ShouldSetExperimentLabels()) {
     base::string16 client_state_path(
         system_install ? dist->GetStateMediumKey() : dist->GetStateKey());
     RegKey client_state(
-        reg_root, client_state_path.c_str(), KEY_SET_VALUE);
+        reg_root, client_state_path.c_str(), KEY_SET_VALUE | KEY_WOW64_32KEY);
     if (experiment_labels.empty()) {
       success = client_state.DeleteValue(google_update::kExperimentLabels)
           == ERROR_SUCCESS;
     } else {
       success = client_state.WriteValue(google_update::kExperimentLabels,
           experiment_labels.c_str()) == ERROR_SUCCESS;
     }
   }
 
   return success;
 }
 
 bool GoogleUpdateSettings::ReadExperimentLabels(
     bool system_install,
     base::string16* experiment_labels) {
   HKEY reg_root = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 
   // If this distribution does not set the experiment labels, don't bother
   // reading.
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   if (!dist->ShouldSetExperimentLabels())
     return false;
 
   base::string16 client_state_path(
       system_install ? dist->GetStateMediumKey() : dist->GetStateKey());
 
   RegKey client_state;
-  LONG result =
-      client_state.Open(reg_root, client_state_path.c_str(), KEY_QUERY_VALUE);
+  LONG result = client_state.Open(reg_root, client_state_path.c_str(),
+                                  KEY_QUERY_VALUE | KEY_WOW64_32KEY);
   if (result == ERROR_SUCCESS) {
     result = client_state.ReadValue(google_update::kExperimentLabels,
                                     experiment_labels);
   }
 
   // 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;
 }