[chrome_elf] NTRegistry - added wow64 redirection support.

chrome/install_static/install_util.cc

 // Copyright 2014 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/install_static/install_util.h"
 
 #include <windows.h>
 #include <assert.h>
 #include <algorithm>
 #include <iostream>
@@ skipping 252 matching lines @@
     app_guid = IsMultiInstall(system_install) ? kAppGuidGoogleBinaries
                                               : kAppGuidGoogleChrome;
   }
 
   DWORD out_value = 0;
 
   // If system_install, first try kRegPathClientStateMedium.
   std::wstring full_key_path(kRegPathClientStateMedium);
   full_key_path.append(1, L'\\');
   full_key_path.append(app_guid);
-  if (system_install && nt::QueryRegValueDWORD(nt::HKLM, full_key_path.c_str(),
-                                               kRegValueUsageStats, &out_value))
+  if (system_install &&
+      nt::QueryRegValueDWORD(nt::HKLM, nt::WOW6432, full_key_path.c_str(),
+                             kRegValueUsageStats, &out_value))
     return (out_value == 1);
 
   // Second, try kRegPathClientState.
   full_key_path = kRegPathClientState;
   full_key_path.append(1, L'\\');
   full_key_path.append(app_guid);
   return (nt::QueryRegValueDWORD((system_install ? nt::HKLM : nt::HKCU),
-                                 full_key_path.c_str(), kRegValueUsageStats,
-                                 &out_value) &&
+                                 nt::WOW6432, full_key_path.c_str(),
+                                 kRegValueUsageStats, &out_value) &&
           out_value == 1);
 }
 
 // Returns true if the |source| string matches the |pattern|. The pattern
 // may contain wildcards like '?' which matches one character or a '*'
 // which matches 0 or more characters.
 // Please note that pattern matches the whole string. If you want to find
 // something in the middle of the string then you need to specify the pattern
 // as '*xyz*'.
 // |source_index| is the index of the current character being matched in
