Additional changes to support Chrome / CF installation wrapped in an MSI:...

chrome/installer/setup/install.cc

 // Copyright (c) 2009 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.
 
 #include <shlobj.h>
 #include <time.h>
 
 #include "chrome/installer/setup/install.h"
 
 #include "base/command_line.h"
@@ skipping 81 matching lines @@
     uninstall_cmd_line->append(installer_util::switches::kDeleteProfile);
     uninstall_cmd_line->append(L" --");
     uninstall_cmd_line->append(installer_util::switches::kChromeFrame);
   }
 
   if (InstallUtil::IsChromeSxSProcess()) {
     uninstall_cmd_line->append(L" --");
     uninstall_cmd_line->append(installer_util::switches::kChromeSxS);
   }
 
-  if (InstallUtil::IsMSIProcess()) {
+  if (InstallUtil::IsMSIProcess(is_system)) {
     uninstall_cmd_line->append(L" --");
     uninstall_cmd_line->append(installer_util::switches::kMsi);
   }
 
   // Propagate the verbose logging switch to uninstalls too.
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(installer_util::switches::kVerboseLogging)) {
     uninstall_cmd_line->append(L" --");
     uninstall_cmd_line->append(installer_util::switches::kVerboseLogging);
   }
 
   if (is_system) {
     uninstall_cmd_line->append(L" --");
     uninstall_cmd_line->append(installer_util::switches::kSystemLevel);
   }
 }
 
 // This method adds work items to create (or update) Chrome uninstall entry in
 // either the Control Panel->Add/Remove Programs list or in the Omaha client
 // state key if running under an MSI installer.
 void AddUninstallShortcutWorkItems(HKEY reg_root,
                                    const std::wstring& exe_path,
                                    const std::wstring& install_path,
                                    const std::wstring& product_name,
                                    const std::wstring& new_version,
                                    WorkItemList* install_list) {
-  std::wstring uninstall_cmd(L"\"");
-  uninstall_cmd.append(installer::GetInstallerPathUnderChrome(install_path,
-                                                              new_version));
-  file_util::AppendToPath(&uninstall_cmd,
-                          file_util::GetFilenameFromPath(exe_path));
-  uninstall_cmd.append(L"\"");
-
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
-
   // When we are installed via an MSI, we need to store our uninstall strings
   // in the Google Update client state key. We do this even for non-MSI
   // managed installs to avoid breaking the edge case whereby an MSI-managed
   // install is updated by a non-msi installer (which would confuse the MSI
   // machinery if these strings were not also updated).
+  // Do not quote the command line for the MSI invocation.
+  std::wstring uninstall_cmd(
+    installer::GetInstallerPathUnderChrome(install_path, new_version));
+  file_util::AppendToPath(&uninstall_cmd,
+    file_util::GetFilenameFromPath(exe_path));
   std::wstring uninstall_arguments;
   AppendUninstallCommandLineFlags(&uninstall_arguments,
                                   reg_root == HKEY_LOCAL_MACHINE);
+
   std::wstring update_state_key = dist->GetStateKey();
   install_list->AddCreateRegKeyWorkItem(reg_root, update_state_key);
   install_list->AddSetRegValueWorkItem(reg_root, update_state_key,
       installer_util::kUninstallStringField, uninstall_cmd, true);
   install_list->AddSetRegValueWorkItem(reg_root, update_state_key,
       installer_util::kUninstallArgumentsField, uninstall_arguments, true);
 
   // MSI installations will manage their own uninstall shortcuts.
-  if (!InstallUtil::IsMSIProcess()) {
-    AppendUninstallCommandLineFlags(&uninstall_cmd,
+  if (!InstallUtil::IsMSIProcess(reg_root == HKEY_LOCAL_MACHINE)) {
+    // We need to quote the command line for the Add/Remove Programs dialog.
+    std::wstring quoted_uninstall_cmd(L"\"");
+    quoted_uninstall_cmd += uninstall_cmd;
+    quoted_uninstall_cmd += L"\"";
+
+    AppendUninstallCommandLineFlags(&quoted_uninstall_cmd,
                                     reg_root == HKEY_LOCAL_MACHINE);
     std::wstring uninstall_reg = dist->GetUninstallRegPath();
     install_list->AddCreateRegKeyWorkItem(reg_root, uninstall_reg);
     install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
         installer_util::kUninstallDisplayNameField, product_name, true);
     install_list->AddSetRegValueWorkItem(reg_root,
                                          uninstall_reg,
                                          installer_util::kUninstallStringField,
-                                         uninstall_cmd, true);
+                                         quoted_uninstall_cmd,
+                                         true);
     install_list->AddSetRegValueWorkItem(reg_root,
                                          uninstall_reg,
                                          L"InstallLocation",
                                          install_path,
                                          true);
 
     // DisplayIcon, NoModify and NoRepair
     std::wstring chrome_icon = AppendPath(install_path,
                                           installer_util::kChromeExe);
     ShellUtil::GetChromeIcon(chrome_icon);
@@ skipping 98 matching lines @@
                                                  chrome_link.value(),
                                                  product_desc, true);
   } else if (file_util::PathExists(chrome_link)) {
     LOG(INFO) << "Updating shortcut at " << chrome_link.value()
               << " to point to " << chrome_exe;
     ret = ret && ShellUtil::UpdateChromeShortcut(chrome_exe,
                                                  chrome_link.value(),
                                                  product_desc, false);
   }
 
