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

chrome/browser/shell_integration_win.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.
 
 #include "chrome/browser/shell_integration.h"
 
 #include <windows.h>
 #include <shobjidl.h>
 #include <propkey.h>
 #include <propvarutil.h>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/windows_version.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_paths_internal.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/installer/setup/setup_util.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/create_reg_key_work_item.h"
 #include "chrome/installer/util/set_reg_value_work_item.h"
 #include "chrome/installer/util/shell_util.h"
 #include "chrome/installer/util/util_constants.h"
 #include "chrome/installer/util/work_item.h"
 #include "chrome/installer/util/work_item_list.h"
 #include "content/browser/browser_thread.h"
 
 namespace {
@@ skipping 243 matching lines @@
   if (!ShellUtil::MakeChromeDefault(dist, ShellUtil::CURRENT_USER,
                                     chrome_exe.value(), true)) {
     LOG(ERROR) << "Chrome could not be set as default browser.";
     return false;
   }
 
   VLOG(1) << "Chrome registered as default browser.";
   return true;
 }
 
-ShellIntegration::DefaultBrowserState ShellIntegration::IsDefaultBrowser() {
+bool ShellIntegration::SetAsDefaultProtocolClient(const std::string& protocol) {
+  if (protocol.empty())
+    return false;
+
+  FilePath chrome_exe;
+  if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
+    LOG(ERROR) << "Error getting app exe path";
+    return false;
+  }
+
+  std::wstring wprotocol = UTF8ToWide(protocol);
+  BrowserDistribution* dist = BrowserDistribution::GetDistribution();
+  if (!ShellUtil::MakeChromeDefaultProtocolClient(dist, chrome_exe.value(),
+        wprotocol)) {
+    LOG(ERROR) << "Chrome could not be set as default handler for "
+               << protocol << ".";
+    return false;
+  }
+
+  VLOG(1) << "Chrome registered as default handler for " << protocol << ".";
+  return true;
+}
+
+ShellIntegration::DefaultWebClientState ShellIntegration::IsDefaultBrowser() {
   // First determine the app path. If we can't determine what that is, we have
   // bigger fish to fry...
   FilePath app_path;
   if (!PathService::Get(base::FILE_EXE, &app_path)) {
     LOG(ERROR) << "Error getting app exe path";
-    return UNKNOWN_DEFAULT_BROWSER;
+    return UNKNOWN_DEFAULT_WEB_CLIENT;
   }
   // When we check for default browser we don't necessarily want to count file
   // type handlers and icons as having changed the default browser status,
   // since the user may have changed their shell settings to cause HTML files
   // to open with a text editor for example. We also don't want to aggressively
   // claim FTP, since the user may have a separate FTP client. It is an open
   // question as to how to "heal" these settings. Perhaps the user should just
   // re-run the installer or run with the --set-default-browser command line
   // flag. There is doubtless some other key we can hook into to cause "Repair"
   // to show up in Add/Remove programs for us.
   const std::wstring kChromeProtocols[] = {L"http", L"https"};
 
   if (base::win::GetVersion() >= base::win::VERSION_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))
-      return NOT_DEFAULT_BROWSER;
+      return NOT_DEFAULT_WEB_CLIENT;
 
     BrowserDistribution* dist = BrowserDistribution::GetDistribution();
     std::wstring app_name = dist->GetApplicationName();
     // If a user specific default browser entry exists, we check for that
     // app name being default. If not, then default browser is just called
     // Google Chrome or Chromium so we do not append suffix to app name.
     std::wstring suffix;
     if (ShellUtil::GetUserSpecificDefaultBrowserSuffix(dist, &suffix))
       app_name += suffix;
 
     for (int i = 0; i < _countof(kChromeProtocols); i++) {
       BOOL result = TRUE;
       hr = pAAR->QueryAppIsDefault(kChromeProtocols[i].c_str(), AT_URLPROTOCOL,
           AL_EFFECTIVE, app_name.c_str(), &result);
       if (!SUCCEEDED(hr) || result == FALSE) {
-        pAAR->Release();
-        return NOT_DEFAULT_BROWSER;
+        return NOT_DEFAULT_WEB_CLIENT;
       }
     }
-    pAAR->Release();
   } else {
     std::wstring short_app_path;
-    GetShortPathName(app_path.value().c_str(),
-                     WriteInto(&short_app_path, MAX_PATH),
-                     MAX_PATH);
+    DWORD get_path_result = GetShortPathName(app_path.value().c_str(),
+        WriteInto(&short_app_path, MAX_PATH), MAX_PATH);
+    if (!get_path_result || get_path_result > MAX_PATH) {
+      LOG(ERROR) << "GetShortPathName error in IsDefaultBrowser.";
+      return UNKNOWN_DEFAULT_WEB_CLIENT;
+    }
 
     // open command for protocol associations
     for (int i = 0; i < _countof(kChromeProtocols); i++) {
       // Check in HKEY_CLASSES_ROOT that is the result of merge between
       // HKLM and HKCU
       HKEY root_key = HKEY_CLASSES_ROOT;
       // Check <protocol>\shell\open\command
       std::wstring key_path(kChromeProtocols[i] + ShellUtil::kRegShellOpen);
       base::win::RegKey key(root_key, key_path.c_str(), KEY_READ);
       std::wstring value;
       if (!key.Valid() || (key.ReadValue(L"", &value) != ERROR_SUCCESS))
-        return NOT_DEFAULT_BROWSER;
+        return NOT_DEFAULT_WEB_CLIENT;
       // Need to normalize path in case it's been munged.
       CommandLine command_line = CommandLine::FromString(value);
       std::wstring short_path;
-      GetShortPathName(command_line.GetProgram().value().c_str(),
-                       WriteInto(&short_path, MAX_PATH), MAX_PATH);
+      get_path_result = GetShortPathName(
+          command_line.GetProgram().value().c_str(),
+          WriteInto(&short_path, MAX_PATH), MAX_PATH);
+      if (!get_path_result || get_path_result > MAX_PATH) {
+        LOG(ERROR) << "GetShortPathName error in IsDefaultBrowser.";
+        return UNKNOWN_DEFAULT_WEB_CLIENT;
+      }
       if (!FilePath::CompareEqualIgnoreCase(short_path, short_app_path))
-        return NOT_DEFAULT_BROWSER;
+        return NOT_DEFAULT_WEB_CLIENT;
     }
   }
