Only do DelegateExecute verb handler registration for Google Chrome.

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 274 matching lines @@
                                  const InstallerState& installer_state,
                                  const FilePath& setup_path,
                                  const Version& new_version,
                                  WorkItemList* list) {
   const Products& products = installer_state.products();
   for (size_t i = 0; i < products.size(); ++i) {
     const Product& p = *products[i];
     if (p.is_chrome_frame()) {
       AddChromeFrameWorkItems(original_state, installer_state, setup_path,
                               new_version, p, list);
-    } else if (p.is_chrome()) {
-      AddChromeWorkItems(original_state, installer_state, setup_path,
-                         new_version, p, list);
     }
   }
 }
 
 // Mirror oeminstall the first time anything is installed multi.  There is no
 // need to update the value on future install/update runs since this value never
 // changes.  Note that the value is removed by Google Update after EULA
 // acceptance is processed.
 void AddOemInstallWorkItems(const InstallationState& original_state,
                             const InstallerState& installer_state,
@@ skipping 510 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);
   }
 
   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 AddChromeWorkItems(const InstallationState& original_state,
-                        const InstallerState& installer_state,
-                        const FilePath& setup_path,
-                        const Version& new_version,
-                        const Product& product,
-                        WorkItemList* list) {
-  // For the moment, this function adds work items to perform COM registration
-  // specific to the Windows 8 delegate.  If more work needs to be done in the
-  // future, pull this into its own function called by AddChromeWorkItems.
-  DCHECK(product.is_chrome());
+void AddDelegateExecuteWorkItems(const InstallationState& original_state,
+                                 const InstallerState& installer_state,
+                                 const FilePath& setup_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(kCommandExecuteImplUuid);
+  delegate_execute_path.append(handler_class_uuid);
   string16 typelib_path(L"Software\\Classes\\TypeLib\\");
-  typelib_path.append(kDelegateExecuteLibUuid);
+  typelib_path.append(type_lib_uuid);
   string16 interface_path(L"Software\\Classes\\Interface\\");
-  interface_path.append(kICommandExecuteImplUuid);
+  interface_path.append(interface_uuid);
 
   if (is_install) {
     // 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
     // Software\Classes\CLSID\{5C65F4B0-3651-4514-B207-D10CB699B14B}
     list->AddCreateRegKeyWorkItem(root, delegate_execute_path);
     list->AddSetRegValueWorkItem(root, delegate_execute_path, L"",
                                  L"CommandExecuteImpl Class", true);
     string16 subkey(delegate_execute_path);
     subkey.append(L"\\LocalServer32");
     list->AddCreateRegKeyWorkItem(root, subkey);
     list->AddSetRegValueWorkItem(root, subkey, L"", command, true);
     list->AddSetRegValueWorkItem(root, subkey, L"ServerExecutable",
                                  delegate_execute.value(), true);
 
     subkey.assign(delegate_execute_path).append(L"\\Programmable");
     list->AddCreateRegKeyWorkItem(root, subkey);
 
     subkey.assign(delegate_execute_path).append(L"\\TypeLib");
     list->AddCreateRegKeyWorkItem(root, subkey);
-    list->AddSetRegValueWorkItem(root, subkey, L"", kDelegateExecuteLibUuid,
-                                 true);
+    list->AddSetRegValueWorkItem(root, subkey, L"", type_lib_uuid, true);
 
     subkey.assign(delegate_execute_path).append(L"\\Version");
     list->AddCreateRegKeyWorkItem(root, subkey);
-    list->AddSetRegValueWorkItem(root, subkey, L"", kDelegateExecuteLibVersion,
-                                 true);
+    list->AddSetRegValueWorkItem(root, subkey, L"", type_lib_version, true);
 
     // Register the DelegateExecuteLib type library at
     // Software\Classes\TypeLib\{4E805ED8-EBA0-4601-9681-12815A56EBFD}
     list->AddCreateRegKeyWorkItem(root, typelib_path);
 
     string16 version_key(typelib_path);
-    version_key.append(1, L'\\').append(kDelegateExecuteLibVersion);
+    version_key.append(1, L'\\').append(type_lib_version);
     list->AddCreateRegKeyWorkItem(root, version_key);
-    list->AddSetRegValueWorkItem(root, version_key, L"", kDelegateExecuteLib,
+    list->AddSetRegValueWorkItem(root, version_key, L"", L"DelegateExecuteLib",
                                  true);
 
     subkey.assign(version_key).append(L"\\FLAGS");
     const DWORD flags = LIBFLAG_FRESTRICTED | LIBFLAG_FCONTROL;
     list->AddCreateRegKeyWorkItem(root, subkey);
     list->AddSetRegValueWorkItem(root, subkey, L"", flags, true);
 
     subkey.assign(version_key).append(L"\\0");
     list->AddCreateRegKeyWorkItem(root, subkey);
 
     subkey.append(L"\\win32");
     list->AddCreateRegKeyWorkItem(root, subkey);
     list->AddSetRegValueWorkItem(root, subkey, L"", delegate_execute.value(),
                                  true);
 
     subkey.assign(version_key).append(L"\\HELPDIR");
     list->AddCreateRegKeyWorkItem(root, subkey);
     list->AddSetRegValueWorkItem(root, subkey, L"",
                                  delegate_execute.DirName().value(), true);
 
     // Register to ICommandExecuteImpl interface at
     // Software\Classes\Interface\{0BA0D4E9-2259-4963-B9AE-A839F7CB7544}
     list->AddCreateRegKeyWorkItem(root, interface_path);
     list->AddSetRegValueWorkItem(root, interface_path, L"",
-                                 kICommandExecuteImpl, true);
+                                 L"ICommandExecuteImpl", true);
 
     subkey.assign(interface_path).append(L"\\ProxyStubClsid32");
     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"", kDelegateExecuteLibUuid,
+    list->AddSetRegValueWorkItem(root, subkey, L"", type_lib_uuid, true);
+    list->AddSetRegValueWorkItem(root, subkey, L"Version", type_lib_version,
                                  true);
-    list->AddSetRegValueWorkItem(root, subkey, L"Version",
-                                 kDelegateExecuteLibVersion, true);
 
   } else {
     list->AddDeleteRegKeyWorkItem(root, delegate_execute_path);
     list->AddDeleteRegKeyWorkItem(root, typelib_path);
     list->AddDeleteRegKeyWorkItem(root, interface_path);
   }
 }
 
 namespace {
 
@@ skipping 235 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