Allow chrome to become the os default handler for arbitrary protocols on mac/win.

chrome/installer/util/shell_util.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 defines functions that integrate Chrome in Windows shell. These
 // functions can be used by Chrome as well as Chrome installer. All of the
 // work is done by the local functions defined in anonymous namespace in
 // this class.
 
 #include "chrome/installer/util/shell_util.h"
 
 #include <windows.h>
 #include <shlobj.h>
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util-inl.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.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/util/browser_distribution.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/master_preferences.h"
 #include "chrome/installer/util/master_preferences_constants.h"
 
 #include "installer_util_strings.h"
 
@@ skipping 26 matching lines @@
     entries->push_front(new RegistryEntry(
         chrome_html_prog_id, ShellUtil::kRegUrlProtocol, L""));
     entries->push_front(new RegistryEntry(
         chrome_html_prog_id + ShellUtil::kRegDefaultIcon, icon_path));
     entries->push_front(new RegistryEntry(
         chrome_html_prog_id + ShellUtil::kRegShellOpen, open_cmd));
 
     return true;
   }
 
+  // This method returns a list of the system level registry entries
+  // needed to declare a capability of handling a protocol.
+  static bool GetProtocolCapabilityEntries(BrowserDistribution* dist,
+                                           const std::wstring& chrome_exe,
+                                           const std::wstring& suffix,
+                                           const std::wstring& protocol,
+                                           std::list<RegistryEntry*>* entries) {
+    std::wstring app_name = dist->GetApplicationName() + suffix;
+    std::wstring start_menu_entry(ShellUtil::kRegStartMenuInternet);
+    start_menu_entry.append(L"\\" + app_name);
+
+    std::wstring capabilities(start_menu_entry + L"\\Capabilities");
+
+    std::wstring html_prog_id(ShellUtil::kChromeHTMLProgId);
+    html_prog_id.append(suffix);
+    entries->push_front(new RegistryEntry(capabilities + L"\\URLAssociations",
+        protocol, html_prog_id));
+    return true;
+}
+
+
   // This method returns a list of all the system level registry entries that
   // are needed to register Chromium on the machine.
   static bool GetSystemEntries(BrowserDistribution* dist,
                                const std::wstring& chrome_exe,
                                const std::wstring& suffix,
                                std::list<RegistryEntry*>* entries) {
     std::wstring icon_path = ShellUtil::GetChromeIcon(dist, chrome_exe);
     std::wstring quoted_exe_path = L"\"" + chrome_exe + L"\"";
 
     std::wstring app_name = dist->GetApplicationName() + suffix;
@@ skipping 29 matching lines @@
     entries->push_front(new RegistryEntry(capabilities + L"\\StartMenu",
         L"StartMenuInternet", app_name));
 
     std::wstring html_prog_id(ShellUtil::kChromeHTMLProgId);
     html_prog_id.append(suffix);
     for (int i = 0; ShellUtil::kFileAssociations[i] != NULL; i++) {
       entries->push_front(new RegistryEntry(
           capabilities + L"\\FileAssociations",
           ShellUtil::kFileAssociations[i], html_prog_id));
     }
-    for (int i = 0; ShellUtil::kProtocolAssociations[i] != NULL; i++) {
+    for (int i = 0; ShellUtil::kPotentialProtocolAssociations[i] != NULL;
+        i++) {
       entries->push_front(new RegistryEntry(
           capabilities + L"\\URLAssociations",
-          ShellUtil::kProtocolAssociations[i], html_prog_id));
+          ShellUtil::kPotentialProtocolAssociations[i], html_prog_id));
     }
 
     FilePath chrome_path(chrome_exe);
     std::wstring app_path_key(ShellUtil::kAppPathsRegistryKey);
     file_util::AppendToPath(&app_path_key, chrome_path.BaseName().value());
     entries->push_front(new RegistryEntry(app_path_key, chrome_exe));
     entries->push_front(new RegistryEntry(app_path_key,
         ShellUtil::kAppPathsRegistryPathName, chrome_path.DirName().value()));
 
     // TODO: add chrome to open with list (Bug 16726).
     return true;
   }
 
   // This method returns a list of all the user level registry entries that
