Pulling user experiment code from BrowserDistribution to a new class.

chrome/installer/util/user_experiment.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright 2013 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>
-#include <msi.h>
+
+#include "chrome/installer/util/user_experiment.h"
+
 #include <sddl.h>
 #include <wtsapi32.h>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/file_path.h"
-#include "base/json/json_file_value_serializer.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/rand_util.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
-#include "base/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
-#include "base/win/registry.h"
+#include "base/version.h"
 #include "base/win/windows_version.h"
 #include "chrome/common/attrition_experiments.h"
 #include "chrome/common/chrome_result_codes.h"
 #include "chrome/common/chrome_switches.h"
-#include "chrome/common/net/test_server_locations.h"
-#include "chrome/common/pref_names.h"
-#include "chrome/installer/util/channel_info.h"
+#include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/google_update_settings.h"
-#include "chrome/installer/util/helper.h"
 #include "chrome/installer/util/install_util.h"
-#include "chrome/installer/util/l10n_string_util.h"
 #include "chrome/installer/util/product.h"
-#include "chrome/installer/util/util_constants.h"
-#include "chrome/installer/util/wmi.h"
 #include "content/public/common/result_codes.h"
 
-#include "installer_util_strings.h"  // NOLINT
-
 #pragma comment(lib, "wtsapi32.lib")
 
