Return a new error code for multi-install updates if Group Policy settings blocking...

chrome/installer/util/google_update_settings.cc

 // Copyright (c) 2011 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 "base/command_line.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time.h"
 #include "base/win/registry.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/channel_info.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/installer_state.h"
 #include "chrome/installer/util/product.h"
 
 using base::win::RegKey;
 using installer::InstallerState;
 
 namespace {
 
+const wchar_t kGoogleUpdatePoliciesKey[] =
+    L"SOFTWARE\\Policies\\Google\\Update";
+const wchar_t kGoogleUpdateUpdatePolicyValue[] = L"UpdateDefault";
+const wchar_t kGoogleUpdateUpdateOverrideValuePrefix[] = L"Update";
+const GoogleUpdateSettings::UpdatePolicy kGoogleUpdateDefaultUpdatePolicy =
+#if defined(GOOGLE_CHROME_BUILD)
+    GoogleUpdateSettings::AUTOMATIC_UPDATES;
+#else
+    GoogleUpdateSettings::UPDATES_DISABLED;
+#endif
+
 // An list of search results in increasing order of desirability.
 enum EulaSearchResult {
   NO_SETTING,
   FOUND_CLIENT_STATE,
   FOUND_OPPOSITE_SETTING,
   FOUND_SAME_SETTING
 };
 
 bool ReadGoogleUpdateStrKey(const wchar_t* const name, std::wstring* value) {
   // The registry functions below will end up going to disk.  Do this on another
@@ skipping 97 matching lines @@
   if (add_multi_modifier && channel_info.IsMultiInstall()) {
     if (!channel->empty()) {
       channel->append(1, L'-');
     }
     channel->append(1, L'm');
   }
 
   return true;
 }
 
+// Populates |update_policy| with the UpdatePolicy enum value corresponding to a
+// DWORD read from the registry and returns true if |value| is within range.
+// If |value| is out of range, returns false without modifying |update_policy|.
+bool GetUpdatePolicyFromDword(
+    const DWORD value,
+    GoogleUpdateSettings::UpdatePolicy* update_policy) {
+  COMPILE_ASSERT(GoogleUpdateSettings::UPDATES_DISABLED == 0,
+                 dont_reorder_GoogleUpdateSettings_UpdatePolicy);
+  COMPILE_ASSERT(GoogleUpdateSettings::AUTOMATIC_UPDATES == 1,
+                 dont_reorder_GoogleUpdateSettings_UpdatePolicy);
+  COMPILE_ASSERT(GoogleUpdateSettings::MANUAL_UPDATES_ONLY == 2,
+                 dont_reorder_GoogleUpdateSettings_UpdatePolicy);

[robertshield, 2011/06/08 16:06:52]

Can these asserts go near the enum declaration? I dislike having them in the
middle of function definitions.

[grt (UTC plus 2), 2011/06/08 16:31:32]

Done.

+  switch (value) {
+    case GoogleUpdateSettings::UPDATES_DISABLED:
+    case GoogleUpdateSettings::AUTOMATIC_UPDATES:
+    case GoogleUpdateSettings::MANUAL_UPDATES_ONLY:
+      *update_policy = static_cast<GoogleUpdateSettings::UpdatePolicy>(value);
+      return true;
+    default:
+      LOG(WARNING) << "Unexpected update policy override value: " << value;
+  }
+  return false;
+}
+
 }  // namespace
 
 // Older versions of Chrome unconditionally read from HKCU\...\ClientState\...
 // and then HKLM\...\ClientState\....  This means that system-level Chrome
 // never checked ClientStateMedium (which has priority according to Google
 // Update) and gave preference to a value in HKCU (which was never checked by
 // Google Update).  From now on, Chrome follows Google Update's policy.
 bool GoogleUpdateSettings::GetCollectStatsConsent() {
   // Determine whether this is a system-level or a user-level install.
   bool system_install = false;
@@ skipping 323 matching lines @@
 }
 
 bool GoogleUpdateSettings::IsOrganicFirstRun(const std::wstring& brand) {
   // Used for testing, to force search engine selector to appear.
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kOrganicInstall))
     return true;
 
   return (StartsWith(brand, L"GG", true) || StartsWith(brand, L"EU", true));
 }
+
+GoogleUpdateSettings::UpdatePolicy GoogleUpdateSettings::GetAppUpdatePolicy(
+    const std::wstring& app_guid,
+    bool* is_overridden) {
+  bool found_override = false;
+  UpdatePolicy update_policy = kGoogleUpdateDefaultUpdatePolicy;
+
+#if defined(GOOGLE_CHROME_BUILD)
+  DCHECK(!app_guid.empty());
+  RegKey policy_key;
+
+  // Google Update Group Policy settings are always in HKLM.
+  if (policy_key.Open(HKEY_LOCAL_MACHINE, kGoogleUpdatePoliciesKey,
+                      KEY_QUERY_VALUE) == ERROR_SUCCESS) {
+    static const size_t kPrefixLen =
+        arraysize(kGoogleUpdateUpdateOverrideValuePrefix) - 1;
+    DWORD value;
+    std::wstring app_update_override;
+    app_update_override.reserve(kPrefixLen + app_guid.size());
+    app_update_override.append(kGoogleUpdateUpdateOverrideValuePrefix,
+                               kPrefixLen);
+    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));
+
+    // Failing that, try to read and comprehend the default override.
+    if (!found_override &&
+        policy_key.ReadValueDW(kGoogleUpdateUpdatePolicyValue,
+                               &value) == ERROR_SUCCESS) {
+      GetUpdatePolicyFromDword(value, &update_policy);
+    }
+  }
+#endif  // defined(GOOGLE_CHROME_BUILD)
+
+  if (is_overridden != NULL)
+    *is_overridden = found_override;
+
+  return update_policy;
+}