Allow the default browser check to return "unknown" and reflect that in the UI.

chrome/browser/shell_integration_win.cc

 // Copyright (c) 2009 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 <shlobj.h>
 #include <shobjidl.h>
 
@@ skipping 26 matching lines @@
   if (!ShellUtil::MakeChromeDefault(ShellUtil::CURRENT_USER,
                                     chrome_exe, true)) {
     LOG(ERROR) << "Chrome could not be set as default browser.";
     return false;
   }
 
   LOG(INFO) << "Chrome registered as default browser.";
   return true;
 }
 
-bool ShellIntegration::IsDefaultBrowser() {
+ShellIntegration::DefaultBrowserState ShellIntegration::IsDefaultBrowser() {
   // First determine the app path. If we can't determine what that is, we have
   // bigger fish to fry...
   std::wstring app_path;
   if (!PathService::Get(base::FILE_EXE, &app_path)) {
     LOG(ERROR) << "Error getting app exe path";
-    return false;
+    return UNKNOWN_DEFAULT_BROWSER;
   }
   // 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 (win_util::GetWinVersion() >= win_util::WINVERSION_VISTA) {
     IApplicationAssociationRegistration* pAAR;
     HRESULT hr = CoCreateInstance(CLSID_ApplicationAssociationRegistration,
         NULL, CLSCTX_INPROC, __uuidof(IApplicationAssociationRegistration),
         (void**)&pAAR);
     if (!SUCCEEDED(hr))
-      return false;
+      return UNKNOWN_DEFAULT_BROWSER;
 
     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(&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)) {
+      if (!SUCCEEDED(hr)) {
         pAAR->Release();
-        return false;
+        return UNKNOWN_DEFAULT_BROWSER;
+      }
+      if (result == FALSE) {
+        pAAR->Release();
+        return NOT_DEFAULT_BROWSER;
       }
     }
     pAAR->Release();
   } else {
     std::wstring short_app_path;
     GetShortPathName(app_path.c_str(), WriteInto(&short_app_path, MAX_PATH),
                      MAX_PATH);
 
     // 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);
       RegKey key(root_key, key_path.c_str(), KEY_READ);
       std::wstring value;
       if (!key.Valid() || !key.ReadValue(L"", &value))
-        return false;
+        return NOT_DEFAULT_BROWSER;  // Or UNKNOWN_DEFAULT_BROWSER?

[Evan Martin, 2009/09/04 22:46:15]

If this registry key is something we set when we *are* the default browser, then
I think it's safe to delete your comment.

[Mike Mammarella, 2009/09/04 22:56:27]

I looked through the RegKey source but it wasn't clear to me whether either of
these conditions indicates that we would be unable to later set the key. If
either does indicate that, then "unknown" is the correct response for that
condition.

[kuchhal, 2009/09/04 23:05:12]

These are keys like <root>\Software\Classes\http\shell\open\command which should
always exist on Windows since it comes with IE preloaded. No browser I know
actually deletes this key. So if we can't read the value most likely we won't be
able to set it either so just setting the status to Unknown should be fine.

On 2009/09/04 22:56:27, Mike Mammarella wrote:

       // Need to normalize path in case it's been munged.
       CommandLine command_line(L"");
       command_line.ParseFromString(value);
       std::wstring short_path;
       GetShortPathName(command_line.program().c_str(),
                        WriteInto(&short_path, MAX_PATH), MAX_PATH);
       if ((short_path.size() != short_app_path.size()) ||
           (!std::equal(short_path.begin(),
                        short_path.end(),
                        short_app_path.begin(),
                        CaseInsensitiveCompare<wchar_t>())))
-        return false;
+        return NOT_DEFAULT_BROWSER;
     }
   }
-  return true;
+  return IS_DEFAULT_BROWSER;
 }
 
 // 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 12 matching lines @@
     std::wstring key_path(L"http");
     key_path.append(ShellUtil::kRegShellOpen);
     RegKey key(HKEY_CLASSES_ROOT, key_path.c_str(), KEY_READ);
     std::wstring app_cmd;
     if (key.Valid() && key.ReadValue(L"", &app_cmd) &&
         std::wstring::npos != StringToLowerASCII(app_cmd).find(L"firefox"))
       ff_default = true;
   }
   return ff_default;
 }