+namespace installer {
+
 namespace {
 
 const wchar_t kChromeGuid[] = L"{8A69D345-D564-463c-AFF1-A69D9E530F96}";
 const wchar_t kBrowserAppId[] = L"Chrome";
 const wchar_t kCommandExecuteImplUuid[] =
     L"{5C65F4B0-3651-4514-B207-D10CB699B14B}";
 
 // The following strings are the possible outcomes of the toast experiment
 // as recorded in the |client| field.
 const wchar_t kToastExpControlGroup[] =        L"01";
 const wchar_t kToastExpCancelGroup[] =         L"02";
 const wchar_t kToastExpUninstallGroup[] =      L"04";
 const wchar_t kToastExpTriesOkGroup[] =        L"18";
 const wchar_t kToastExpTriesErrorGroup[] =     L"28";
 const wchar_t kToastActiveGroup[] =            L"40";
 const wchar_t kToastUDDirFailure[] =           L"40";
 const wchar_t kToastExpBaseGroup[] =           L"80";
 
 // Substitute the locale parameter in uninstall URL with whatever
 // Google Update tells us is the locale. In case we fail to find
 // the locale, we use US English.
 string16 LocalizeUrl(const wchar_t* url) {

[huangs, 2013/02/21 23:41:36]

This routine is from google_chrome_distribution.cc (which also needs it).  I'm
thinking about moving this to GoogleUpdateSettings.

[grt (UTC plus 2), 2013/02/22 16:47:55]

I think InstallUtil is a better place for it.

   string16 language;
   if (!GoogleUpdateSettings::GetLanguage(&language))
     language = L"en-US";  // Default to US English.
   return ReplaceStringPlaceholders(url, language.c_str(), NULL);
 }
 
-string16 GetUninstallSurveyUrl() {
-  const wchar_t kSurveyUrl[] = L"http://www.google.com/support/chrome/bin/"
-                               L"request.py?hl=$1&contact_type=uninstall";
-  return LocalizeUrl(kSurveyUrl);
-}
-
 string16 GetWelcomeBackUrl() {
   const wchar_t kWelcomeUrl[] = L"http://www.google.com/chrome/intl/$1/"
                                 L"welcomeback-new.html";
   return LocalizeUrl(kWelcomeUrl);
 }
 
 // Converts FILETIME to hours. FILETIME times are absolute times in
 // 100 nanosecond units. For example 5:30 pm of June 15, 2009 is 3580464.
 int FileTimeToHours(const FILETIME& time) {
   const ULONGLONG k100sNanoSecsToHours = 10000000LL * 60 * 60;
@@ skipping 183 matching lines @@
   options.as_user = user_token;
   options.inherit_handles = true;
   options.empty_desktop_name = true;
   VLOG(1) << __FUNCTION__ << " launching " << cmd_line.GetCommandLineString();
   bool launched = base::LaunchProcess(cmd_line, options, NULL);
   ::CloseHandle(user_token);
   VLOG(1) << __FUNCTION__ << "   result: " << launched;
   return launched;
 }
 
-}  // namespace
-
-GoogleChromeDistribution::GoogleChromeDistribution()
-    : BrowserDistribution(CHROME_BROWSER),
-      product_guid_(kChromeGuid) {
-}
-
-bool GoogleChromeDistribution::BuildUninstallMetricsString(
-    const DictionaryValue* uninstall_metrics_dict, string16* metrics) {
-  DCHECK(NULL != metrics);
-  bool has_values = false;
-
-  for (DictionaryValue::Iterator iter(*uninstall_metrics_dict); !iter.IsAtEnd();
-       iter.Advance()) {
-    has_values = true;
-    metrics->append(L"&");
-    metrics->append(UTF8ToWide(iter.key()));
-    metrics->append(L"=");
-
-    std::string value;
-    iter.value().GetAsString(&value);
-    metrics->append(UTF8ToWide(value));
-  }
-
-  return has_values;
-}
-
-bool GoogleChromeDistribution::ExtractUninstallMetricsFromFile(
-    const base::FilePath& file_path,
-    string16* uninstall_metrics_string) {
-  JSONFileValueSerializer json_serializer(file_path);
-
-  std::string json_error_string;
-  scoped_ptr<Value> root(json_serializer.Deserialize(NULL, NULL));
-  if (!root.get())
-    return false;
-
-  // Preferences should always have a dictionary root.
-  if (!root->IsType(Value::TYPE_DICTIONARY))
-    return false;
-
-  return ExtractUninstallMetrics(*static_cast<DictionaryValue*>(root.get()),
-                                 uninstall_metrics_string);
-}
-
-bool GoogleChromeDistribution::ExtractUninstallMetrics(
-    const DictionaryValue& root,
-    string16* uninstall_metrics_string) {
-  // 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;
-  }
-
-  const DictionaryValue* uninstall_metrics_dict = NULL;
-  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;
-}
-
-void GoogleChromeDistribution::DoPostUninstallOperations(
-    const Version& version,
-    const base::FilePath& local_data_path,
-    const string16& distribution_data) {
-  // Send the Chrome version and OS version as params to the form.
-  // It would be nice to send the locale, too, but I don't see an
-  // easy way to get that in the existing code. It's something we
-  // can add later, if needed.
-  // We depend on installed_version.GetString() not having spaces or other
-  // characters that need escaping: 0.2.13.4. Should that change, we will
-  // need to escape the string before using it in a URL.
-  const string16 kVersionParam = L"crversion";
-  const string16 kOSParam = L"os";
-  base::win::OSInfo::VersionNumber version_number =
-      base::win::OSInfo::GetInstance()->version_number();
-  string16 os_version = base::StringPrintf(L"%d.%d.%d",
-      version_number.major, version_number.minor, version_number.build);
-
-  base::FilePath iexplore;
-  if (!PathService::Get(base::DIR_PROGRAM_FILES, &iexplore))
-    return;
-
-  iexplore = iexplore.AppendASCII("Internet Explorer");
-  iexplore = iexplore.AppendASCII("iexplore.exe");
-
-  string16 command = iexplore.value() + L" " + GetUninstallSurveyUrl() +
-      L"&" + kVersionParam + L"=" + UTF8ToWide(version.GetString()) + L"&" +
-      kOSParam + L"=" + os_version;
-
-  string16 uninstall_metrics;
-  if (ExtractUninstallMetricsFromFile(local_data_path, &uninstall_metrics)) {
-    // The user has opted into anonymous usage data collection, so append
-    // metrics and distribution data.
-    command += uninstall_metrics;
-    if (!distribution_data.empty()) {
-      command += L"&";
-      command += distribution_data;
-    }
-  }
-
-  int pid = 0;
-  // The reason we use WMI to launch the process is because the uninstall
-  // process runs inside a Job object controlled by the shell. As long as there
-  // are processes running, the shell will not close the uninstall applet. WMI
-  // allows us to escape from the Job object so the applet will close.
-  installer::WMIProcess::Launch(command, &pid);
-}
-
-string16 GoogleChromeDistribution::GetActiveSetupGuid() {
-  return product_guid();
-}
-
-string16 GoogleChromeDistribution::GetAppGuid() {
-  return product_guid();
-}
-
-string16 GoogleChromeDistribution::GetBaseAppName() {
-  // I'd really like to return L ## PRODUCT_FULLNAME_STRING; but that's no good
-  // since it'd be "Chromium" in a non-Chrome build, which isn't at all what I
-  // want.  Sigh.
-  return L"Google Chrome";
-}
-
-string16 GoogleChromeDistribution::GetAppShortCutName() {
-  const string16& app_shortcut_name =
-      installer::GetLocalizedString(IDS_PRODUCT_NAME_BASE);
-  return app_shortcut_name;
-}
-
-string16 GoogleChromeDistribution::GetAlternateApplicationName() {
-  const string16& alt_product_name =
-      installer::GetLocalizedString(IDS_OEM_MAIN_SHORTCUT_NAME_BASE);
-  return alt_product_name;
-}
-
-string16 GoogleChromeDistribution::GetBaseAppId() {
-  return kBrowserAppId;
-}
-
-string16 GoogleChromeDistribution::GetInstallSubDir() {
-  string16 sub_dir(installer::kGoogleChromeInstallSubDir1);
-  sub_dir.append(L"\\");
-  sub_dir.append(installer::kGoogleChromeInstallSubDir2);
-  return sub_dir;
-}
-
-string16 GoogleChromeDistribution::GetPublisherName() {
-  const string16& publisher_name =
-      installer::GetLocalizedString(IDS_ABOUT_VERSION_COMPANY_NAME_BASE);
-  return publisher_name;
-}
-
-string16 GoogleChromeDistribution::GetAppDescription() {
-  const string16& app_description =
-      installer::GetLocalizedString(IDS_SHORTCUT_TOOLTIP_BASE);
-  return app_description;
-}
-
-std::string GoogleChromeDistribution::GetSafeBrowsingName() {
-  return "googlechrome";
-}
-
-string16 GoogleChromeDistribution::GetStateKey() {
-  string16 key(google_update::kRegPathClientState);
-  key.append(L"\\");
-  key.append(product_guid());
-  return key;
-}
-
-string16 GoogleChromeDistribution::GetStateMediumKey() {
-  string16 key(google_update::kRegPathClientStateMedium);
-  key.append(L"\\");
-  key.append(product_guid());
-  return key;
-}
-
-string16 GoogleChromeDistribution::GetStatsServerURL() {
-  return L"https://clients4.google.com/firefox/metrics/collect";
-}
-
-std::string GoogleChromeDistribution::GetNetworkStatsServer() const {
-  return chrome_common_net::kEchoTestServerLocation;
-}
-
-std::string GoogleChromeDistribution::GetHttpPipeliningTestServer() const {
-  return chrome_common_net::kPipelineTestServerBaseUrl;
-}
-
-string16 GoogleChromeDistribution::GetDistributionData(HKEY root_key) {
-  string16 sub_key(google_update::kRegPathClientState);
-  sub_key.append(L"\\");
-  sub_key.append(product_guid());
-
-  base::win::RegKey client_state_key(root_key, sub_key.c_str(), KEY_READ);
-  string16 result;
-  string16 brand_value;
-  if (client_state_key.ReadValue(google_update::kRegRLZBrandField,
-                                 &brand_value) == ERROR_SUCCESS) {
-    result = google_update::kRegRLZBrandField;
-    result.append(L"=");
-    result.append(brand_value);
-    result.append(L"&");
-  }
-
-  string16 client_value;
-  if (client_state_key.ReadValue(google_update::kRegClientField,
-                                 &client_value) == ERROR_SUCCESS) {
-    result.append(google_update::kRegClientField);
-    result.append(L"=");
-    result.append(client_value);
-    result.append(L"&");
-  }
-
-  string16 ap_value;
-  // If we fail to read the ap key, send up "&ap=" anyway to indicate
-  // that this was probably a stable channel release.
-  client_state_key.ReadValue(google_update::kRegApField, &ap_value);
-  result.append(google_update::kRegApField);
-  result.append(L"=");
-  result.append(ap_value);
-
-  return result;
-}
-
-string16 GoogleChromeDistribution::GetUninstallLinkName() {
-  const string16& link_name =
-      installer::GetLocalizedString(IDS_UNINSTALL_CHROME_BASE);
-  return link_name;
-}
-
-string16 GoogleChromeDistribution::GetUninstallRegPath() {
-  return L"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\"
-         L"Google Chrome";
-}
-
-string16 GoogleChromeDistribution::GetVersionKey() {
-  string16 key(google_update::kRegPathClients);
-  key.append(L"\\");
-  key.append(product_guid());
-  return key;
-}
-
-string16 GoogleChromeDistribution::GetIconFilename() {
-  return installer::kChromeExe;
-}
-
-bool GoogleChromeDistribution::GetCommandExecuteImplClsid(
-    string16* handler_class_uuid) {
-  if (handler_class_uuid)
-    *handler_class_uuid = kCommandExecuteImplUuid;
-  return true;
-}
-
-bool GoogleChromeDistribution::AppHostIsSupported() {
-  return true;
-}
-
-// 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::UpdateInstallStatus(bool system_install,
-    installer::ArchiveType archive_type,
-    installer::InstallStatus install_status) {
-  GoogleUpdateSettings::UpdateInstallStatus(system_install,
-      archive_type, InstallUtil::GetInstallReturnCode(install_status),
-      product_guid());
-}
-
 // 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(const string16& 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.