+  // are needed to make Chromium the default handler for a protocol.
+  static bool GetUserProtocolEntries(BrowserDistribution* dist,
+                                     const std::wstring& chrome_exe,
+                                     const std::wstring& suffix,
+                                     const std::wstring& protocol,
+                                     const std::wstring& chrome_icon,
+                                     const std::wstring& chrome_open,
+                                     std::list<RegistryEntry*>* entries) {
+    // Protocols associations.
+    std::wstring url_key(ShellUtil::kRegClasses);
+    file_util::AppendToPath(&url_key, protocol);
+
+    // This registry value tells Windows that this 'class' is a URL scheme
+    // so IE, explorer and other apps will route it to our handler.
+    // <root hkey>\Software\Classes\<protocol>\URL Protocol
+    entries->push_front(new RegistryEntry(url_key,
+        ShellUtil::kRegUrlProtocol, L""));
+
+    // <root hkey>\Software\Classes\<protocol>\DefaultIcon
+    std::wstring icon_key = url_key + ShellUtil::kRegDefaultIcon;
+    entries->push_front(new RegistryEntry(icon_key, chrome_icon));
+
+    // <root hkey>\Software\Classes\<protocol>\shell\open\command
+    std::wstring shell_key = url_key + ShellUtil::kRegShellOpen;
+    entries->push_front(new RegistryEntry(shell_key, chrome_open));
+
+    // <root hkey>\Software\Classes\<protocol>\shell\open\ddeexec
+    std::wstring dde_key = url_key + L"\\shell\\open\\ddeexec";
+    entries->push_front(new RegistryEntry(dde_key, L""));
+
+    // <root hkey>\Software\Classes\<protocol>\shell\@
+    std::wstring protocol_shell_key = url_key + ShellUtil::kRegShellPath;
+    entries->push_front(new RegistryEntry(protocol_shell_key, L"open"));
+
+    return true;
+  }
+
+  // This method returns a list of all the user level registry entries that
   // are needed to make Chromium default browser.
   static bool GetUserEntries(BrowserDistribution* dist,
                              const std::wstring& chrome_exe,
                              const std::wstring& suffix,
                              std::list<RegistryEntry*>* entries) {
     // File extension associations.
     std::wstring html_prog_id(ShellUtil::kChromeHTMLProgId);
     html_prog_id.append(suffix);
     for (int i = 0; ShellUtil::kFileAssociations[i] != NULL; i++) {
       std::wstring ext_key(ShellUtil::kRegClasses);
       file_util::AppendToPath(&ext_key, ShellUtil::kFileAssociations[i]);
       entries->push_front(new RegistryEntry(ext_key, html_prog_id));
     }
 
     // Protocols associations.
     std::wstring chrome_open = ShellUtil::GetChromeShellOpenCmd(chrome_exe);
     std::wstring chrome_icon = ShellUtil::GetChromeIcon(dist, chrome_exe);
-    for (int i = 0; ShellUtil::kProtocolAssociations[i] != NULL; i++) {
-      std::wstring url_key(ShellUtil::kRegClasses);
-      file_util::AppendToPath(&url_key, ShellUtil::kProtocolAssociations[i]);
-
-      // <root hkey>\Software\Classes\<protocol>\DefaultIcon
-      std::wstring icon_key = url_key + ShellUtil::kRegDefaultIcon;
-      entries->push_front(new RegistryEntry(icon_key, chrome_icon));
-
-      // <root hkey>\Software\Classes\<protocol>\shell\open\command
-      std::wstring shell_key = url_key + ShellUtil::kRegShellOpen;
-      entries->push_front(new RegistryEntry(shell_key, chrome_open));
-
-      // <root hkey>\Software\Classes\<protocol>\shell\open\ddeexec
-      std::wstring dde_key = url_key + L"\\shell\\open\\ddeexec";
-      entries->push_front(new RegistryEntry(dde_key, L""));
-
-      // <root hkey>\Software\Classes\<protocol>\shell\@
-      std::wstring protocol_shell_key = url_key + ShellUtil::kRegShellPath;
-      entries->push_front(new RegistryEntry(protocol_shell_key, L"open"));
+    for (int i = 0; ShellUtil::kBrowserProtocolAssociations[i] != NULL; i++) {
+      GetUserProtocolEntries(dist, chrome_exe, suffix,
+                             ShellUtil::kBrowserProtocolAssociations[i],
+                             chrome_icon, chrome_open, entries);
     }
 
     // start->Internet shortcut.
     std::wstring start_menu(ShellUtil::kRegStartMenuInternet);
     std::wstring app_name = dist->GetApplicationName() + suffix;
     entries->push_front(new RegistryEntry(start_menu, app_name));
     return true;
   }
 
   // Generate work_item tasks required to create current registry entry and
@@ skipping 104 matching lines @@
   RegistryEntry::GetSystemEntries(dist, chrome_exe, suffix, &entries);
   for (std::list<RegistryEntry*>::const_iterator itr = entries.begin();
        itr != entries.end() && registered; ++itr) {
     // We do not need registered = registered && ... since the loop condition
     // is set to exit early.
     registered = (*itr)->ExistsInHKLM();
   }
   return registered;
 }
 