@@ skipping 109 matching lines @@
   return false;
 }
 
 bool IsMultiInstall(bool is_system_install) {
   std::wstring args;
 
   std::wstring full_key_path(kRegPathClientState);
   full_key_path.append(1, L'\\');
   full_key_path.append(kAppGuidGoogleChrome);
   if (!nt::QueryRegValueSZ((is_system_install ? nt::HKLM : nt::HKCU),
-                           full_key_path.c_str(), kUninstallArgumentsField,
-                           &args))
+                           nt::WOW6432, full_key_path.c_str(),
+                           kUninstallArgumentsField, &args))
     return false;
 
   return (args.find(L"--multi-install") != std::wstring::npos);
 }
 
 bool GetCollectStatsConsent() {
   return GetCollectStatsConsentImpl(GetCurrentProcessExePath());
 }
 
 bool GetCollectStatsConsentForTesting(const std::wstring& exe_path) {
   return GetCollectStatsConsentImpl(exe_path);
 }
 
 bool GetCollectStatsInSample() {
   std::wstring registry_path = GetChromeInstallRegistryPath();
 
   DWORD out_value = 0;
-  if (!nt::QueryRegValueDWORD(nt::HKCU, registry_path.c_str(),
+  if (!nt::QueryRegValueDWORD(nt::HKCU, nt::WOW6432, registry_path.c_str(),
                               kRegValueChromeStatsSample, &out_value)) {
     // If reading the value failed, treat it as though sampling isn't in effect,
     // implicitly meaning this install is in the sample.
     return true;
   }
   return out_value == 1;
 }
 
 bool SetCollectStatsInSample(bool in_sample) {
   std::wstring registry_path = GetChromeInstallRegistryPath();
 
   HANDLE key_handle = INVALID_HANDLE_VALUE;
-  if (!nt::CreateRegKey(nt::HKCU, registry_path.c_str(), KEY_SET_VALUE,
-                        &key_handle)) {
+  if (!nt::CreateRegKey(nt::HKCU, registry_path.c_str(),
+                        KEY_SET_VALUE | KEY_WOW64_32KEY, &key_handle)) {
     nt::CloseRegKey(key_handle);
     return false;
   }
 
   return nt::SetRegValueDWORD(key_handle, kRegValueChromeStatsSample,
                               in_sample ? 1 : 0);
 }
 
 bool ReportingIsEnforcedByPolicy(bool* crash_reporting_enabled) {
   DWORD value = 0;
 
   // First, try HKLM.
-  if (nt::QueryRegValueDWORD(nt::HKLM, kRegPathChromePolicy,
+  if (nt::QueryRegValueDWORD(nt::HKLM, nt::NONE, kRegPathChromePolicy,
                              kMetricsReportingEnabled, &value)) {
     *crash_reporting_enabled = (value != 0);
     return true;
   }
 
   // Second, try HKCU.
-  if (nt::QueryRegValueDWORD(nt::HKCU, kRegPathChromePolicy,
+  if (nt::QueryRegValueDWORD(nt::HKCU, nt::NONE, kRegPathChromePolicy,
                              kMetricsReportingEnabled, &value)) {
     *crash_reporting_enabled = (value != 0);
     return true;
   }
 
   return false;
 }
 
 void InitializeProcessType() {
   assert(g_process_type == ProcessType::UNINITIALIZED);
@@ skipping 159 matching lines @@
   // but that the "ap" value therein cannot be read due to some reason *other*
   // than it not being present. This should be exceedingly rare. For
   // simplicity's sake, use an empty |value| in case of any error whatsoever
   // here.
   std::wstring value;
   bool is_multi_install = IsMultiInstall(!is_per_user_install);
   if (is_multi_install) {
     std::wstring full_key_path(kRegPathClientState);
     full_key_path.append(1, L'\\');
     full_key_path.append(kAppGuidGoogleBinaries);
-    nt::QueryRegValueSZ(is_per_user_install ? nt::HKCU : nt::HKLM,
+    nt::QueryRegValueSZ(is_per_user_install ? nt::HKCU : nt::HKLM, nt::WOW6432,
                         full_key_path.c_str(), kRegApField, &value);
   } else {
     std::wstring full_key_path(kRegPathClientState);
     full_key_path.append(1, L'\\');
     full_key_path.append(kAppGuidGoogleChrome);
-    nt::QueryRegValueSZ(is_per_user_install ? nt::HKCU : nt::HKLM,
+    nt::QueryRegValueSZ(is_per_user_install ? nt::HKCU : nt::HKLM, nt::WOW6432,
                         full_key_path.c_str(), kRegApField, &value);
   }
 
   static constexpr wchar_t kChromeChannelBetaPattern[] = L"1?1-*";
   static constexpr wchar_t kChromeChannelBetaX64Pattern[] = L"*x64-beta*";
   static constexpr wchar_t kChromeChannelDevPattern[] = L"2?0-d*";
   static constexpr wchar_t kChromeChannelDevX64Pattern[] = L"*x64-dev*";
 
   std::transform(value.begin(), value.end(), value.begin(), ::tolower);
 
@@ skipping 25 matching lines @@
       channel_name->push_back(L'-');
     channel_name->push_back(L'm');
   }
 }
 
 std::string GetGoogleUpdateVersion() {
   // TODO(ananta)
   // Consider whether Chromium should connect to Google update to manage
   // updates. Should this be returning an empty string for Chromium builds?.
   std::wstring update_version;
-  if (nt::QueryRegValueSZ(nt::AUTO, kRegPathGoogleUpdate,
+  if (nt::QueryRegValueSZ(nt::AUTO, nt::WOW6432, kRegPathGoogleUpdate,
                           kRegGoogleUpdateVersion, &update_version))
     return UTF16ToUTF8(update_version);
 
   return std::string();
 }
 
 std::wstring GetChromeInstallSubDirectory() {
 #if defined(GOOGLE_CHROME_BUILD)
   std::wstring result = kGoogleChromeInstallSubDir1;
   result += L"\\";
@@ skipping 177 matching lines @@
     switch_value_end_offset = command_line_copy.length();
 
   std::string switch_value = command_line_copy.substr(
       switch_value_start_offset,
       switch_value_end_offset - (switch_offset + switch_token.length()));
   TrimT<std::string>(&switch_value);
   return switch_value;
 }
 
 }  // namespace install_static