@@ skipping 13 matching lines @@
     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);
   }
 }
 
-bool GoogleChromeDistribution::GetExperimentDetails(
-    UserExperiment* experiment, int flavor) {
+}  // namespace
+
+UserExperiment::UserExperiment() {}
+
+// static
+bool UserExperiment::CreateExperimentDetails(
+    UserExperiment::ExperimentDetails* experiment,
+    int flavor) {
   struct FlavorDetails {
     int heading_id;
     int flags;
   };
   // Maximum number of experiment flavors we support.
   static const int kMax = 4;
   // This struct determines which experiment flavors we show for each locale and
   // brand.
   //
   // Plugin infobar experiment:
   // The experiment in 2011 used PIxx codes.
   //
   // Inactive user toast experiment:
   // The experiment in Dec 2009 used TGxx and THxx.
   // The experiment in Feb 2010 used TKxx and TLxx.
   // The experiment in Apr 2010 used TMxx and TNxx.
   // The experiment in Oct 2010 used TVxx TWxx TXxx TYxx.
   // The experiment in Feb 2011 used SJxx SKxx SLxx SMxx.
   // The experiment in Mar 2012 used ZAxx ZBxx ZCxx.
   // The experiment in Jan 2013 uses DAxx.
   using namespace attrition_experiments;
 
-  static const struct UserExperimentDetails {
+  static const struct UserExperimentSpecs {
     const wchar_t* locale;  // Locale to show this experiment for (* for all).
     const wchar_t* brands;  // Brand codes show this experiment for (* for all).
     int control_group;      // Size of the control group, in percentages.
     const wchar_t* prefix;  // The two letter experiment code. The second letter
                             // will be incremented with the flavor.
     FlavorDetails flavors[kMax];
   } kExperiments[] = {
     // The first match from top to bottom is used so this list should be ordered
     // most-specific rule first.
     { L"*", L"GGRV",  // All locales, GGRV is enterprise.
@@ skipping 34 matching lines @@
 
     std::vector<string16> brand_codes;
     base::SplitString(kExperiments[i].brands, L',', &brand_codes);
     if (brand_codes.empty())
       return false;
     for (std::vector<string16>::iterator it = brand_codes.begin();
          it != brand_codes.end(); ++it) {
       if (*it != brand && *it != L"*")
         continue;
       // We have found our match.
-      const UserExperimentDetails& match = kExperiments[i];
+      const UserExperimentSpecs& match = kExperiments[i];
       // Find out how many flavors we have. Zero means no experiment.
       int num_flavors = 0;
       while (match.flavors[num_flavors].heading_id) { ++num_flavors; }
       if (!num_flavors)
         return false;
 
       if (flavor < 0)
         flavor = base::RandInt(0, num_flavors - 1);
       experiment->flavor = flavor;
       experiment->heading = match.flavors[flavor].heading_id;
       experiment->control_group = match.control_group;
       const wchar_t prefix[] = { match.prefix[0], match.prefix[1] + flavor, 0 };
       experiment->prefix = prefix;
       experiment->flags = match.flavors[flavor].flags;
       return true;
     }
   }
 
   return false;
 }
 
 // Currently we only have one experiment: the inactive user toast. Which only
 // applies for users doing upgrades.
 
-//
+// static
 // 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(
-    const base::FilePath& setup_path, installer::InstallStatus status,
-    const Version& version, const installer::Product& product,
-    bool system_level) {
+void UserExperiment::LaunchUserExperiment(const base::FilePath& setup_path,
+                                          installer::InstallStatus status,
+                                          const Version& version,
+                                          const installer::Product& product,
+                                          bool system_level) {
   VLOG(1) << "LaunchUserExperiment status: " << status << " product: "
           << product.distribution()->GetAppShortCutName()
           << " system_level: " << system_level;
 
   if (system_level) {
     if (installer::NEW_VERSION_UPDATED == status) {
       // We need to relaunch as the interactive user.
       LaunchSetupAsConsoleUser(setup_path, product,
                                installer::switches::kSystemLevelToast);
       return;
     }
   } else {
     if ((installer::NEW_VERSION_UPDATED != status) &&
         (installer::REENTRY_SYS_UPDATE != status)) {
       // We are not updating or in re-launch. Exit.
       return;
     }
   }
 
   // The |flavor| value ends up being processed by TryChromeDialogView to show
   // different experiments.
-  UserExperiment experiment;
-  if (!GetExperimentDetails(&experiment, -1)) {
+  ExperimentDetails experiment;
+  if (!CreateExperimentDetails(&experiment, -1)) {
     VLOG(1) << "Failed to get experiment details.";
     return;
   }
   int flavor = experiment.flavor;
   string16 base_group = experiment.prefix;
 
   string16 brand;
   if (GoogleUpdateSettings::GetBrand(&brand) && (brand == L"CHXX")) {
     // Testing only: the user automatically qualifies for the experiment.
     VLOG(1) << "Experiment qualification bypass";
@@ skipping 53 matching lines @@
   // System level: We have already been relaunched, so we don't need to be
   // quick, but we relaunch to follow the exact same codepath.
   CommandLine cmd_line(setup_path);
   cmd_line.AppendSwitchASCII(installer::switches::kInactiveUserToast,
                              base::IntToString(flavor));
   cmd_line.AppendSwitchASCII(installer::switches::kExperimentGroup,
                              WideToASCII(base_group));
   LaunchSetup(&cmd_line, product, system_level);
 }
 
+// static
 // User qualifies for the experiment. To test, use --try-chrome-again=|flavor|
 // as a parameter to chrome.exe.
-void GoogleChromeDistribution::InactiveUserToastExperiment(int flavor,
+void UserExperiment::InactiveUserToastExperiment(
+    BrowserDistribution* dist,
+    int flavor,
     const string16& experiment_group,
     const installer::Product& installation,
     const base::FilePath& application_path) {
   // Add the 'welcome back' url for chrome to show.
   CommandLine options(CommandLine::NO_PROGRAM);
-  options.AppendSwitchNative(switches::kTryChromeAgain,
+  options.AppendSwitchNative(::switches::kTryChromeAgain,
       base::IntToString16(flavor));
   // Prepend the url with a space.
   string16 url(GetWelcomeBackUrl());
   options.AppendArg("--");
   options.AppendArgNative(url);
   // The command line should now have the url added as:
   // "chrome.exe -- <url>"
   DCHECK_NE(string16::npos,
       options.GetCommandLineString().find(L" -- " + url));
 
@@ skipping 22 matching lines @@
 
   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::switches::kSystemLevelToast);
 
   CommandLine cmd(InstallUtil::GetChromeUninstallCmd(system_level_toast,
-                                                     GetType()));
+                                                     dist->GetType()));
   base::LaunchProcess(cmd, base::LaunchOptions(), NULL);
 }
 
-bool GoogleChromeDistribution::ShouldSetExperimentLabels() {
-  return true;
-}
+}  // namespace installer