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

chrome/installer/util/install_util.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.
 //
 // See the corresponding header file for description of the functions in this
 // file.
 
 #include "chrome/installer/util/install_util.h"
 
 #include <shellapi.h>
 #include <shlobj.h>
 #include <shlwapi.h>
 
 #include <algorithm>
 
 #include "base/command_line.h"
+#include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "base/win/registry.h"
 #include "base/win/windows_version.h"
 #include "chrome/installer/util/browser_distribution.h"
@@ skipping 304 matching lines @@
                                           installer::kInstallBinaryDir) &&
          FilePath::CompareEqualIgnoreCase(exe_dir.DirName().BaseName().value(),
                                           chrome_sxs_dir);
 }
 
 bool InstallUtil::IsChromeSxSProcess() {
   static bool sxs = CheckIsChromeSxSProcess();
   return sxs;
 }
 
+bool InstallUtil::HasDelegateExecuteHandler(BrowserDistribution* dist,
+                                            const string16& chrome_exe) {
+  bool found = false;
+  bool system_install = !IsPerUserInstall(chrome_exe.c_str());
+  scoped_ptr<Version> version(GetChromeVersion(dist, system_install));
+  if (!version.get()) {

[gab, 2012/04/25 05:18:29]

I think having the main logic first feels cleaner:
if (version.get()) {
  (main logic)
} else {
  LOG(ERROR) ...
} 

Alternatively I also like:
if (!version.get()) {
  LOG(ERROR) ...
  return false;
}
(main logic)

Your call :).

[grt (UTC plus 2), 2012/04/25 13:05:11]

I often do, too.  When the else{} clause is a one or two line error case,
though, I tend to put it first.  As the main logic gets bigger (as it often
does), it pushes the error handling further and further away from its raison
d'etre, making it harder to review.  By putting it first, it's easy to see both
sides of the if/else regardless of how big the main logic gets.  Personal
preference...
Although I'm not fanatical about it, I prefer one exit to functions.  If your
curious, Tommi can give you some arguments about why multiple exits can
potentially add overhead.  :-)

[gab, 2012/04/25 13:44:02]

Reading overhead or actual overhead in the binary?
I disagree with reading overhead given at least by seeing the return I know this
case is handled and done; where as without a return I have to skim over the
entire main logic to see if there is something else happening after the else
block (but before the global return).

[grt (UTC plus 2), 2012/04/25 14:33:49]

In the binary.

+    LOG(ERROR) << __FUNCTION__ << " failed to determine version of "
+               << dist->GetAppShortCutName() << " installed at " << chrome_exe;
+  } else {
+    FilePath handler(
+        FilePath(chrome_exe).DirName()
+            .AppendASCII(version->GetString())
+            .Append(installer::kDelegateExecuteExe));
+    found = file_util::PathExists(handler);
+  }
+  return found;
+}
+
 // This method tries to delete a registry key and logs an error message
 // in case of failure. It returns true if deletion is successful,
 // otherwise false.
 bool InstallUtil::DeleteRegistryKey(HKEY root_key,
                                     const std::wstring& key_path) {
   VLOG(1) << "Deleting registry key " << key_path;
   LONG result = ::SHDeleteKey(root_key, key_path.c_str());
   if (result != ERROR_SUCCESS && result != ERROR_FILE_NOT_FOUND) {
     LOG(ERROR) << "Failed to delete registry key: " << key_path
                << " error: " << result;
@@ skipping 101 matching lines @@
   int len = GetDateFormatW(LOCALE_INVARIANT, 0, NULL, kDateFormat,
                            date_str, arraysize(date_str));
   if (len) {
     --len;  // Subtract terminating \0.
   } else {
     PLOG(DFATAL) << "GetDateFormat";
   }
 
   return std::wstring(date_str, len);
 }