+// This method checks if Chrome is already registered on the local machine
+// for the requested protocol. It just checks the one value required for this.
+bool IsChromeRegisteredForProtocol(BrowserDistribution* dist,
+                                   const std::wstring& chrome_exe,
+                                   const std::wstring& suffix,
+                                   const std::wstring& protocol) {
+  bool registered = true;
+  std::list<RegistryEntry*> entries;
+  STLElementDeleter<std::list<RegistryEntry*>> entries_deleter(&entries);
+  RegistryEntry::GetProtocolCapabilityEntries(dist, chrome_exe, suffix,
+      protocol, &entries);
+  for (std::list<RegistryEntry*>::const_iterator itr = entries.begin();
+       itr != entries.end() && registered; ++itr) {
+    // We do not need registered = registered && ... since the loop condition
+    // is set to exit early.
+    registered = (*itr)->ExistsInHKLM();
+  }
+  return registered;
+}
+
 // This method registers Chrome on Vista by launching an elevated setup.exe.
 // That will show the user the standard Vista elevation prompt. If the user
 // accepts it the new process will make the necessary changes and return SUCCESS
 // that we capture and return.
+// If protocol is non-empty we will also register Chrome as being capable of
+// handling the protocol.
 bool ElevateAndRegisterChrome(BrowserDistribution* dist,
                               const std::wstring& chrome_exe,
-                              const std::wstring& suffix) {
+                              const std::wstring& suffix,
+                              const std::wstring& protocol) {
   FilePath exe_path =
       FilePath::FromWStringHack(chrome_exe).DirName()
           .Append(installer::kSetupExe);
   if (!file_util::PathExists(exe_path)) {
     HKEY reg_root = InstallUtil::IsPerUserInstall(chrome_exe.c_str()) ?
         HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE;
     RegKey key(reg_root, dist->GetUninstallRegPath().c_str(), KEY_READ);
     std::wstring uninstall_string;
     key.ReadValue(installer::kUninstallStringField, &uninstall_string);
     CommandLine command_line = CommandLine::FromString(uninstall_string);
     exe_path = command_line.GetProgram();
   }
 
   if (file_util::PathExists(exe_path)) {
     CommandLine cmd(exe_path);
     cmd.AppendSwitchNative(installer::switches::kRegisterChromeBrowser,
                            chrome_exe);
     if (!suffix.empty()) {
       cmd.AppendSwitchNative(
           installer::switches::kRegisterChromeBrowserSuffix, suffix);
     }
 
     CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
     if (browser_command_line.HasSwitch(switches::kChromeFrame)) {
       cmd.AppendSwitch(installer::switches::kChromeFrame);
     }
 
+    if (!protocol.empty()) {
+      cmd.AppendSwitchNative(
+        installer::switches::kRegisterURLProtocol, protocol);
+    }
+
     DWORD ret_val = 0;
     InstallUtil::ExecuteExeAsAdmin(cmd, &ret_val);
     if (ret_val == 0)
       return true;
   }
   return false;
 }
 
 // This method tries to figure out if another user has already registered her
 // own copy of Chrome so that we can avoid overwriting it and append current
@@ skipping 45 matching lines @@
         return false;
       else
         one_mismatch = true;
     }
   }
   return true;
 }
 
 }  // namespace
 
