Refactor of BrowserDistribution.

chrome/installer/setup/install_worker.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.
 //
 // This file contains the definitions of the installer functions that build
 // the WorkItemList used to install the application.
 
 #include "chrome/installer/setup/install_worker.h"
 
 #include <oaidl.h>
@@ skipping 420 matching lines @@
   if (installer_state.system_install()) {
     PathService::Get(base::DIR_COMMON_START_MENU, &uninstall_link);
   } else {
     PathService::Get(base::DIR_START_MENU, &uninstall_link);
   }
 
   if (uninstall_link.empty()) {
     LOG(ERROR) << "Failed to get location for shortcut.";
   } else {
     uninstall_link = uninstall_link.Append(
-        product.distribution()->GetAppShortCutName());
+        product.distribution()->GetStartMenuShortcutSubfolder(
+            BrowserDistribution::SUBFOLDER_CHROME));
     uninstall_link = uninstall_link.Append(
         product.distribution()->GetUninstallLinkName() + installer::kLnkExt);
     VLOG(1) << "Deleting old uninstall shortcut (if present): "
             << uninstall_link.value();
     WorkItem* delete_link = work_item_list->AddDeleteTreeWorkItem(
         uninstall_link, temp_path);
     delete_link->set_ignore_failure(true);
     delete_link->set_log_message(
         "Failed to delete old uninstall shortcut.");
   }
@@ skipping 263 matching lines @@
   // MSI installations will manage their own uninstall shortcuts.
   if (!installer_state.is_msi() && product.ShouldCreateUninstallEntry()) {
     // We need to quote the command line for the Add/Remove Programs dialog.
     CommandLine quoted_uninstall_cmd(installer_path);
     DCHECK_EQ(quoted_uninstall_cmd.GetCommandLineString()[0], '"');
     quoted_uninstall_cmd.AppendArguments(uninstall_arguments, false);
 
     string16 uninstall_reg = browser_dist->GetUninstallRegPath();
     install_list->AddCreateRegKeyWorkItem(reg_root, uninstall_reg);
     install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
-        installer::kUninstallDisplayNameField,
-        browser_dist->GetAppShortCutName(), true);
+        installer::kUninstallDisplayNameField, browser_dist->GetDisplayName(),
+        true);
     install_list->AddSetRegValueWorkItem(reg_root,
         uninstall_reg, installer::kUninstallStringField,
         quoted_uninstall_cmd.GetCommandLineString(), true);
     install_list->AddSetRegValueWorkItem(reg_root,
                                          uninstall_reg,
                                          L"InstallLocation",
                                          install_path.value(),
                                          true);
 
     BrowserDistribution* dist = product.distribution();
     string16 chrome_icon = ShellUtil::FormatIconLocation(
         install_path.Append(dist->GetIconFilename()).value(),
-        dist->GetIconIndex());
+        dist->GetIconIndex(BrowserDistribution::SHORTCUT_CHROME));
     install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
                                          L"DisplayIcon", chrome_icon, true);
     install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
                                          L"NoModify", static_cast<DWORD>(1),
                                          true);
     install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
                                          L"NoRepair", static_cast<DWORD>(1),
                                          true);
 
     install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
@@ skipping 29 matching lines @@
 void AddVersionKeyWorkItems(HKEY root,
                             BrowserDistribution* dist,
                             const Version& new_version,
                             bool add_language_identifier,
                             WorkItemList* list) {
   // Create Version key for each distribution (if not already present) and set
   // the new product version as the last step.
   string16 version_key(dist->GetVersionKey());
   list->AddCreateRegKeyWorkItem(root, version_key);
 
-  string16 product_name(dist->GetAppShortCutName());
+  string16 product_name(dist->GetDisplayName());
   list->AddSetRegValueWorkItem(root, version_key, google_update::kRegNameField,
                                product_name, true);  // overwrite name also
   list->AddSetRegValueWorkItem(root, version_key,
                                google_update::kRegOopcrashesField,
                                static_cast<DWORD>(1),
                                false);  // set during first install
   if (add_language_identifier) {
     // Write the language identifier of the current translation.  Omaha's set of
     // languages is a superset of Chrome's set of translations with this one
     // exception: what Chrome calls "en-us", Omaha calls "en".  sigh.
@@ skipping 38 matching lines @@
       LOG(ERROR) << "No products found in AddOemInstallWorkItems";
       return;
     }
     const ProductState* source_product =
         original_state.GetNonVersionedProductState(system_install, source_type);
 
     string16 oem_install;
     if (source_product->GetOemInstall(&oem_install)) {
       VLOG(1) << "Mirroring oeminstall=\"" << oem_install << "\" from "
               << BrowserDistribution::GetSpecificDistribution(source_type)->
-                    GetAppShortCutName();
+                     GetDisplayName();
       install_list->AddCreateRegKeyWorkItem(root_key, multi_key);
       // Always overwrite an old value.
       install_list->AddSetRegValueWorkItem(root_key, multi_key,
                                            google_update::kRegOemInstallField,
                                            oem_install, true);
     } else {
       // Clear any old value.
       install_list->AddDeleteRegValueWorkItem(
           root_key, multi_key, google_update::kRegOemInstallField);
     }
@@ skipping 34 matching lines @@
           (!have_eula_accepted || dword_value > eula_accepted)) {
         have_eula_accepted = true;
         eula_accepted = dword_value;
         product_type = this_type;
       }
     }
 
     if (have_eula_accepted) {
       VLOG(1) << "Mirroring eulaaccepted=" << eula_accepted << " from "
               << BrowserDistribution::GetSpecificDistribution(product_type)->
-                     GetAppShortCutName();
+                     GetDisplayName();
       install_list->AddCreateRegKeyWorkItem(root_key, multi_key);
       install_list->AddSetRegValueWorkItem(
           root_key, multi_key, google_update::kRegEULAAceptedField,
           eula_accepted, true);
     } else {
       // Clear any old value.
       install_list->AddDeleteRegValueWorkItem(
           root_key, multi_key, google_update::kRegEULAAceptedField);
     }
   }
