[M54 Merge] 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 232 matching lines @@
 }
 
 std::wstring GetChromeInstallRegistryPath() {
   std::wstring registry_path = L"Software\\";
   registry_path += GetChromeInstallSubDirectory();
   return registry_path;
 }
 
 bool GetCollectStatsConsentImpl(const std::wstring& exe_path) {
   bool enabled = true;
-  bool controlled_by_policy = ReportingIsEnforcedByPolicy(&enabled);
 
-  if (controlled_by_policy && !enabled)
-    return false;
+  if (ReportingIsEnforcedByPolicy(&enabled))
+    return enabled;
 
   bool system_install = IsSystemInstall(exe_path.c_str());
   std::wstring app_guid;
 
   if (IsSxSChrome(exe_path.c_str())) {
     app_guid = kAppGuidCanary;
   } else {
     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* metrics_is_enforced_by_policy) {
   DWORD value = 0;
 
   // First, try HKLM.
-  if (nt::QueryRegValueDWORD(nt::HKLM, kRegPathChromePolicy,
+  if (nt::QueryRegValueDWORD(nt::HKLM, nt::NONE, kRegPathChromePolicy,
                              kMetricsReportingEnabled, &value)) {
     *metrics_is_enforced_by_policy = (value != 0);
     return true;
   }
 
   // Second, try HKCU.
-  if (nt::QueryRegValueDWORD(nt::HKCU, kRegPathChromePolicy,
+  if (nt::QueryRegValueDWORD(nt::HKCU, nt::NONE, kRegPathChromePolicy,
                              kMetricsReportingEnabled, &value)) {
     *metrics_is_enforced_by_policy = (value != 0);
     return true;
   }
 
   return false;
 }
 
 void InitializeProcessType() {
   assert(g_process_type == ProcessType::UNINITIALIZED);
@@ skipping 155 matching lines @@
   if (IsSxSChrome(GetCurrentProcessExePath().c_str())) {
     *channel_name = L"canary";
   } else {
     std::wstring value;
     bool channel_available = false;
     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);
-      channel_available =
-          nt::QueryRegValueSZ(is_per_user_install ? nt::HKCU : nt::HKLM,
-                              full_key_path.c_str(), kRegApField, &value);
+      channel_available = 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);
-      channel_available =
-          nt::QueryRegValueSZ(is_per_user_install ? nt::HKCU : nt::HKLM,
-                              full_key_path.c_str(), kRegApField, &value);
+      channel_available = nt::QueryRegValueSZ(
+          is_per_user_install ? nt::HKCU : nt::HKLM, nt::WOW6432,
+          full_key_path.c_str(), kRegApField, &value);
     }
     if (channel_available) {
       static const wchar_t kChromeChannelBetaPattern[] = L"1?1-*";
       static const wchar_t kChromeChannelBetaX64Pattern[] = L"*x64-beta*";
       static const wchar_t kChromeChannelDevPattern[] = L"2?0-d*";
       static const wchar_t kChromeChannelDevX64Pattern[] = L"*x64-dev*";
 
       std::transform(value.begin(), value.end(), value.begin(), ::tolower);
 
       // Empty channel names or those containing "stable" should be reported as
@@ skipping 28 matching lines @@
       *channel_name = kChromeChannelUnknown;
     }
   }
 }
 
 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