Move "default for protocol" probing logic out of shell_integration_win.cc into shell_util.cc.

chrome/browser/shell_integration_win.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.
 
 #include "chrome/browser/shell_integration.h"
 
 #include <windows.h>
 #include <shobjidl.h>
 #include <propkey.h>
 #include <propvarutil.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/registry.h"
-#include "base/win/scoped_co_mem.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/shortcut.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_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/install_util.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/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace {
 
-// Gets the short (8.3) form of |path|, putting the result in |short_path| and
-// returning true on success.  |short_path| is not modified on failure.
-bool ShortNameFromPath(const FilePath& path, string16* short_path) {
-  DCHECK(short_path);
-  string16 result(MAX_PATH, L'\0');
-  DWORD short_length = GetShortPathName(path.value().c_str(), &result[0],
-                                        result.size());
-  if (short_length == 0 || short_length > result.size()) {
-    PLOG(ERROR) << "Error getting short (8.3) path";
-    return false;
-  }
-
-  result.resize(short_length);
-  short_path->swap(result);
-  return true;
-}
-
-// Probe using IApplicationAssociationRegistration::QueryCurrentDefault
-// (Windows 8); see ProbeProtocolHandlers.  This mechanism is not suitable for
-// use on previous versions of Windows despite the presence of
-// QueryCurrentDefault on them since versions of Windows prior to Windows 8
-// did not perform validation on the ProgID registered as the current default.
-// As a result, stale ProgIDs could be returned, leading to false positives.
-ShellIntegration::DefaultWebClientState ProbeCurrentDefaultHandlers(
-    const wchar_t* const* protocols,
-    size_t num_protocols) {
-  base::win::ScopedComPtr<IApplicationAssociationRegistration> registration;
-  HRESULT hr = registration.CreateInstance(
-      CLSID_ApplicationAssociationRegistration, NULL, CLSCTX_INPROC);
-  if (FAILED(hr))
-    return ShellIntegration::UNKNOWN_DEFAULT_WEB_CLIENT;
-
-  BrowserDistribution* dist = BrowserDistribution::GetDistribution();
-  FilePath chrome_exe;
-  if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
-    NOTREACHED();
-    return ShellIntegration::UNKNOWN_DEFAULT_WEB_CLIENT;
-  }
-  string16 prog_id(ShellUtil::kChromeHTMLProgId);
-  prog_id += ShellUtil::GetCurrentInstallationSuffix(dist, chrome_exe.value());
-
-  for (size_t i = 0; i < num_protocols; ++i) {
-    base::win::ScopedCoMem<wchar_t> current_app;
-    hr = registration->QueryCurrentDefault(protocols[i], AT_URLPROTOCOL,
-                                           AL_EFFECTIVE, &current_app);
-    if (FAILED(hr) || prog_id.compare(current_app) != 0)
-      return ShellIntegration::NOT_DEFAULT_WEB_CLIENT;
-  }
-
-  return ShellIntegration::IS_DEFAULT_WEB_CLIENT;
-}
-
-// Probe using IApplicationAssociationRegistration::QueryAppIsDefault (Vista and
-// Windows 7); see ProbeProtocolHandlers.
-ShellIntegration::DefaultWebClientState ProbeAppIsDefaultHandlers(
-    const wchar_t* const* protocols,
-    size_t num_protocols) {
-  base::win::ScopedComPtr<IApplicationAssociationRegistration> registration;
-  HRESULT hr = registration.CreateInstance(
-      CLSID_ApplicationAssociationRegistration, NULL, CLSCTX_INPROC);
-  if (FAILED(hr))
-    return ShellIntegration::UNKNOWN_DEFAULT_WEB_CLIENT;
-
-  BrowserDistribution* dist = BrowserDistribution::GetDistribution();
-  FilePath chrome_exe;
-  if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
-    NOTREACHED();
-    return ShellIntegration::UNKNOWN_DEFAULT_WEB_CLIENT;
-  }
-  string16 app_name(ShellUtil::GetApplicationName(dist, chrome_exe.value()));
-
-  BOOL result;
-  for (size_t i = 0; i < num_protocols; ++i) {
-    result = TRUE;
-    hr = registration->QueryAppIsDefault(protocols[i], AT_URLPROTOCOL,
-        AL_EFFECTIVE, app_name.c_str(), &result);
-    if (FAILED(hr) || result == FALSE)
-      return ShellIntegration::NOT_DEFAULT_WEB_CLIENT;
-  }
-
-  return ShellIntegration::IS_DEFAULT_WEB_CLIENT;
-}
-
-// Probe the current commands registered to handle the shell "open" verb for
-// |protocols| (Windows XP); see ProbeProtocolHandlers.
-ShellIntegration::DefaultWebClientState ProbeOpenCommandHandlers(
-    const wchar_t* const* protocols,
-    size_t num_protocols) {
-  // Get the path to the current exe (Chrome).
-  FilePath app_path;
-  if (!PathService::Get(base::FILE_EXE, &app_path)) {
-    LOG(ERROR) << "Error getting app exe path";
-    return ShellIntegration::UNKNOWN_DEFAULT_WEB_CLIENT;
-  }
-
-  // Get its short (8.3) form.
-  string16 short_app_path;
-  if (!ShortNameFromPath(app_path, &short_app_path))
-    return ShellIntegration::UNKNOWN_DEFAULT_WEB_CLIENT;
-
-  const HKEY root_key = HKEY_CLASSES_ROOT;
-  string16 key_path;
-  base::win::RegKey key;
-  string16 value;
-  CommandLine command_line(CommandLine::NO_PROGRAM);
-  string16 short_path;
-
-  for (size_t i = 0; i < num_protocols; ++i) {
-    // Get the command line from HKCU\<protocol>\shell\open\command.
-    key_path.assign(protocols[i]).append(ShellUtil::kRegShellOpen);
-    if ((key.Open(root_key, key_path.c_str(),
-                  KEY_QUERY_VALUE) != ERROR_SUCCESS) ||
-        (key.ReadValue(L"", &value) != ERROR_SUCCESS)) {
-      return ShellIntegration::NOT_DEFAULT_WEB_CLIENT;
-    }
-
-    // Need to normalize path in case it's been munged.
-    command_line = CommandLine::FromString(value);
-    if (!ShortNameFromPath(command_line.GetProgram(), &short_path))
-      return ShellIntegration::UNKNOWN_DEFAULT_WEB_CLIENT;
-
-    if (!FilePath::CompareEqualIgnoreCase(short_path, short_app_path))
-      return ShellIntegration::NOT_DEFAULT_WEB_CLIENT;
-  }
-
-  return ShellIntegration::IS_DEFAULT_WEB_CLIENT;
-}
-
-// A helper function that probes default protocol handler registration (in a
-// manner appropriate for the current version of Windows) to determine if
-// Chrome is the default handler for |protocols|.  Returns IS_DEFAULT_WEB_CLIENT
-// only if Chrome is the default for all specified protocols.
-ShellIntegration::DefaultWebClientState ProbeProtocolHandlers(
-    const wchar_t* const* protocols,
-    size_t num_protocols) {
-  DCHECK(!num_protocols || protocols);
-  if (DCHECK_IS_ON()) {
-    for (size_t i = 0; i < num_protocols; ++i)
-      DCHECK(protocols[i] && *protocols[i]);
-  }
-
-  const base::win::Version windows_version = base::win::GetVersion();
-
-  if (windows_version >= base::win::VERSION_WIN8)
-    return ProbeCurrentDefaultHandlers(protocols, num_protocols);
-  else if (windows_version >= base::win::VERSION_VISTA)
-    return ProbeAppIsDefaultHandlers(protocols, num_protocols);
-
-  return ProbeOpenCommandHandlers(protocols, num_protocols);
-}
-
 // Helper function for ShellIntegration::GetAppId to generates profile id
 // from profile path. "profile_id" is composed of sanitized basenames of
 // user data dir and profile dir joined by a ".".
 string16 GetProfileIdFromPath(const FilePath& profile_path) {
   // Return empty string if profile_path is empty
   if (profile_path.empty())
     return string16();
 
   FilePath default_user_data_dir;
   // Return empty string if profile_path is in default user data
@@ skipping 176 matching lines @@
       continue;
     }
 
     if (kLocations[i].sub_dir)
       path = path.Append(kLocations[i].sub_dir);
 
     MigrateWin7ShortcutsInPath(chrome_exe, path);
   }
 }
 
