Installer refactoring: using string16 instead of wstring for GoogleUpdateSettings.

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>

[gab, 2014/07/07 18:47:49]

rm include already in header.

[huangs, 2014/07/07 19:29:24]

Done.

 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.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"
@@ skipping 27 matching lines @@
 const GoogleUpdateSettings::UpdatePolicy
 GoogleUpdateSettings::kDefaultUpdatePolicy =
 #if defined(GOOGLE_CHROME_BUILD)
     GoogleUpdateSettings::AUTOMATIC_UPDATES;
 #else
     GoogleUpdateSettings::UPDATES_DISABLED;
 #endif
 
 namespace {
 
-bool ReadGoogleUpdateStrKey(const wchar_t* const name, std::wstring* value) {
+bool ReadGoogleUpdateStrKey(const wchar_t* const name, base::string16* value) {
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
-  std::wstring reg_path = dist->GetStateKey();
+  base::string16 reg_path = dist->GetStateKey();
   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 | KEY_WOW64_32KEY);
     return (hklm_key.ReadValue(name, value) == ERROR_SUCCESS);
   }
   return true;
 }
 
 // Updates a registry key |name| to be |value| for the given |app_reg_data|.
 // 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.
 bool WriteGoogleUpdateStrKeyInternal(const AppRegistrationData& app_reg_data,
                                      bool system_install,
                                      const wchar_t* const name,
-                                     // presubmit: allow wstring
-                                     const std::wstring& value,
+                                     const base::string16& value,
                                      const wchar_t* const aggregate) {
   const REGSAM kAccess = KEY_SET_VALUE | KEY_WOW64_32KEY;
   if (system_install) {
     DCHECK(aggregate);
     // Machine installs require each OS user to write a unique key under a
     // named key in HKLM as well as an "aggregation" function that describes
     // how the values of multiple users are to be combined.
-    std::wstring uniquename;  // presubmit: allow wstring
+    base::string16 uniquename;
     if (!base::win::GetUserSidString(&uniquename)) {
       NOTREACHED();
       return false;
     }
 
     base::string16 reg_path(app_reg_data.GetStateMediumKey());
     reg_path.append(L"\\");
     reg_path.append(name);
     RegKey key(HKEY_LOCAL_MACHINE, reg_path.c_str(), kAccess);
     key.WriteValue(google_update::kRegAggregateMethod, aggregate);
     return (key.WriteValue(uniquename.c_str(), value.c_str()) == ERROR_SUCCESS);
   } else {
     // User installs are easy: just write the values to HKCU tree.
     RegKey key(HKEY_CURRENT_USER, app_reg_data.GetStateKey().c_str(), kAccess);
     return (key.WriteValue(name, value.c_str()) == ERROR_SUCCESS);
   }
 }
 
 bool WriteGoogleUpdateStrKey(const wchar_t* const name,
-                             const std::wstring& value) {
+                             const base::string16& value) {
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   return WriteGoogleUpdateStrKeyInternal(
       dist->GetAppRegistrationData(), false, name, value, NULL);
 }
 
 bool ClearGoogleUpdateStrKey(const wchar_t* const name) {
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
-  std::wstring reg_path = dist->GetStateKey();
+  base::string16 reg_path = dist->GetStateKey();
   RegKey key(HKEY_CURRENT_USER,
              reg_path.c_str(),
              KEY_READ | KEY_WRITE | KEY_WOW64_32KEY);
-  std::wstring value;
+  base::string16 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();
+  base::string16 reg_path = dist->GetStateKey();
   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,
@@ skipping 139 matching lines @@
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
 
   // Consent applies to all products in a multi-install package.
   if (InstallUtil::IsMultiInstall(dist, system_install)) {
     dist = BrowserDistribution::GetSpecificDistribution(
         BrowserDistribution::CHROME_BINARIES);
   }
 
   // Write to ClientStateMedium for system-level; ClientState otherwise.
   HKEY root_key = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
-  std::wstring reg_path =
+  base::string16 reg_path =
       system_install ? dist->GetStateMediumKey() : dist->GetStateKey();
   RegKey key;
   LONG result = key.Create(
       root_key, reg_path.c_str(), KEY_SET_VALUE | KEY_WOW64_32KEY);
   if (result != ERROR_SUCCESS) {
     LOG(ERROR) << "Failed opening key " << reg_path << " to set "
                << google_update::kRegUsageStatsField << "; result: " << result;
   } else {
     result = key.WriteValue(google_update::kRegUsageStatsField, value);
     LOG_IF(ERROR, result != ERROR_SUCCESS) << "Failed setting "
         << google_update::kRegUsageStatsField << " in key " << reg_path
         << "; result: " << result;
   }
   return (result == ERROR_SUCCESS);
 }
 
 bool GoogleUpdateSettings::GetMetricsId(std::string* metrics_id) {
-  std::wstring metrics_id_w;
+  base::string16 metrics_id_w;
   bool rv = ReadGoogleUpdateStrKey(google_update::kRegMetricsId, &metrics_id_w);
   *metrics_id = base::WideToUTF8(metrics_id_w);
   return rv;
 }
 
 bool GoogleUpdateSettings::SetMetricsId(const std::string& metrics_id) {
-  std::wstring metrics_id_w = base::UTF8ToWide(metrics_id);
+  base::string16 metrics_id_w = base::UTF8ToWide(metrics_id);
   return WriteGoogleUpdateStrKey(google_update::kRegMetricsId, metrics_id_w);
 }
 
 // EULA consent is only relevant for system-level installs.
 bool GoogleUpdateSettings::SetEULAConsent(
     const InstallationState& machine_state,
     BrowserDistribution* dist,
     bool consented) {
   DCHECK(dist);
   const DWORD eula_accepted = consented ? 1 : 0;
   const REGSAM kAccess = KEY_SET_VALUE | KEY_WOW64_32KEY;
-  std::wstring reg_path = dist->GetStateMediumKey();
+  base::string16 reg_path = dist->GetStateMediumKey();
   bool succeeded = true;
   RegKey key;
 
   // Write the consent value into the product's ClientStateMedium key.
   if (key.Create(HKEY_LOCAL_MACHINE, reg_path.c_str(),
                  kAccess) != ERROR_SUCCESS ||
       key.WriteValue(google_update::kRegEULAAceptedField,
                      eula_accepted) != ERROR_SUCCESS) {
     succeeded = false;
   }
@@ skipping 12 matching lines @@
         key.WriteValue(google_update::kRegEULAAceptedField,
                        eula_accepted) != ERROR_SUCCESS) {
         succeeded = false;
     }
   }
 
   return succeeded;
 }
 
 int GoogleUpdateSettings::GetLastRunTime() {
-  std::wstring time_s;
+  base::string16 time_s;
   if (!ReadGoogleUpdateStrKey(google_update::kRegLastRunTimeField, &time_s))
     return -1;
   int64 time_i;
   if (!base::StringToInt64(time_s, &time_i))
     return -1;
   base::TimeDelta td =
       base::Time::NowFromSystemTime() - base::Time::FromInternalValue(time_i);
   return td.InDays();
 }
 
 bool GoogleUpdateSettings::SetLastRunTime() {
   int64 time = base::Time::NowFromSystemTime().ToInternalValue();
   return WriteGoogleUpdateStrKey(google_update::kRegLastRunTimeField,
                                  base::Int64ToString16(time));
 }
 
 bool GoogleUpdateSettings::RemoveLastRunTime() {
   return RemoveGoogleUpdateStrKey(google_update::kRegLastRunTimeField);
 }
 