-
 const wchar_t* ShellUtil::kRegDefaultIcon = L"\\DefaultIcon";
 const wchar_t* ShellUtil::kRegShellPath = L"\\shell";
 const wchar_t* ShellUtil::kRegShellOpen = L"\\shell\\open\\command";
 const wchar_t* ShellUtil::kRegStartMenuInternet =
     L"Software\\Clients\\StartMenuInternet";
 const wchar_t* ShellUtil::kRegClasses = L"Software\\Classes";
 const wchar_t* ShellUtil::kRegRegisteredApplications =
     L"Software\\RegisteredApplications";
 const wchar_t* ShellUtil::kRegVistaUrlPrefs =
     L"Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\"
     L"http\\UserChoice";
 const wchar_t* ShellUtil::kAppPathsRegistryKey =
     L"Software\\Microsoft\\Windows\\CurrentVersion\\App Paths";
 const wchar_t* ShellUtil::kAppPathsRegistryPathName = L"Path";
 
 #if defined(GOOGLE_CHROME_BUILD)
 const wchar_t* ShellUtil::kChromeHTMLProgId = L"ChromeHTML";
 const wchar_t* ShellUtil::kChromeHTMLProgIdDesc = L"Chrome HTML Document";
 #else
 const wchar_t* ShellUtil::kChromeHTMLProgId = L"ChromiumHTML";
 const wchar_t* ShellUtil::kChromeHTMLProgIdDesc = L"Chromium HTML Document";
 #endif
 
 const wchar_t* ShellUtil::kFileAssociations[] = {L".htm", L".html", L".shtml",
     L".xht", L".xhtml", NULL};
-const wchar_t* ShellUtil::kProtocolAssociations[] = {L"ftp", L"http", L"https",
-    NULL};
+const wchar_t* ShellUtil::kBrowserProtocolAssociations[] = {L"ftp", L"http",
+    L"https", NULL};
+const wchar_t* ShellUtil::kPotentialProtocolAssociations[] = {L"ftp", L"http",
+    L"https", L"mailto", L"webcal", NULL};
 const wchar_t* ShellUtil::kRegUrlProtocol = L"URL Protocol";
 
 bool ShellUtil::AdminNeededForRegistryCleanup(BrowserDistribution* dist,
                                               const std::wstring& suffix) {
   bool cleanup_needed = false;
   std::list<RegistryEntry*> entries;
   STLElementDeleter<std::list<RegistryEntry*>> entries_deleter(&entries);
   RegistryEntry::GetProgIdEntries(dist, L"chrome.exe", suffix, &entries);
   RegistryEntry::GetSystemEntries(dist, L"chrome.exe", suffix, &entries);
   for (std::list<RegistryEntry*>::const_iterator itr = entries.begin();
@@ skipping 192 matching lines @@
   if (!dist->CanSetAsDefault())
     return false;
 
   ShellUtil::RegisterChromeBrowser(dist, chrome_exe, L"", elevate_if_not_admin);
 
   bool ret = true;
   // First use the new "recommended" way on Vista to make Chrome default
   // browser.
   if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
     VLOG(1) << "Registering Chrome as default browser on Vista.";
-    IApplicationAssociationRegistration* pAAR;
-    HRESULT hr = CoCreateInstance(CLSID_ApplicationAssociationRegistration,
-        NULL, CLSCTX_INPROC, __uuidof(IApplicationAssociationRegistration),
-        (void**)&pAAR);
+    base::win::ScopedComPtr<IApplicationAssociationRegistration> pAAR;
+    HRESULT hr = pAAR.CreateInstance(CLSID_ApplicationAssociationRegistration,
+        NULL, CLSCTX_INPROC);
     if (SUCCEEDED(hr)) {
       std::wstring app_name = dist->GetApplicationName();
       std::wstring suffix;
       if (ShellUtil::GetUserSpecificDefaultBrowserSuffix(dist, &suffix))
         app_name += suffix;
 
-      hr = pAAR->SetAppAsDefaultAll(app_name.c_str());
-      pAAR->Release();
+      for (int i = 0;
+           SUCCEEDED(hr) && ShellUtil::kBrowserProtocolAssociations[i] != NULL;
+           i++) {
+        hr = pAAR->SetAppAsDefault(app_name.c_str(),
+            ShellUtil::kBrowserProtocolAssociations[i], AT_URLPROTOCOL);
+      }
+
+      for (int i = 0;
+           SUCCEEDED(hr) && ShellUtil::kFileAssociations[i] != NULL; i++) {
+        hr = pAAR->SetAppAsDefault(app_name.c_str(),
+            ShellUtil::kFileAssociations[i], AT_FILEEXTENSION);
+      }
     }
     if (!SUCCEEDED(hr)) {
       ret = false;
-      LOG(ERROR) << "Could not make Chrome default browser.";
+      LOG(ERROR) << "Could not make Chrome default browser (Vista): HRESULT="
+                 << hr << ".";
     }
   }
 
   // Now use the old way to associate Chrome with supported protocols and file
   // associations. This should not be required on Vista but since some
   // applications still read Software\Classes\http key directly, we have to do
   // this on Vista also.
 
   std::list<RegistryEntry*> entries;
   STLElementDeleter<std::list<RegistryEntry*>> entries_deleter(&entries);
   std::wstring suffix;
   if (!GetUserSpecificDefaultBrowserSuffix(dist, &suffix))
     suffix = L"";
   RegistryEntry::GetUserEntries(dist, chrome_exe, suffix, &entries);
   // Change the default browser for current user.
   if ((shell_change & ShellUtil::CURRENT_USER) &&
-      !AddRegistryEntries(HKEY_CURRENT_USER, entries))
-      ret = false;
+      !AddRegistryEntries(HKEY_CURRENT_USER, entries)) {
+    ret = false;
+    LOG(ERROR) << "Could not make Chrome default browser (XP/current user).";
+  }
 
   // Chrome as default browser at system level.
   if ((shell_change & ShellUtil::SYSTEM_LEVEL) &&
-      !AddRegistryEntries(HKEY_LOCAL_MACHINE, entries))
+      !AddRegistryEntries(HKEY_LOCAL_MACHINE, entries)) {
     ret = false;
+    LOG(ERROR) << "Could not make Chrome default browser (XP/system level).";
+  }
 
   // Send Windows notification event so that it can update icons for
   // file associations.
   SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, NULL, NULL);
   return ret;
 }
 