-  return IS_DEFAULT_BROWSER;
+  return IS_DEFAULT_WEB_CLIENT;
+}
+
+ShellIntegration::DefaultWebClientState
+    ShellIntegration::IsDefaultProtocolClient(const std::string& protocol) {
+  if (protocol.empty())
+    return UNKNOWN_DEFAULT_WEB_CLIENT;
+
+  // Determine the app path. If we can't determine what that is, we have
+  // bigger fish to fry...
+  FilePath app_path;
+  if (!PathService::Get(base::FILE_EXE, &app_path)) {
+    LOG(ERROR) << "Error getting app exe path";
+    return UNKNOWN_DEFAULT_WEB_CLIENT;
+  }
+
+  std::wstring wprotocol = UTF8ToWide(protocol);
+
+  if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
+    base::win::ScopedComPtr<IApplicationAssociationRegistration> pAAR;
+    HRESULT hr = pAAR.CreateInstance(CLSID_ApplicationAssociationRegistration,
+        NULL, CLSCTX_INPROC);
+    if (!SUCCEEDED(hr))
+      return NOT_DEFAULT_WEB_CLIENT;
+
+    BrowserDistribution* dist = BrowserDistribution::GetDistribution();
+    std::wstring app_name = dist->GetApplicationName();
+    // If a user specific default browser entry exists, we check for that
+    // app name being default. If not, then default browser is just called
+    // Google Chrome or Chromium so we do not append suffix to app name.
+    std::wstring suffix;
+    if (ShellUtil::GetUserSpecificDefaultBrowserSuffix(dist, &suffix))
+      app_name += suffix;
+
+    BOOL result = TRUE;
+    hr = pAAR->QueryAppIsDefault(wprotocol.c_str(), AT_URLPROTOCOL,
+        AL_EFFECTIVE, app_name.c_str(), &result);
+    if (!SUCCEEDED(hr) || result == FALSE) {
+      return NOT_DEFAULT_WEB_CLIENT;
+    }
+  } else {
+    std::wstring short_app_path;
+    DWORD get_path_result = GetShortPathName(app_path.value().c_str(),
+        WriteInto(&short_app_path, MAX_PATH), MAX_PATH);
+    if (!get_path_result || get_path_result > MAX_PATH) {
+      LOG(ERROR) << "GetShortPathName error in IsDefaultProtocolClient.";
+      return UNKNOWN_DEFAULT_WEB_CLIENT;
+    }
+
+    // open command for protocol associations
+    // Check in HKEY_CLASSES_ROOT that is the result of merge between
+    // HKLM and HKCU
+    HKEY root_key = HKEY_CLASSES_ROOT;
+    // Check <protocol>\shell\open\command
+    std::wstring key_path(wprotocol + ShellUtil::kRegShellOpen);
+    base::win::RegKey key(root_key, key_path.c_str(), KEY_READ);
+    std::wstring value;
+    if (!key.Valid() || (key.ReadValue(L"", &value) != ERROR_SUCCESS))
+      return NOT_DEFAULT_WEB_CLIENT;
+    // Need to normalize path in case it's been munged.
+    CommandLine command_line = CommandLine::FromString(value);
+    std::wstring short_path;
+    get_path_result = GetShortPathName(
+        command_line.GetProgram().value().c_str(),
+        WriteInto(&short_path, MAX_PATH), MAX_PATH);
+    if (!get_path_result || get_path_result > MAX_PATH) {
+      LOG(ERROR) << "GetShortPathName error in IsDefaultProtocolClient.";
+      return UNKNOWN_DEFAULT_WEB_CLIENT;
+    }
+    if (!FilePath::CompareEqualIgnoreCase(short_path, short_app_path))
+      return NOT_DEFAULT_WEB_CLIENT;
+  }
+  return IS_DEFAULT_WEB_CLIENT;
 }
 
 // There is no reliable way to say which browser is default on a machine (each
 // browser can have some of the protocols/shortcuts). So we look for only HTTP
 // protocol handler. Even this handler is located at different places in
 // registry on XP and Vista:
 // - HKCR\http\shell\open\command (XP)
 // - HKCU\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\
 //   http\UserChoice (Vista)
 // This method checks if Firefox is defualt browser by checking these
@@ skipping 41 matching lines @@
                   profile_path);
 }
 
 void ShellIntegration::MigrateChromiumShortcuts() {
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return;
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE, new MigrateChromiumShortcutsTask());
 }