Don't register or use the DelegateExecute verb handler if it isn't present.

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>
 #include <shlobj.h>
 #include <time.h>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/file_path.h"
+#include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/version.h"
 #include "base/win/registry.h"
 #include "base/win/windows_version.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/installer/setup/install.h"
 #include "chrome/installer/setup/setup_constants.h"
@@ skipping 820 matching lines @@
   const Products& products = installer_state.products();
   for (size_t i = 0; i < products.size(); ++i) {
     const Product* product = products[i];
 
     AddUninstallShortcutWorkItems(installer_state, setup_path, new_version,
                                   install_list, *product);
 
     AddVersionKeyWorkItems(root, product->distribution(), new_version,
                            add_language_identifier, install_list);
 
-    AddDelegateExecuteWorkItems(original_state, installer_state, setup_path,
-                                new_version, *product, install_list);
+    AddDelegateExecuteWorkItems(installer_state, src_path, new_version,
+                                *product, install_list);
   }
 
   if (installer_state.is_multi_install()) {
     AddMultiUninstallWorkItems(installer_state, setup_path, new_version,
                                install_list);
 
     AddVersionKeyWorkItems(root,
         installer_state.multi_package_binaries_distribution(), new_version,
         add_language_identifier, install_list);
   }
@@ skipping 185 matching lines @@
                          BrowserDistribution::CHROME_BROWSER));
       chrome.InitializeFromUninstallCommand(chrome_state->uninstall_command());
       AddUninstallShortcutWorkItems(installer_state, setup_path,
                                     chrome_state->version(), list, chrome);
     } else {
       NOTREACHED() << "What happened to Chrome?";
     }
   }
 }
 
-void AddDelegateExecuteWorkItems(const InstallationState& original_state,
-                                 const InstallerState& installer_state,
-                                 const FilePath& setup_path,
+void AddDelegateExecuteWorkItems(const InstallerState& installer_state,
+                                 const FilePath& src_path,
                                  const Version& new_version,
                                  const Product& product,
                                  WorkItemList* list) {
   string16 handler_class_uuid;
   string16 type_lib_uuid;
   string16 type_lib_version;
   string16 interface_uuid;
   BrowserDistribution* distribution = product.distribution();
   if (!distribution->GetDelegateExecuteHandlerData(
           &handler_class_uuid, &type_lib_uuid, &type_lib_version,
           &interface_uuid)) {
     VLOG(1) << "No DelegateExecute verb handler processing to do for "
             << distribution->GetAppShortCutName();
     return;
   }
 
-  VLOG(1) << "DelegateExecute verb handler COM registration.";
-
   HKEY root = installer_state.root_key();
   const bool is_install =
       (installer_state.operation() != InstallerState::UNINSTALL);
   string16 delegate_execute_path(L"Software\\Classes\\CLSID\\");
   delegate_execute_path.append(handler_class_uuid);
   string16 typelib_path(L"Software\\Classes\\TypeLib\\");
   typelib_path.append(type_lib_uuid);
   string16 interface_path(L"Software\\Classes\\Interface\\");
   interface_path.append(interface_uuid);
 
-  if (is_install) {
+  // Add work items to register the handler iff it is present.  Remove its
+  // registration otherwise since builds after r132190 included it when it
+  // wasn't strictly necessary.
+  // TODO(grt): remove the extra check for the .exe when it's ever-present;
+  // see also shell_util.cc's GetProgIdEntries.
+  if (is_install &&
+      file_util::PathExists(src_path.AppendASCII(new_version.GetString())
+          .Append(kDelegateExecuteExe))) {
+    VLOG(1) << "Adding registration items for DelegateExecute verb handler.";
+
     // The path to the exe (in the version directory).
     FilePath delegate_execute(
         installer_state.target_path().AppendASCII(new_version.GetString()));
     delegate_execute = delegate_execute.Append(kDelegateExecuteExe);
 
     // Command-line featuring the quoted path to the exe.
     string16 command(1, L'"');
     command.append(delegate_execute.value()).append(1, L'"');
 
     // Register the CommandExecuteImpl class at
@@ skipping 57 matching lines @@
     list->AddCreateRegKeyWorkItem(root, subkey);
     list->AddSetRegValueWorkItem(root, subkey, L"", kPSOAInterfaceUuid, true);
 
     subkey.assign(interface_path).append(L"\\TypeLib");
     list->AddCreateRegKeyWorkItem(root, subkey);
     list->AddSetRegValueWorkItem(root, subkey, L"", type_lib_uuid, true);
     list->AddSetRegValueWorkItem(root, subkey, L"Version", type_lib_version,
                                  true);
 
   } else {
+    VLOG(1) << "Adding unregistration items for DelegateExecute verb handler.";
+
     list->AddDeleteRegKeyWorkItem(root, delegate_execute_path);
     list->AddDeleteRegKeyWorkItem(root, typelib_path);
     list->AddDeleteRegKeyWorkItem(root, interface_path);
   }
 }
 
 namespace {
 
 enum ElevationPolicyId {
   CURRENT_ELEVATION_POLICY,
@@ skipping 233 matching lines @@
     } 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