+bool ShellUtil::MakeChromeDefaultProtocolClient(BrowserDistribution* dist,
+                                                const std::wstring& chrome_exe,
+                                                const std::wstring& protocol) {
+  if (!dist->CanSetAsDefault())
+    return false;
+
+  ShellUtil::RegisterChromeForProtocol(dist, chrome_exe, L"", protocol, true);
+
+  bool ret = true;
+  // First use the new "recommended" way on Vista to make Chrome default
+  // protocol handler.
+  if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
+    VLOG(1) << "Registering Chrome as default handler for " << protocol
+            << " on Vista.";
+    base::win::ScopedComPtr<IApplicationAssociationRegistration> pAAR;
+    HRESULT hr = pAAR.CreateInstance(CLSID_ApplicationAssociationRegistration,
+      NULL, CLSCTX_INPROC);
+    if (SUCCEEDED(hr)) {
+      std::wstring app_name = dist->GetApplicationName();
+      std::wstring suffix;
+      if (ShellUtil::GetUserSpecificDefaultBrowserSuffix(dist, &suffix))
+        app_name += suffix;
+
+      hr = pAAR->SetAppAsDefault(app_name.c_str(), protocol.c_str(),
+                                 AT_URLPROTOCOL);
+    }
+    if (!SUCCEEDED(hr)) {
+      ret = false;
+      LOG(ERROR) << "Could not make Chrome default protocol client (Vista):"
+                 << " HRESULT=" << hr << ".";
+    }
+  }
+
+  // Now use the old way to associate Chrome with the desired protocol. This
+  // should not be required on Vista but since some applications still read
+  // Software\Classes\http key directly, we have to do this on Vista also.
+
+  std::list<RegistryEntry*> entries;
+  STLElementDeleter<std::list<RegistryEntry*>> entries_deleter(&entries);
+  std::wstring suffix;
+  if (!GetUserSpecificDefaultBrowserSuffix(dist, &suffix))
+    suffix = L"";
+  std::wstring chrome_open = ShellUtil::GetChromeShellOpenCmd(chrome_exe);
+  std::wstring chrome_icon = ShellUtil::GetChromeIcon(dist, chrome_exe);
+  RegistryEntry::GetUserProtocolEntries(dist, chrome_exe, suffix, protocol,
+                                        chrome_icon, chrome_open, &entries);
+  // Change the default protocol handler for current user.
+  if (!AddRegistryEntries(HKEY_CURRENT_USER, entries)) {
+      ret = false;
+      LOG(ERROR) << "Could not make Chrome default protocol client (XP).";
+  }
+
+  return ret;
+}
+
 bool ShellUtil::RegisterChromeBrowser(BrowserDistribution* dist,
                                       const std::wstring& chrome_exe,
                                       const std::wstring& unique_suffix,
                                       bool elevate_if_not_admin) {
   if (!dist->CanSetAsDefault())
     return false;
 
   // First figure out we need to append a suffix to the registry entries to
   // make them unique.
   std::wstring suffix;
@@ skipping 14 matching lines @@
     std::list<RegistryEntry*> entries;
     STLElementDeleter<std::list<RegistryEntry*>> entries_deleter(&entries);
     RegistryEntry::GetProgIdEntries(dist, chrome_exe, suffix, &entries);
     RegistryEntry::GetSystemEntries(dist, chrome_exe, suffix, &entries);
     return AddRegistryEntries(HKEY_LOCAL_MACHINE, entries);
   }
 
   // If user is not an admin and OS is Vista, try to elevate and register.
   if (elevate_if_not_admin &&
       base::win::GetVersion() >= base::win::VERSION_VISTA &&
-      ElevateAndRegisterChrome(dist, chrome_exe, suffix))
+      ElevateAndRegisterChrome(dist, chrome_exe, suffix, L""))
     return true;
 
   // If we got to this point then all we can do is create ProgIds under HKCU
   // on XP as well as Vista.
   std::list<RegistryEntry*> entries;
   STLElementDeleter<std::list<RegistryEntry*>> entries_deleter(&entries);
   RegistryEntry::GetProgIdEntries(dist, chrome_exe, L"", &entries);
   return AddRegistryEntries(HKEY_CURRENT_USER, entries);
 }
 