-  // Create/update uninstall link
-  FilePath uninstall_link(shortcut_path);  // Uninstall Chrome link
-  uninstall_link = uninstall_link.Append(
-      dist->GetUninstallLinkName() + L".lnk");
-  if ((install_status == installer_util::FIRST_INSTALL_SUCCESS) ||
-      (install_status == installer_util::INSTALL_REPAIRED) ||
-      (file_util::PathExists(uninstall_link))) {
-    if (!file_util::PathExists(shortcut_path))
-      file_util::CreateDirectoryW(shortcut_path);
-    std::wstring setup_exe(installer::GetInstallerPathUnderChrome(install_path,
-                                                                  new_version));
-    file_util::AppendToPath(&setup_exe,
-                            file_util::GetFilenameFromPath(exe_path));
+  // Create/update uninstall link if we are not an MSI install. MSI
+  // installations are, for the time being, managed only through the
+  // Add/Remove Programs dialog.
+  // TODO(robertshield): We could add a shortcut to msiexec /X {GUID} here.
+  if (!InstallUtil::IsMSIProcess(system_install)) {
+    FilePath uninstall_link(shortcut_path);  // Uninstall Chrome link
+    uninstall_link = uninstall_link.Append(
+        dist->GetUninstallLinkName() + L".lnk");
+    if ((install_status == installer_util::FIRST_INSTALL_SUCCESS) ||
+        (install_status == installer_util::INSTALL_REPAIRED) ||
+        (file_util::PathExists(uninstall_link))) {
+      if (!file_util::PathExists(shortcut_path))
+          file_util::CreateDirectoryW(shortcut_path);
+        std::wstring setup_exe(installer::GetInstallerPathUnderChrome(
+            install_path, new_version));
+        file_util::AppendToPath(&setup_exe,
+                                file_util::GetFilenameFromPath(exe_path));
 
-    std::wstring arguments;
-    AppendUninstallCommandLineFlags(&arguments, system_install);
-
-    LOG(INFO) << "Creating/updating uninstall link at "
-              << uninstall_link.value();
-    ret = ret && file_util::CreateShortcutLink(setup_exe.c_str(),
-                                               uninstall_link.value().c_str(),
-                                               NULL,
-                                               arguments.c_str(),
-                                               NULL, setup_exe.c_str(), 0,
-                                               NULL);
+        std::wstring arguments;
+        AppendUninstallCommandLineFlags(&arguments, system_install);
+        LOG(INFO) << "Creating/updating uninstall link at "
+                  << uninstall_link.value();
+        ret = ret && file_util::CreateShortcutLink(setup_exe.c_str(),
+            uninstall_link.value().c_str(),
+            NULL,
+            arguments.c_str(),
+            NULL,
+            setup_exe.c_str(),
+            0,
+            NULL);
+    }
   }
 
   // Update Desktop and Quick Launch shortcuts. If --create-new-shortcuts
   // is specified we want to create them, otherwise we update them only if
   // they exist.
   if (system_install) {
     ret = ret && ShellUtil::CreateChromeDesktopShortcut(chrome_exe,
         product_desc, ShellUtil::SYSTEM_LEVEL, alt_shortcut,
         create_all_shortcut);
     ret = ret && ShellUtil::CreateChromeQuickLaunchShortcut(chrome_exe,
         ShellUtil::CURRENT_USER | ShellUtil::SYSTEM_LEVEL, create_all_shortcut);
   } else {
     ret = ret && ShellUtil::CreateChromeDesktopShortcut(chrome_exe,
         product_desc, ShellUtil::CURRENT_USER, alt_shortcut,
         create_all_shortcut);
     ret = ret && ShellUtil::CreateChromeQuickLaunchShortcut(chrome_exe,
         ShellUtil::CURRENT_USER, create_all_shortcut);
   }
 
   return ret;
 }
 
 // After a successful copying of all the files, this function is called to
 // do a few post install tasks:
 // - Handle the case of in-use-update by updating "opv" key or deleting it if
 //   not required.
 // - Register any new dlls and unregister old dlls.
