Merge the installer, installer_util and setup_util namespaces into a single i...

chrome/installer/util/google_chrome_distribution.cc

 // Copyright (c) 2010 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.
 //
 // This file defines specific implementation of BrowserDistribution class for
 // Google Chrome.
 
 #include "chrome/installer/util/google_chrome_distribution.h"
 
 #include <windows.h>
@@ skipping 122 matching lines @@
 // If system_level_toast is true, appends --system-level-toast.
 // If handle to experiment result key was given at startup, re-add it.
 // Does not wait for the process to terminate.
 bool RelaunchSetup(const std::string& flag, int value,
                    bool system_level_toast) {
   CommandLine new_cmd_line(CommandLine::ForCurrentProcess()->GetProgram());
   new_cmd_line.AppendSwitchASCII(flag, base::IntToString(value));
 
   // Re-add the system level toast flag.
   if (system_level_toast) {
-    new_cmd_line.AppendSwitch(installer_util::switches::kSystemLevelToast);
+    new_cmd_line.AppendSwitch(installer::switches::kSystemLevelToast);
 
     // Re-add the toast result key. We need to do this because Setup running as
     // system passes the key to Setup running as user, but that child process
     // does not perform the actual toasting, it launches another Setup (as user)
     // to do so. That is the process that needs the key.
     const CommandLine& current_cmd_line = *CommandLine::ForCurrentProcess();
-    std::string key(installer_util::switches::kToastResultsKey);
+    std::string key(installer::switches::kToastResultsKey);
     std::string toast_key = current_cmd_line.GetSwitchValueASCII(key);
     if (!toast_key.empty()) {
       new_cmd_line.AppendSwitchASCII(key, toast_key);
 
       // Use handle inheritance to make sure the duplicated toast results key
       // gets inherited by the child process.
       return base::LaunchAppWithHandleInheritance(
           new_cmd_line.command_line_string(), false, false, NULL);
     }
   }
@@ skipping 57 matching lines @@
 // Remote Desktop sessions do not count as interactive sessions; running this
 // method as a user logged in via remote desktop will do nothing.
 bool RelaunchSetupAsConsoleUser(const std::string& flag) {
   FilePath setup_exe = CommandLine::ForCurrentProcess()->GetProgram();
   CommandLine cmd_line(setup_exe);
   cmd_line.AppendSwitch(flag);
 
   // Get the Google Update results key, and pass it on the command line to
   // the child process.
   int key = GoogleUpdateSettings::DuplicateGoogleUpdateSystemClientKey();
-  cmd_line.AppendSwitchASCII(installer_util::switches::kToastResultsKey,
+  cmd_line.AppendSwitchASCII(installer::switches::kToastResultsKey,
                              base::IntToString(key));
 
   if (base::win::GetVersion() > base::win::VERSION_XP) {
     // Make sure that in Vista and Above we have the proper DACLs so
     // the interactive user can launch it.
     if (!FixDACLsForExecute(setup_exe.ToWStringHack().c_str()))
       NOTREACHED();
   }
 
   DWORD console_id = ::WTSGetActiveConsoleSessionId();
   if (console_id == 0xFFFFFFFF)
     return false;
   HANDLE user_token;
   if (!::WTSQueryUserToken(console_id, &user_token))
     return false;
   // Note: Handle inheritance must be true in order for the child process to be
   // able to use the duplicated handle above (Google Update results).
   bool launched = base::LaunchAppAsUser(user_token,
                                         cmd_line.command_line_string(),
                                         false, NULL, true, true);
   ::CloseHandle(user_token);
   return launched;
 }
 
 }  // namespace
 
 GoogleChromeDistribution::GoogleChromeDistribution(
-    const installer_util::MasterPreferences& prefs)
+    const installer::MasterPreferences& prefs)
         : BrowserDistribution(prefs), product_guid_(kChromeGuid) {
 }
 
 // The functions below are not used by the 64-bit Windows binary -
 // see the comment in google_chrome_distribution_dummy.cc
 #ifndef _WIN64
 bool GoogleChromeDistribution::BuildUninstallMetricsString(
     DictionaryValue* uninstall_metrics_dict, std::wstring* metrics) {
   DCHECK(NULL != metrics);
   bool has_values = false;
@@ skipping 36 matching lines @@
   // Make sure that the user wants us reporting metrics. If not, don't
   // add our uninstall metrics.
   bool metrics_reporting_enabled = false;
   if (!root.GetBoolean(prefs::kMetricsReportingEnabled,
                        &metrics_reporting_enabled) ||
       !metrics_reporting_enabled) {
     return false;
   }
 
   DictionaryValue* uninstall_metrics_dict;
-  if (!root.HasKey(installer_util::kUninstallMetricsName) ||
-      !root.GetDictionary(installer_util::kUninstallMetricsName,
+  if (!root.HasKey(installer::kUninstallMetricsName) ||
+      !root.GetDictionary(installer::kUninstallMetricsName,
                           &uninstall_metrics_dict)) {
     return false;
   }
 
   if (!BuildUninstallMetricsString(uninstall_metrics_dict,
                                    uninstall_metrics_string)) {
     return false;
   }
 
   return true;
@@ skipping 52 matching lines @@
   // allows us to escape from the Job object so the applet will close.
   installer::WMIProcess::Launch(command, &pid);
 }
 
 std::wstring GoogleChromeDistribution::GetAppGuid() {
   return product_guid();
 }
 
 std::wstring GoogleChromeDistribution::GetApplicationName() {
   const std::wstring& product_name =
-      installer_util::GetLocalizedString(IDS_PRODUCT_NAME_BASE);
+      installer::GetLocalizedString(IDS_PRODUCT_NAME_BASE);
   return product_name;
 }
 
 std::wstring GoogleChromeDistribution::GetAlternateApplicationName() {
   const std::wstring& alt_product_name =
-      installer_util::GetLocalizedString(IDS_OEM_MAIN_SHORTCUT_NAME_BASE);
+      installer::GetLocalizedString(IDS_OEM_MAIN_SHORTCUT_NAME_BASE);
   return alt_product_name;
 }
 
 std::wstring GoogleChromeDistribution::GetBrowserAppId() {
   return kBrowserAppId;
 }
 
 std::wstring GoogleChromeDistribution::GetInstallSubDir() {
-  std::wstring sub_dir(installer_util::kGoogleChromeInstallSubDir1);
+  std::wstring sub_dir(installer::kGoogleChromeInstallSubDir1);
   sub_dir.append(L"\\");
-  sub_dir.append(installer_util::kGoogleChromeInstallSubDir2);
+  sub_dir.append(installer::kGoogleChromeInstallSubDir2);
   return sub_dir;
 }
 
 std::wstring GoogleChromeDistribution::GetPublisherName() {
   const std::wstring& publisher_name =
-      installer_util::GetLocalizedString(IDS_ABOUT_VERSION_COMPANY_NAME_BASE);
+      installer::GetLocalizedString(IDS_ABOUT_VERSION_COMPANY_NAME_BASE);
   return publisher_name;
 }
 
 std::wstring GoogleChromeDistribution::GetAppDescription() {
   const std::wstring& app_description =
-      installer_util::GetLocalizedString(IDS_SHORTCUT_TOOLTIP_BASE);
+      installer::GetLocalizedString(IDS_SHORTCUT_TOOLTIP_BASE);
   return app_description;
 }
 
 std::string GoogleChromeDistribution::GetSafeBrowsingName() {
   return "googlechrome";
 }
 
 std::wstring GoogleChromeDistribution::GetStateKey() {
   std::wstring key(google_update::kRegPathClientState);
   key.append(L"\\");
@@ skipping 43 matching lines @@
   client_state_key.ReadValue(google_update::kRegApField, &ap_value);
   result.append(google_update::kRegApField);
   result.append(L"=");
   result.append(ap_value);
 
   return result;
 }
 
 std::wstring GoogleChromeDistribution::GetUninstallLinkName() {
   const std::wstring& link_name =
-      installer_util::GetLocalizedString(IDS_UNINSTALL_CHROME_BASE);
+      installer::GetLocalizedString(IDS_UNINSTALL_CHROME_BASE);
   return link_name;
 }
 
 std::wstring GoogleChromeDistribution::GetUninstallRegPath() {
   return L"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\"
          L"Google Chrome";
 }
 
 std::wstring GoogleChromeDistribution::GetVersionKey() {
   std::wstring key(google_update::kRegPathClients);
   key.append(L"\\");
   key.append(product_guid());
   return key;
 }
 
 // This method checks if we need to change "ap" key in Google Update to try
 // full installer as fall back method in case incremental installer fails.
 // - If incremental installer fails we append a magic string ("-full"), if
 // 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 :)
 void GoogleChromeDistribution::UpdateDiffInstallStatus(bool system_install,
-    bool incremental_install, installer_util::InstallStatus install_status) {
+    bool incremental_install, installer::InstallStatus install_status) {
   GoogleUpdateSettings::UpdateDiffInstallStatus(system_install,
       incremental_install, GetInstallReturnCode(install_status),
       product_guid().c_str());
 }
 
 // The functions below are not used by the 64-bit Windows binary -
 // see the comment in google_chrome_distribution_dummy.cc
 #ifndef _WIN64
 // A helper function that writes to HKLM if the handle was passed through the
 // command line, but HKCU otherwise. |experiment_group| is the value to write
 // and |last_write| is used when writing to HKLM to determine whether to close
 // the handle when done.
 void SetClient(std::wstring experiment_group, bool last_write) {
   static int reg_key_handle = -1;
   if (reg_key_handle == -1) {
     // If a specific Toast Results key handle (presumably to our HKLM key) was
     // passed in to the command line (such as for system level installs), we use
     // it. Otherwise, we write to the key under HKCU.
     const CommandLine& cmd_line = *CommandLine::ForCurrentProcess();
-    if (cmd_line.HasSwitch(installer_util::switches::kToastResultsKey)) {
+    if (cmd_line.HasSwitch(installer::switches::kToastResultsKey)) {
       // Get the handle to the key under HKLM.
       base::StringToInt(cmd_line.GetSwitchValueASCII(
-          installer_util::switches::kToastResultsKey).c_str(),
+          installer::switches::kToastResultsKey).c_str(),
           &reg_key_handle);
     } else {
       reg_key_handle = 0;
     }
   }
 
   if (reg_key_handle) {
     // Use it to write the experiment results.
     GoogleUpdateSettings::WriteGoogleUpdateSystemClientKey(
         reg_key_handle, google_update::kRegClientField, experiment_group);
     if (last_write)
       CloseHandle((HANDLE) reg_key_handle);
   } else {
     // Write to HKCU.
     GoogleUpdateSettings::SetClient(experiment_group);
   }
 }
 
 // Currently we only have one experiment: the inactive user toast. Which only
 // applies for users doing upgrades.
 //
 // There are three scenarios when this function is called:
 // 1- Is a per-user-install and it updated: perform the experiment
 // 2- Is a system-install and it updated : relaunch as the interactive user
 // 3- It has been re-launched from the #2 case. In this case we enter
 //    this function with |system_install| true and a REENTRY_SYS_UPDATE status.
 void GoogleChromeDistribution::LaunchUserExperiment(
-    installer_util::InstallStatus status, const installer::Version& version,
+    installer::InstallStatus status, const installer::Version& version,
     const installer::Product& installation, bool system_level) {
   if (system_level) {
-    if (installer_util::NEW_VERSION_UPDATED == status) {
+    if (installer::NEW_VERSION_UPDATED == status) {
       // We need to relaunch as the interactive user.
-      RelaunchSetupAsConsoleUser(installer_util::switches::kSystemLevelToast);
+      RelaunchSetupAsConsoleUser(installer::switches::kSystemLevelToast);
       return;
     }
   } else {
-    if ((installer_util::NEW_VERSION_UPDATED != status) &&
-        (installer_util::REENTRY_SYS_UPDATE != status)) {
+    if ((installer::NEW_VERSION_UPDATED != status) &&
+        (installer::REENTRY_SYS_UPDATE != status)) {
       // We are not updating or in re-launch. Exit.
       return;
     }
   }
 
   // This ends up being processed by ShowTryChromeDialog to show different
   // experiments.  Only run the experiment in en-US.
   int flavor = 0;
   std::wstring language;
   if (GoogleUpdateSettings::GetLanguage(&language) && (language == L"en-US"))
@@ skipping 31 matching lines @@
       return;
     }
   }
 
   VLOG(1) << "User drafted for toast experiment " << flavor;
   SetClient(GetExperimentGroup(kToastExpBaseGroup, flavor), false);
   // User level: The experiment needs to be performed in a different process
   // because google_update expects the upgrade process to be quick and nimble.
   // System level: We have already been relaunched, so we don't need to be
   // quick, but we relaunch to follow the exact same codepath.
-  RelaunchSetup(installer_util::switches::kInactiveUserToast, flavor,
+  RelaunchSetup(installer::switches::kInactiveUserToast, flavor,
                 system_level);
 }
 
 // User qualifies for the experiment. Launch chrome with --try-chrome=flavor.
 void GoogleChromeDistribution::InactiveUserToastExperiment(int flavor,
     const installer::Product& installation) {
   bool has_welcome_url = (flavor == 0);
   // Possibly add a url to launch depending on the experiment flavor.
   CommandLine options(CommandLine::NO_PROGRAM);
   options.AppendSwitchNative(switches::kTryChromeAgain,
@@ skipping 32 matching lines @@
   // Write to the |client| key for the last time.
   SetClient(GetExperimentGroup(outcome, flavor), true);
 
   if (outcome != kToastExpUninstallGroup)
     return;
 
   // The user wants to uninstall. This is a best effort operation. Note that
   // we waited for chrome to exit so the uninstall would not detect chrome
   // running.
   bool system_level_toast = CommandLine::ForCurrentProcess()->HasSwitch(
-      installer_util::switches::kSystemLevelToast);
+      installer::switches::kSystemLevelToast);
 
   std::wstring cmd(InstallUtil::GetChromeUninstallCmd(
       system_level_toast, this));
 
   base::LaunchApp(cmd, false, false, NULL);
 }
 #endif