-bool GoogleUpdateSettings::GetBrowser(std::wstring* browser) {
+bool GoogleUpdateSettings::GetBrowser(base::string16* browser) {
   return ReadGoogleUpdateStrKey(google_update::kRegBrowserField, browser);
 }
 
-bool GoogleUpdateSettings::GetLanguage(std::wstring* language) {
+bool GoogleUpdateSettings::GetLanguage(base::string16* language) {
   return ReadGoogleUpdateStrKey(google_update::kRegLangField, language);
 }
 
-bool GoogleUpdateSettings::GetBrand(std::wstring* brand) {
+bool GoogleUpdateSettings::GetBrand(base::string16* brand) {
   return ReadGoogleUpdateStrKey(google_update::kRegRLZBrandField, brand);
 }
 
-bool GoogleUpdateSettings::GetReactivationBrand(std::wstring* brand) {
+bool GoogleUpdateSettings::GetReactivationBrand(base::string16* brand) {
   return ReadGoogleUpdateStrKey(google_update::kRegRLZReactivationBrandField,
                                 brand);
 }
 
-bool GoogleUpdateSettings::GetClient(std::wstring* client) {
+bool GoogleUpdateSettings::GetClient(base::string16* client) {
   return ReadGoogleUpdateStrKey(google_update::kRegClientField, client);
 }
 
-bool GoogleUpdateSettings::SetClient(const std::wstring& client) {
+bool GoogleUpdateSettings::SetClient(const base::string16& client) {
   return WriteGoogleUpdateStrKey(google_update::kRegClientField, client);
 }
 
-bool GoogleUpdateSettings::GetReferral(std::wstring* referral) {
+bool GoogleUpdateSettings::GetReferral(base::string16* referral) {
   return ReadGoogleUpdateStrKey(google_update::kRegReferralField, referral);
 }
 
 bool GoogleUpdateSettings::ClearReferral() {
   return ClearGoogleUpdateStrKey(google_update::kRegReferralField);
 }
 
 bool GoogleUpdateSettings::UpdateDidRunStateForApp(
     const AppRegistrationData& app_reg_data,
     bool did_run) {
@@ skipping 21 matching lines @@
 }
 
 bool GoogleUpdateSettings::GetChromeChannelAndModifiers(
     bool system_install,
     base::string16* channel) {
   return GetChromeChannelInternal(system_install, true, channel);
 }
 
 void GoogleUpdateSettings::UpdateInstallStatus(bool system_install,
     installer::ArchiveType archive_type, int install_return_code,
-    const std::wstring& product_guid) {
+    const base::string16& product_guid) {
   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);
+  base::string16 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_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;
 
@@ skipping 70 matching lines @@
                                   L"sum()");
   WriteGoogleUpdateStrKeyInternal(dist->GetAppRegistrationData(),
                                   system_install,
                                   google_update::kRegProfilesSignedIn,
                                   base::Int64ToString16(profiles_signedin),
                                   L"sum()");
 }
 
 int GoogleUpdateSettings::DuplicateGoogleUpdateSystemClientKey() {
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
-  std::wstring reg_path = dist->GetStateKey();
+  base::string16 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 | 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);
 }
 
 bool GoogleUpdateSettings::WriteGoogleUpdateSystemClientKey(
-    int handle, const std::wstring& key, const std::wstring& value) {
+    int handle, const base::string16& key, const base::string16& value) {
   HKEY reg_key = reinterpret_cast<HKEY>(reinterpret_cast<void*>(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 std::wstring& app_guid,
+    const base::string16& 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.
@@ skipping 308 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;
 }