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/files/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_util.h"
-#include "base/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/utf_string_conversions.h"
-#include "base/win/registry.h"
+#include "base/win/scoped_handle.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/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 user_experiment {
+
 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) {
   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;
   ULARGE_INTEGER uli = {time.dwLowDateTime, time.dwHighDateTime};
   return static_cast<int>(uli.QuadPart / k100sNanoSecsToHours);
 }
 
 // Returns the directory last write time in hours since January 1, 1601.
 // Returns -1 if there was an error retrieving the directory time.
 int GetDirectoryWriteTimeInHours(const wchar_t* path) {
   // To open a directory you need to pass FILE_FLAG_BACKUP_SEMANTICS.
   DWORD share = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
-  HANDLE file = ::CreateFileW(path, 0, share, NULL, OPEN_EXISTING,
-                              FILE_FLAG_BACKUP_SEMANTICS, NULL);
-  if (INVALID_HANDLE_VALUE == file)
+  base::win::ScopedHandle file(CreateFileW(path, 0, share, NULL, OPEN_EXISTING,

[gab, 2013/03/04 23:40:30]

Keep the leading :: for CreateFileW, this guarantees that you are using the one
defined in the global namespace (and tends to be common style when using methods
from the Windows API).

(I also think the 'W' in the method name is unnecessary, but grt (our
C++/Windows guru) would definitely know more than I on this (IIRC CreateFile is
#defined to the right impl at compile time -- hardcoding it to one impl isn't
necessary))

[huangs, 2013/03/05 16:48:34]

Done.

+                               FILE_FLAG_BACKUP_SEMANTICS, NULL));
+  if (!file.IsValid())
     return -1;
+
   FILETIME time;
-  if (!::GetFileTime(file, NULL, NULL, &time)) {
-    ::CloseHandle(file);
-    return -1;
-  }
-
-  ::CloseHandle(file);
-  return FileTimeToHours(time);
+  return ::GetFileTime(file, NULL, NULL, &time) ? FileTimeToHours(time) : -1;
 }
 
 // Returns the directory last-write time age in hours, relative to current
 // time, so if it returns 14 it means that the directory was last written 14
 // hours ago. Returns -1 if there was an error retrieving the directory.
 int GetDirectoryWriteAgeInHours(const wchar_t* path) {
   int dir_time = GetDirectoryWriteTimeInHours(path);
   if (dir_time < 0)
     return dir_time;
   FILETIME time;
@@ skipping 152 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
+
+bool CreateExperimentDetails(
+    int flavor,
+    ExperimentDetails* experiment) {
   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.
 
-//
 // 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 LaunchUserExperiment(const base::FilePath& setup_path,
+                          installer::InstallStatus status,
+                          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(-1, &experiment)) {
     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 55 matching lines @@
   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);
 }
 
 // User qualifies for the experiment. To test, use --try-chrome-again=|flavor|
 // as a parameter to chrome.exe.
-void GoogleChromeDistribution::InactiveUserToastExperiment(int flavor,
-    const string16& experiment_group,
-    const installer::Product& installation,
-    const base::FilePath& application_path) {
+void 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 user_experiment
+
+}  // namespace installer