Add support for the quick-enable-cf command to the installer. This encompase...

chrome/installer/setup/install_worker.cc

 // Copyright (c) 2011 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 <shlobj.h>
@@ skipping 597 matching lines @@
         install_list);
   }
 
   // Add any remaining work items that involve special settings for
   // each product.
   AddProductSpecificWorkItems(original_state, installer_state, setup_path,
                               new_version, install_list);
 
   AddGoogleUpdateWorkItems(installer_state, install_list);
 
+  AddQuickEnableWorkItems(installer_state, original_state, &setup_path,
+                          &new_version, install_list);
+
   // Append the tasks that run after the installation.
   AppendPostInstallTasks(installer_state,
                          setup_path,
                          new_chrome_exe,
                          current_version->get(),
                          new_version,
                          temp_path,
                          install_list);
 }
 
@@ skipping 266 matching lines @@
     } else {
       VLOG(1) << kIERefreshPolicy << " not supported.";
     }
 
     FreeLibrary(ieframe);
   } else {
     VLOG(1) << "Cannot load " << kIEFrameDll;
   }
 }
 
+void AddQuickEnableWorkItems(const InstallerState& installer_state,

[grt (UTC plus 2), 2011/03/02 19:48:28]

This function made me so sad that I rewrote it.  The logic is now based on the
target state rather than the transitions themselves.  I think this makes it much
easier to reason about its correctness.  I'm working on a unit test that I'll
add in an update prior to commit.

[tommi (sloooow) - chröme, 2011/03/02 20:30:58]

thanks. more easily digestible :)

[grt (UTC plus 2), 2011/03/02 20:44:47]

<burp>

+                             const InstallationState& machine_state,
+                             const FilePath* setup_path,
+                             const Version* new_version,
+                             WorkItemList* work_item_list) {
+  DCHECK(work_item_list);
+
+  enum QuickEnableOperation {
+    DO_NOTHING,
+    ADD_COMMAND,
+    REMOVE_COMMAND
+  } operation = DO_NOTHING;
+  const Version* binaries_version = NULL;
+  FilePath binaries_setup_path;
+
+  if (installer_state.operation() == InstallerState::UNINSTALL) {
+    // Add the quick-enable command if Chrome Frame single, multi, or ready-mode
+    // is being uninstalled, Chrome multi is installed, and Chrome multi is not
+    // being uninstalled.
+    const ProductState* chrome =
+        machine_state.GetProductState(installer_state.system_install(),
+                                      BrowserDistribution::CHROME_BROWSER);
+    if (installer_state.FindProduct(
+            BrowserDistribution::CHROME_FRAME) != NULL &&
+        chrome != NULL && chrome->is_multi_install() &&
+        installer_state.FindProduct(
+            BrowserDistribution::CHROME_BROWSER) == NULL) {
+      operation = ADD_COMMAND;
+      // Chrome multi's uninstall command has the proper path to setup.exe.
+      binaries_setup_path = chrome->uninstall_command().GetProgram();
+    }
+  } else {

[robertshield, 2011/03/02 14:58:57]

Can we move the DCHECKS on setup_path and new_version here since as per the
header file comments, they are always required for installation? 

[grt (UTC plus 2), 2011/03/02 19:48:28]

Done.

+    // Delete the quick-enable command if Chrome Frame single or Chrome Frame
+    // multi (not ready-mode) is being installed.  Note that the command can
+    // only be present if the binaries are already installed, but we try to
+    // remove it in any case just to be sure.
+    const Product* cf =
+        installer_state.FindProduct(BrowserDistribution::CHROME_FRAME);
+    const Product* chrome =
+        installer_state.FindProduct(BrowserDistribution::CHROME_BROWSER);
+    if (cf != NULL && (!installer_state.is_multi_install() ||
+                       !cf->HasOption(installer::kOptionReadyMode))) {
+      operation = REMOVE_COMMAND;
+    } else if (cf != NULL) {
+      // Add the quick-enable command if Chrome Frame ready-mode is being
+      // installed.
+      DCHECK(cf->HasOption(installer::kOptionReadyMode));

[tommi (sloooow) - chröme, 2011/03/01 23:33:13]

couldn't we also get here for a 'single' install (not ready-mode)?

[grt (UTC plus 2), 2011/03/02 19:48:28]

I don't think so (at least, that wasn't my plan).  The first block is hit for
single CF or multi-but-not-ready-mode CF, which leaves only multi-ready-mode-CF
for this block.  Let me know if you think I've messed up the logic here.

+      DCHECK(setup_path);
+      DCHECK(new_version);
+      operation = ADD_COMMAND;
+      // This new version's setup.exe is the one we need.
+      binaries_version = new_version;
+    } else if (installer_state.is_multi_install() &&
+               machine_state.GetProductState(
+                   installer_state.system_install(),
+                   BrowserDistribution::CHROME_FRAME) == NULL) {

[tommi (sloooow) - chröme, 2011/03/01 23:33:13]

What if there exists a system install of gcf and this is a user install?

[grt (UTC plus 2), 2011/03/02 19:48:28]

Robert, Erik, and I just discussed this and reached the conclusion that user-
and system-level should be handled independently as far as adding or removing
the command in the registry goes.

+      // Add the quick-enable command if Chrome Frame is not being installed,
+      // we're doing a multi-install of Chrome, and single Chrome Frame is not
+      // already installed.
+      DCHECK(installer_state.FindProduct(BrowserDistribution::CHROME_BROWSER));
+      DCHECK(new_version);
+      operation = ADD_COMMAND;
+      // This new version's setup.exe is the one we need.
+      binaries_version = new_version;
+    } else {
+      // Else we're doing a single install of Chrome, so do nothing.
+      DCHECK(!installer_state.is_multi_install() && chrome != NULL);
+    }
+
+    // Get the proper path to setup.exe if needed.
+    if (operation == ADD_COMMAND) {
+      DCHECK(binaries_version);
+      DCHECK(!setup_path->empty());
+      binaries_setup_path =
+          installer_state.GetInstallerDirectory(*binaries_version).Append(
+              setup_path->BaseName());
+    }
+  }
+
+  if (operation != DO_NOTHING) {
+    BrowserDistribution* binaries =
+        BrowserDistribution::GetSpecificDistribution(
+            BrowserDistribution::CHROME_BINARIES);
+    std::wstring cmd_key(binaries->GetVersionKey());
+    cmd_key.append(1, L'\\').append(kCmdQuickEnableCf);

[erikwright (departed), 2011/03/02 15:18:16]

add \\Commands here, after the version key.

[grt (UTC plus 2), 2011/03/02 19:48:28]

Done.

+
+    if (operation == ADD_COMMAND) {
+      DCHECK(!binaries_setup_path.empty());
+      CommandLine cmd_line(binaries_setup_path);
+      cmd_line.AppendSwitch(switches::kMultiInstall);
+      if (installer_state.system_install())
+        cmd_line.AppendSwitch(switches::kSystemLevel);
+      if (installer_state.verbose_logging())
+        cmd_line.AppendSwitch(switches::kVerboseLogging);
+      cmd_line.AppendSwitch(switches::kChromeFrameQuickEnable);
+      ProductCommand cmd(cmd_line.command_line_string(), true, true);
+      cmd.AddWorkItems(installer_state.root_key(), cmd_key, work_item_list);
+    } else {
+      DCHECK(operation == REMOVE_COMMAND);
+      work_item_list->AddDeleteRegKeyWorkItem(installer_state.root_key(),
+                                              cmd_key)->set_log_message(
+          "removing quick-enable-cf command");
+    }
+  }
+}
+
 }  // namespace installer