Installer refactoring: using string16 instead of wstring for GoogleUpdateSettings.

chrome/installer/util/google_update_settings.h

 // 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.
 
 #ifndef CHROME_INSTALLER_UTIL_GOOGLE_UPDATE_SETTINGS_H_
 #define CHROME_INSTALLER_UTIL_GOOGLE_UPDATE_SETTINGS_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 98 matching lines @@
   // Returns false if the value could not be stored.
   static bool SetLastRunTime();
 
   // Removes the storage used by SetLastRunTime() and SetLastRunTime(). Returns
   // false if the operation failed. Returns true if the storage was freed or
   // if it never existed in the first place.
   static bool RemoveLastRunTime();
 
   // Returns in |browser| the browser used to download chrome as recorded
   // Google Update. Returns false if the information is not available.
-  static bool GetBrowser(std::wstring* browser);
+  static bool GetBrowser(base::string16* browser);
 
   // Returns in |language| the language selected by the user when downloading
   // chrome. This information is collected by the web server used to download
   // the chrome installer. Returns false if the information is not available.
-  static bool GetLanguage(std::wstring* language);
+  static bool GetLanguage(base::string16* language);
 
   // Returns in |brand| the RLZ brand code or distribution tag that has been
   // assigned to a partner. Returns false if the information is not available.
   //
   // NOTE: This function is Windows only.  If the code you are writing is not
   // specifically for Windows, prefer calling google_brand::GetBrand().
-  static bool GetBrand(std::wstring* brand);
+  static bool GetBrand(base::string16* brand);
 
   // Returns in |brand| the RLZ reactivation brand code or distribution tag
   // that has been assigned to a partner for reactivating a dormant chrome
   // install. Returns false if the information is not available.
   //
   // NOTE: This function is Windows only.  If the code you are writing is not
   // specifically for Windows, prefer calling
   // google_brand::GetReactivationBrand().
-  static bool GetReactivationBrand(std::wstring* brand);
+  static bool GetReactivationBrand(base::string16* brand);
 
   // Returns in |client| the google_update client field, which is currently
   // used to track experiments. Returns false if the entry does not exist.
-  static bool GetClient(std::wstring* client);
+  static bool GetClient(base::string16* client);
 
   // Sets the google_update client field. Unlike GetClient() this is set only
   // for the current user. Returns false if the operation failed.
-  static bool SetClient(const std::wstring& client);
+  static bool SetClient(const base::string16& client);
 
   // Returns in 'client' the RLZ referral available for some distribution
   // partners. This value does not exist for most chrome or chromium installs.
-  static bool GetReferral(std::wstring* referral);
+  static bool GetReferral(base::string16* referral);
 
   // Overwrites the current value of the referral with an empty string. Returns
   // true if this operation succeeded.
   static bool ClearReferral();
 
   // Set did_run "dr" in the client state value for app specified by
   // |app_reg_data|. This is used to measure active users. Returns false if
   // registry write fails.
   static bool UpdateDidRunStateForApp(const AppRegistrationData& app_reg_data,
                                       bool did_run);
@@ skipping 22 matching lines @@
   // it is not present already, so that Google Update server next time will send
   // full installer to update Chrome on the local machine
   // - If we are currently running full installer, we remove this magic
   // string (if it is present) regardless of whether installer failed or not.
   // There is no fall-back for full installer :)
   // - Unconditionally remove "-multifail" since we haven't crashed.
   // |state_key| should be obtained via InstallerState::state_key().
   static void UpdateInstallStatus(bool system_install,
                                   installer::ArchiveType archive_type,
                                   int install_return_code,
-                                  const std::wstring& product_guid);
+                                  const base::string16& product_guid);
 
   // This method updates the value for Google Update "ap" key for Chrome
   // based on whether we are doing incremental install (or not) and whether
   // the install succeeded.
   // - If install worked, remove the magic string (if present).
   // - If incremental installer failed, append a magic string (if
   //   not present already).
   // - If full installer failed, still remove this magic
   //   string (if it is present already).
   //
@@ skipping 16 matching lines @@
   // However, when we are about to switch contexts from system to user, we can
   // duplicate the handle to the registry key and pass it (through handle
   // inheritance) to the newly created child process that is launched as the
   // user, allowing the child process to write to the key, with the
   // WriteGoogleUpdateSystemClientKey function below.
   static int DuplicateGoogleUpdateSystemClientKey();
 
   // Takes a |handle| to a registry key and writes |value| string into the
   // specified |key|. See DuplicateGoogleUpdateSystemClientKey for details.
   static bool WriteGoogleUpdateSystemClientKey(int handle,
-                                               const std::wstring& key,
-                                               const std::wstring& value);
+                                               const base::string16& key,
+                                               const base::string16& value);
 
   // Returns the effective update policy for |app_guid| as dictated by
   // Group Policy settings.  |is_overridden|, if non-NULL, is populated with
   // true if an app-specific policy override is in force, or false otherwise.
-  static UpdatePolicy GetAppUpdatePolicy(const std::wstring& app_guid,
+  static UpdatePolicy GetAppUpdatePolicy(const base::string16& app_guid,
                                          bool* is_overridden);
 
   // Returns true if the app indicated by |app_guid| should be updated
   // automatically by Google Update based on current autoupdate settings. This
   // is distinct from GetApUpdatePolicy which checks only a subset of things
   // that can cause an app not to update.
   static bool AreAutoupdatesEnabled(const base::string16& app_guid);
 
   // Attempts to reenable auto-updates for |app_guid| by removing
   // any group policy settings that would block updates from occurring. This is
@@ skipping 57 matching lines @@
   // this will do nothing to |experiment_labels|. This will return true if the
   // label did not exist, or was successfully read.
   static bool ReadExperimentLabels(bool system_install,
                                    base::string16* experiment_labels);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(GoogleUpdateSettings);
 };
 
 #endif  // CHROME_INSTALLER_UTIL_GOOGLE_UPDATE_SETTINGS_H_