+bool ShellUtil::RegisterChromeForProtocol(BrowserDistribution* dist,
+                                          const std::wstring& chrome_exe,
+                                          const std::wstring& unique_suffix,
+                                          const std::wstring& protocol,
+                                          bool elevate_if_not_admin) {
+  if (!dist->CanSetAsDefault())
+    return false;
+
+  // Figure out we need to append a suffix to the registry entries to
+  // make them unique.
+  std::wstring suffix;
+  if (!unique_suffix.empty()) {
+    suffix = unique_suffix;
+  } else if (InstallUtil::IsPerUserInstall(chrome_exe.c_str()) &&
+             !GetUserSpecificDefaultBrowserSuffix(dist, &suffix) &&
+             !AnotherUserHasDefaultBrowser(dist, chrome_exe)) {
+    suffix = L"";
+  }
+
+  // Check if Chromium is already registered with this suffix.
+  if (IsChromeRegisteredForProtocol(dist, chrome_exe, suffix, protocol))
+    return true;
+
+  if (IsUserAnAdmin()) {
+    // We can do this operation directly.
+    // If we're not registered at all, try to register. If that fails
+    // we should give up.
+    if (!IsChromeRegistered(dist, chrome_exe, suffix) &&
+        !RegisterChromeBrowser(dist, chrome_exe, suffix, false)) {
+      return false;
+    }
+
+    // Write in the capabillity for the protocol.
+    std::list<RegistryEntry*> entries;
+    STLElementDeleter<std::list<RegistryEntry*>> entries_deleter(&entries);
+    RegistryEntry::GetProtocolCapabilityEntries(dist, chrome_exe, suffix,
+        protocol, &entries);
+    return AddRegistryEntries(HKEY_LOCAL_MACHINE, entries);
+  } else if (elevate_if_not_admin &&
+             base::win::GetVersion() >= base::win::VERSION_VISTA) {
+    // Elevate to do the whole job
+    return ElevateAndRegisterChrome(dist, chrome_exe, suffix, protocol);
+  } else {
+    // we need admin rights to register our capability. If we don't
+    // have them and can't elevate, give up.
+    return false;
+  }
+}
+
 bool ShellUtil::RemoveChromeDesktopShortcut(BrowserDistribution* dist,
                                             int shell_change, bool alternate) {
   std::wstring shortcut_name;
   if (!ShellUtil::GetChromeShortcutName(dist, &shortcut_name, alternate))
     return false;
 
   bool ret = true;
   if (shell_change & ShellUtil::CURRENT_USER) {
     FilePath shortcut_path;
     if (ShellUtil::GetDesktopPath(false, &shortcut_path)) {
@@ skipping 76 matching lines @@
         chrome_exe.c_str(),                // target
         shortcut.c_str(),                  // shortcut
         chrome_path.c_str(),               // working dir
         NULL,                              // arguments
         description.c_str(),               // description
         chrome_exe.c_str(),                // icon file
         icon_index,                        // icon index
         dist->GetBrowserAppId().c_str());  // app id
   }
 }