+// - If this is an MSI install, ensures that the MSI marker is set, and sets
+//   it if not.
 // If these operations are successful, the function returns true, otherwise
 // false.
 bool DoPostInstallTasks(HKEY reg_root,
                         const std::wstring& exe_path,
                         const std::wstring& install_path,
                         const std::wstring& new_chrome_exe,
                         const std::wstring& current_version,
                         const installer::Version& new_version) {
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   std::wstring version_key = dist->GetVersionKey();
 
+  bool is_system_install = (reg_root == HKEY_LOCAL_MACHINE);
+
   if (file_util::PathExists(FilePath::FromWStringHack(new_chrome_exe))) {
     // Looks like this was in use update. So make sure we update the 'opv' key
     // with the current version that is active and 'cmd' key with the rename
     // command to run.
     if (current_version.empty()) {
       LOG(ERROR) << "New chrome.exe exists but current version is empty!";
       return false;
     }
     scoped_ptr<WorkItemList> inuse_list(WorkItem::CreateWorkItemList());
     inuse_list->AddSetRegValueWorkItem(reg_root,
                                        version_key,
                                        google_update::kRegOldVersionField,
                                        current_version.c_str(),
                                        true);
 
     std::wstring rename_cmd(installer::GetInstallerPathUnderChrome(
         install_path, new_version.GetString()));
     file_util::AppendToPath(&rename_cmd,
                             file_util::GetFilenameFromPath(exe_path));
     rename_cmd = L"\"" + rename_cmd +
                  L"\" --" + installer_util::switches::kRenameChromeExe;
-    if (reg_root == HKEY_LOCAL_MACHINE)
+    if (is_system_install)
       rename_cmd = rename_cmd + L" --" + installer_util::switches::kSystemLevel;
 
     if (InstallUtil::IsChromeFrameProcess()) {
       rename_cmd += L" --";
       rename_cmd += installer_util::switches::kChromeFrame;
     }
 
     if (InstallUtil::IsChromeSxSProcess()) {
       rename_cmd += L" --";
       rename_cmd += installer_util::switches::kChromeSxS;
@@ skipping 54 matching lines @@
     if (InstallUtil::BuildDLLRegistrationList(dll_path, kDllsToRegister,
                                               kNumDllsToRegister, true,
                                               dll_list.get())) {
       if (!dll_list->Do()) {
         dll_list->Rollback();
         return false;
       }
     }
   }
 
+  // If we're told that we're an MSI install, make sure to set the marker
+  // in the client state key so that future updates do the right thing.
+  if (InstallUtil::IsMSIProcess(is_system_install)) {
+    if (!InstallUtil::SetMSIMarker(is_system_install, true))
+      return false;
+  }
+
   return true;
 }
 
 // This method tells if we are running on 64 bit platform so that we can copy
 // one extra exe. If the API call to determine 64 bit fails, we play it safe
 // and return true anyway so that the executable can be copied.
 bool Is64bit() {
   typedef BOOL (WINAPI *WOW_FUNC)(HANDLE, PBOOL);
   BOOL is64 = FALSE;
 
@@ skipping 260 matching lines @@
     }
 
     std::wstring latest_version_to_keep(new_version.GetString());
     if (!current_version.empty())
       latest_version_to_keep.assign(current_version);
     RemoveOldVersionDirs(install_path, latest_version_to_keep);
   }
 
   return result;
 }