@@ skipping 512 matching lines @@
     }
   }
 }
 
 void AddDelegateExecuteWorkItems(const InstallerState& installer_state,
                                  const base::FilePath& target_path,
                                  const Version& new_version,
                                  const Product& product,
                                  WorkItemList* list) {
   string16 handler_class_uuid;
-  BrowserDistribution* distribution = product.distribution();
-  if (!distribution->GetCommandExecuteImplClsid(&handler_class_uuid)) {
+  BrowserDistribution* dist = product.distribution();
+  if (!dist->GetCommandExecuteImplClsid(&handler_class_uuid)) {
     if (InstallUtil::IsChromeSxSProcess()) {
       CleanupBadCanaryDelegateExecuteRegistration(target_path, list);
     } else {
       VLOG(1) << "No DelegateExecute verb handler processing to do for "
-              << distribution->GetAppShortCutName();
+              << dist->GetDisplayName();
     }
     return;
   }
 
   HKEY root = installer_state.root_key();
   string16 delegate_execute_path(L"Software\\Classes\\CLSID\\");
   delegate_execute_path.append(handler_class_uuid);
 
   // Unconditionally remove registration regardless of whether or not it is
   // needed since builds after r132190 included it when it wasn't strictly
@@ skipping 35 matching lines @@
     list->AddCreateRegKeyWorkItem(root, subkey);
   }
 }
 
 void AddActiveSetupWorkItems(const InstallerState& installer_state,
                              const base::FilePath& setup_path,
                              const Version& new_version,
                              const Product& product,
                              WorkItemList* list) {
   DCHECK(installer_state.operation() != InstallerState::UNINSTALL);
-  BrowserDistribution* distribution = product.distribution();
+  BrowserDistribution* dist = product.distribution();
 
   if (!product.is_chrome() || !installer_state.system_install()) {
     const char* install_level =
         installer_state.system_install() ? "system" : "user";
     VLOG(1) << "No Active Setup processing to do for " << install_level
-            << "-level " << distribution->GetAppShortCutName();
+            << "-level " << dist->GetDisplayName();
     return;
   }
   DCHECK(installer_state.RequiresActiveSetup());
 
   const HKEY root = HKEY_LOCAL_MACHINE;
-  const string16 active_setup_path(
-      InstallUtil::GetActiveSetupPath(distribution));
+  const string16 active_setup_path(InstallUtil::GetActiveSetupPath(dist));
 
   VLOG(1) << "Adding registration items for Active Setup.";
   list->AddCreateRegKeyWorkItem(root, active_setup_path);
   list->AddSetRegValueWorkItem(root, active_setup_path, L"",
-                               distribution->GetAppShortCutName(), true);
+                               dist->GetDisplayName(), true);
 
   base::FilePath active_setup_exe(installer_state.GetInstallerDirectory(
       new_version).Append(kActiveSetupExe));
   CommandLine cmd(active_setup_exe);
   cmd.AppendSwitch(installer::switches::kConfigureUserSettings);
   cmd.AppendSwitch(installer::switches::kVerboseLogging);
   cmd.AppendSwitch(installer::switches::kSystemLevel);
   product.AppendProductFlags(&cmd);
   list->AddSetRegValueWorkItem(root, active_setup_path, L"StubPath",
                                cmd.GetCommandLineString(), true);
 
   // TODO(grt): http://crbug.com/75152 Write a reference to a localized
   // resource.
   list->AddSetRegValueWorkItem(root, active_setup_path, L"Localized Name",
-                               distribution->GetAppShortCutName(), true);
+                               dist->GetDisplayName(), true);
 
   list->AddSetRegValueWorkItem(root, active_setup_path, L"IsInstalled",
                                static_cast<DWORD>(1U), true);
 
   list->AddSetRegValueWorkItem(root, active_setup_path, L"Version",
                                kActiveSetupVersion, true);
 }
 
 void AddDeleteOldIELowRightsPolicyWorkItems(
     const InstallerState& installer_state,
@@ skipping 170 matching lines @@
     if (installer_state.system_install())
       cmd_line.AppendSwitch(switches::kSystemLevel);
     AppCommand cmd(cmd_line.GetCommandLineString());
     cmd.set_sends_pings(true);
     cmd.set_is_web_accessible(true);
     cmd.AddWorkItems(installer_state.root_key(), cmd_key, work_item_list);
   }
 }
 
 }  // namespace installer