Use install_static::GetAppGuid in place of BrowserDistribution and AppRegistrationData.

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 <stdint.h>
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "base/win/registry.h"
 #include "base/win/win_util.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/install_static/install_util.h"
 #include "chrome/installer/util/app_registration_data.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/channel_info.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/installation_state.h"
 #include "chrome/installer/util/product.h"
 
 using base::win::RegKey;
 using installer::InstallationState;
 
@@ skipping 510 matching lines @@
     int handle, const base::string16& key, const base::string16& value) {
   HKEY reg_key = reinterpret_cast<HKEY>(
       reinterpret_cast<void*>(static_cast<uintptr_t>(handle)));
   DWORD size = static_cast<DWORD>(value.size()) * sizeof(wchar_t);
   LSTATUS status = RegSetValueEx(reg_key, key.c_str(), 0, REG_SZ,
       reinterpret_cast<const BYTE*>(value.c_str()), size);
   return status == ERROR_SUCCESS;
 }
 
 GoogleUpdateSettings::UpdatePolicy GoogleUpdateSettings::GetAppUpdatePolicy(
-    const base::string16& app_guid,
+    base::StringPiece16 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);
+    app_guid.AppendToString(&app_update_override);
     // 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(kUpdatePolicyValue, &value) == ERROR_SUCCESS) {
       GetUpdatePolicyFromDword(value, &update_policy);
     }
@@ skipping 15 matching lines @@
   RegKey policy_key;
   DWORD value = 0;
   if (policy_key.Open(HKEY_LOCAL_MACHINE, kPoliciesKey,
                       KEY_QUERY_VALUE) == ERROR_SUCCESS &&
       policy_key.ReadValueDW(kCheckPeriodOverrideMinutes,
                              &value) == ERROR_SUCCESS &&
       (value == 0 || value > kCheckPeriodOverrideMinutesMax)) {
     return false;
   }
 
-  BrowserDistribution* dist = BrowserDistribution::GetDistribution();
-  UpdatePolicy app_policy = GetAppUpdatePolicy(dist->GetAppGuid(), nullptr);
+  UpdatePolicy app_policy =
+      GetAppUpdatePolicy(install_static::GetAppGuid(), nullptr);
   return app_policy == AUTOMATIC_UPDATES || app_policy == AUTO_UPDATES_ONLY;
 #else  // defined(GOOGLE_CHROME_BUILD)
   // Chromium does not auto update.
   return false;
 #endif  // !defined(GOOGLE_CHROME_BUILD)
 }
 
 // static
 bool GoogleUpdateSettings::ReenableAutoupdates() {
 #if defined(GOOGLE_CHROME_BUILD)
   int needs_reset_count = 0;
   int did_reset_count = 0;
 
   UpdatePolicy update_policy = kDefaultUpdatePolicy;
   RegKey policy_key;
   if (policy_key.Open(HKEY_LOCAL_MACHINE, kPoliciesKey,
                       KEY_SET_VALUE | KEY_QUERY_VALUE) == ERROR_SUCCESS) {
     // Set to true while app-specific overrides are present that allow automatic
     // updates. When this is the case, the defaults are irrelevant and don't
     // need to be checked or reset.
     bool automatic_updates_allowed_by_overrides = true;
     DWORD value = 0;
 
     // First check the app-specific override value and reset that if needed.
     // Note that this intentionally sets the override to AUTOMATIC_UPDATES even
     // if it was previously AUTO_UPDATES_ONLY. The thinking is that
     // AUTOMATIC_UPDATES is marginally more likely to let a user update and this
     // code is only called when a stuck user asks for updates.
     base::string16 app_update_override(kUpdateOverrideValuePrefix);
-    app_update_override.append(
-        BrowserDistribution::GetDistribution()->GetAppGuid());
+    app_update_override.append(install_static::GetAppGuid());
     if (policy_key.ReadValueDW(app_update_override.c_str(), &value) !=
         ERROR_SUCCESS) {
       automatic_updates_allowed_by_overrides = false;
     } else if (!GetUpdatePolicyFromDword(value, &update_policy) ||
                update_policy != GoogleUpdateSettings::AUTOMATIC_UPDATES) {
       automatic_updates_allowed_by_overrides = false;
       ++needs_reset_count;
       if (policy_key.WriteValue(
               app_update_override.c_str(),
               static_cast<DWORD>(GoogleUpdateSettings::AUTOMATIC_UPDATES)) ==
@@ skipping 55 matching lines @@
     for (auto ch : value) {
       if (!base::IsAsciiAlpha(ch))
         return base::string16();
     }
     return value;
   }
   return base::string16();
 }
 
 void GoogleUpdateSettings::RecordChromeUpdatePolicyHistograms() {
-  const base::string16 app_guid =
-      BrowserDistribution::GetDistribution()->GetAppGuid();
-
   bool is_overridden = false;
-  const UpdatePolicy update_policy = GetAppUpdatePolicy(app_guid,
-                                                        &is_overridden);
+  const UpdatePolicy update_policy =
+      GetAppUpdatePolicy(install_static::GetAppGuid(), &is_overridden);
   UMA_HISTOGRAM_BOOLEAN("GoogleUpdate.UpdatePolicyIsOverridden", is_overridden);
   UMA_HISTOGRAM_ENUMERATION("GoogleUpdate.EffectivePolicy", update_policy,
                             UPDATE_POLICIES_COUNT);
 }
 
 base::string16 GoogleUpdateSettings::GetUninstallCommandLine(
     bool system_install) {
   const HKEY root_key = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   base::string16 cmd_line;
   RegKey update_key;
@@ skipping 112 matching lines @@
 
 bool GoogleUpdateSettings::GetUpdateDetailForGoogleUpdate(bool system_install,
                                                           ProductData* data) {
   return GetUpdateDetailForApp(system_install,
                                google_update::kGoogleUpdateUpgradeCode,
                                data);
 }
 
 bool GoogleUpdateSettings::GetUpdateDetail(bool system_install,
                                            ProductData* data) {
-  BrowserDistribution* dist = BrowserDistribution::GetDistribution();
-  return GetUpdateDetailForApp(system_install,
-                               dist->GetAppGuid().c_str(),
+  return GetUpdateDetailForApp(system_install, install_static::GetAppGuid(),
                                data);
 }
 
 bool GoogleUpdateSettings::SetExperimentLabels(
     bool system_install,
     const base::string16& experiment_labels) {
   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.
@@ skipping 43 matching lines @@
   }
 
   // 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;
 }