Force COM machinery to notice that the path to the DelegateExecute verb handler has changed.

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/bind.h"
 #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/string16.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/version.h"
 #include "base/win/registry.h"
+#include "base/win/scoped_comptr.h"
 #include "base/win/windows_version.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/installer/setup/install.h"
 #include "chrome/installer/setup/setup_constants.h"
 #include "chrome/installer/setup/setup_util.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/conditional_work_item_list.h"
 #include "chrome/installer/util/create_reg_key_work_item.h"
 #include "chrome/installer/util/google_update_constants.h"
@@ skipping 1070 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?";
     }
   }
 }
 
+// Probes COM machinery to get an instance of delegate_execute.exe's
+// CommandExecuteImpl class.  This is required so that COM purges its cache of
+// the path to the binary, which changes on updates.  This callback
+// unconditionally returns true since an install should not be aborted if the
+// probe fails.
+bool ProbeCommandExecuteCallback(const string16& command_execute_id,
+                                 const CallbackWorkItem& work_item) {
+  // Noop on rollback.
+  if (work_item.IsRollback())
+    return true;
+
+  CLSID class_id = {};
+
+  HRESULT hr = CLSIDFromString(command_execute_id.c_str(), &class_id);
+  if (FAILED(hr)) {
+    LOG(DFATAL) << "Failed converting \"" << command_execute_id << "\" to "
+                   "CLSID; hr=0x" << std::hex << hr;
+  } else {
+    base::win::ScopedComPtr<IUnknown> command_execute_impl;
+    hr = command_execute_impl.CreateInstance(class_id, NULL,
+                                             CLSCTX_LOCAL_SERVER);
+    if (hr != REGDB_E_CLASSNOTREG) {
+      LOG(ERROR) << "Unexpected result creating CommandExecuteImpl; hr=0x"
+                 << std::hex << hr;
+    }
+  }
+
+  return true;
+}
+
 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;
   }
 
   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);
 
+  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);
+
   // 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.";
 
+    list->AddCallbackWorkItem(base::Bind(&ProbeCommandExecuteCallback,
+                                         handler_class_uuid));
+
     // 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 55 matching lines @@
 
     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"", 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);
   }
 }
 
 void AddActiveSetupWorkItems(const InstallerState& installer_state,
                              const Version& new_version,
                              const Product& product,
                              WorkItemList* list) {
   DCHECK(installer_state.operation() != InstallerState::UNINSTALL);
   BrowserDistribution* distribution = product.distribution();
 
@@ skipping 341 matching lines @@
                                  machine_state,
                                  setup_path,
                                  new_version,
                                  work_item_list,
                                  false,  // have_child_product
                                  cmd_line,
                                  kCmdQuickEnableApplicationHost);
 }
 
 }  // namespace installer