+ShellIntegration::DefaultWebClientState
+    GetDefaultWebClientStateFromShellUtilDefaultState(
+        ShellUtil::DefaultState default_state) {
+  switch (default_state) {
+    case ShellUtil::NOT_DEFAULT:
+      return ShellIntegration::NOT_DEFAULT_WEB_CLIENT;
+    case ShellUtil::IS_DEFAULT:
+      return ShellIntegration::IS_DEFAULT_WEB_CLIENT;
+    default:
+      return ShellIntegration::UNKNOWN_DEFAULT_WEB_CLIENT;

[grt (UTC plus 2), 2012/10/12 19:59:35]

DCHECK for the UNKNOWN ShellUtil::DefaultState value here

[gab, 2012/10/12 20:35:12]

Done.

+  }
+}
+
 }  // namespace
 
 ShellIntegration::DefaultWebClientSetPermission
     ShellIntegration::CanSetAsDefaultBrowser() {
   if (!BrowserDistribution::GetDistribution()->CanSetAsDefault())
     return SET_DEFAULT_NOT_ALLOWED;
 
   if (ShellUtil::CanMakeChromeDefaultUnattended())
     return SET_DEFAULT_UNATTENDED;
   else
@@ skipping 73 matching lines @@
           dist, chrome_exe.value(), wprotocol)) {
     LOG(ERROR) << "Failed to launch the set-default-client Windows UI.";
     return false;
   }
 
   VLOG(1) << "Set-default-client Windows UI completed.";
   return true;
 }
 
 ShellIntegration::DefaultWebClientState ShellIntegration::IsDefaultBrowser() {
-  // 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.
-  static const wchar_t* const kChromeProtocols[] = { L"http", L"https" };
-
-  return ProbeProtocolHandlers(kChromeProtocols, arraysize(kChromeProtocols));
+  return GetDefaultWebClientStateFromShellUtilDefaultState(
+      ShellUtil::IsChromeDefault());
 }
 
 ShellIntegration::DefaultWebClientState
     ShellIntegration::IsDefaultProtocolClient(const std::string& protocol) {
-  if (protocol.empty())
-    return UNKNOWN_DEFAULT_WEB_CLIENT;
-
-  string16 wide_protocol(UTF8ToUTF16(protocol));
-  const wchar_t* const protocols[] = { wide_protocol.c_str() };
-
-  return ProbeProtocolHandlers(protocols, arraysize(protocols));
+  return GetDefaultWebClientStateFromShellUtilDefaultState(
+      ShellUtil::IsChromeDefaultProtocolClient(UTF8ToUTF16(protocol)));
 }
 
 // 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 91 matching lines @@
     }
 
     shortcut = shortcut.Append(shortcut_name).Append(shortcut_name +
                                                      installer::kLnkExt);
     if (file_util::PathExists(shortcut))
       return shortcut;
   }
 
   return FilePath();
 }