Support for interactive set-chrome-as-default in Windows.

chrome/installer/util/shell_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.
 //
 // 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"
@@ skipping 59 matching lines @@
   // "Software\Clients\StartMenuInternet\Chromium[.user]\Capabilities".
   static string16 GetCapabilitiesKey(BrowserDistribution* dist,
                                      const string16& suffix) {
     return GetBrowserClientKey(dist, suffix).append(L"\\Capabilities");
   }
 
   // This method returns a list of all the registry entries that
   // are needed to register Chromium ProgIds.
   // These entries should be registered in HKCU for user-level installs and in
   // HKLM for system-level installs.
-  // TODO (gab): Extract the Windows 8 only registrations out of this function.
   static bool GetProgIdEntries(BrowserDistribution* dist,
                                const string16& chrome_exe,
                                const string16& suffix,
                                std::list<RegistryEntry*>* entries) {
     string16 icon_path(ShellUtil::GetChromeIcon(dist, chrome_exe));
     string16 open_cmd(ShellUtil::GetChromeShellOpenCmd(chrome_exe));
     string16 delegate_command(ShellUtil::GetChromeDelegateCommand(chrome_exe));
     // For user-level installs: entries for the app id and DelegateExecute verb
     // handler will be in HKCU; thus we do not need a suffix on those entries.
     string16 app_id(dist->GetBrowserAppId());
@@ skipping 51 matching lines @@
         chrome_html_prog_id + ShellUtil::kRegDefaultIcon, icon_path));
     entries->push_front(new RegistryEntry(
         chrome_html_prog_id + ShellUtil::kRegShellOpen, open_cmd));
     if (set_delegate_execute) {
       entries->push_front(new RegistryEntry(
           chrome_html_prog_id + ShellUtil::kRegShellOpen,
           ShellUtil::kRegDelegateExecute, delegate_guid));
     }
 
     // The following entries are required as of Windows 8, but do not
-    // depend on the DelegateExecute.
+    // depend on the DelegateExecute verb handler being set.
     if (base::win::GetVersion() >= base::win::VERSION_WIN8) {
       entries->push_front(new RegistryEntry(
           chrome_html_prog_id, ShellUtil::kRegAppUserModelId, app_id));
 
       // Add \Software\Classes\ChromeHTML\Application entries
       string16 chrome_application(chrome_html_prog_id +
                                   ShellUtil::kRegApplication);
       entries->push_front(new RegistryEntry(
           chrome_application, ShellUtil::kRegAppUserModelId, app_id));
       entries->push_front(new RegistryEntry(
@@ skipping 320 matching lines @@
 // 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 string16& chrome_exe,
                               const string16& suffix,
                               const string16& protocol) {
+  // Only user-level installs prior to Windows 8 should need to elevate to
+  // register.
+  DCHECK(InstallUtil::IsPerUserInstall(chrome_exe.c_str()));
+  DCHECK_LT(base::win::GetVersion(), base::win::VERSION_WIN8);
   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);
     string16 uninstall_string;
     key.ReadValue(installer::kUninstallStringField, &uninstall_string);
     CommandLine command_line = CommandLine::FromString(uninstall_string);
@@ skipping 79 matching lines @@
       else
         one_mismatch = true;
     }
   }
   return true;
 }
 
 // Launches the Windows 7 and Windows 8 application association dialog, which
 // is the only documented way to make a browser the default browser on
 // Windows 8.
-bool LaunchApplicationAssociationDialog(const string16& app_id) {
-  base::win::ScopedComPtr<IApplicationAssociationRegistrationUI> aarui;
-  HRESULT hr = aarui.CreateInstance(CLSID_ApplicationAssociationRegistrationUI);
-  if (FAILED(hr))
-    return false;
-  hr = aarui->LaunchAdvancedAssociationUI(app_id.c_str());
+bool LaunchApplicationAssociationDialog() {
+  const wchar_t* protocol = L"http";
+  OPENASINFO open_as_info = {};
+  open_as_info.pcszFile = protocol;
+  open_as_info.oaifInFlags =
+      OAIF_URL_PROTOCOL | OAIF_FORCE_REGISTRATION | OAIF_REGISTER_EXT;
+  HRESULT hr = SHOpenWithDialog(NULL, &open_as_info);
   return SUCCEEDED(hr);
 }
 
 uint32 ConvertShellUtilShortcutOptionsToFileUtil(uint32 options) {
   uint32 converted_options = 0;
   if (options & ShellUtil::SHORTCUT_DUAL_MODE)
     converted_options |= file_util::SHORTCUT_DUAL_MODE;
   if (options & ShellUtil::SHORTCUT_CREATE_ALWAYS)
     converted_options |= file_util::SHORTCUT_CREATE_ALWAYS;
   return converted_options;
@@ skipping 32 matching lines @@
     key = ShellUtil::kRegClasses;
     key.push_back(FilePath::kSeparators[0]);
     key.append(ShellUtil::kChromeHTMLProgId);
     key.append(suffix);
     key.append(ShellUtil::kRegShellOpen);
     InstallUtil::DeleteRegistryValue(root_key, key,
                                      ShellUtil::kRegDelegateExecute);
   }
 }
 
+// Returns the root registry key (HKLM or HKCU) into which system registration
+// for default protocols must be placed. As of Windows 8 everything can go in
+// HKCU for per-user installs.
+HKEY DetermineRegistrationRoot(bool is_per_user) {
+  return is_per_user && base::win::GetVersion() >= base::win::VERSION_WIN8 ?
+      HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE;
+}
+
 }  // 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";
@@ skipping 245 matching lines @@
 
   return RegKey(HKEY_LOCAL_MACHINE,
                 RegistryEntry::GetBrowserClientKey(dist, *entry).c_str(),
                 KEY_READ).Valid();
 }
 
 bool ShellUtil::MakeChromeDefault(BrowserDistribution* dist,
                                   int shell_change,
                                   const string16& chrome_exe,
                                   bool elevate_if_not_admin) {
+  DCHECK(!(shell_change & ShellUtil::SYSTEM_LEVEL) || IsUserAnAdmin());
+
   if (!dist->CanSetAsDefault())
     return false;
 
+  // Windows 8 does not permit making a browser default just like that.
+  // This process needs to be routed through the system's UI. Use
+  // ShowMakeChromeDefaultSystemUI instead (below).
+  if (base::win::GetVersion() >= base::win::VERSION_WIN8)
+    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.
   string16 app_name = dist->GetApplicationName();
   string16 app_suffix;
   if (ShellUtil::GetUserSpecificDefaultBrowserSuffix(dist, &app_suffix))
     app_name += app_suffix;
 
   if (base::win::GetVersion() >= base::win::VERSION_WIN8) {
     // On Windows 8, you can't set yourself as the default handler
     // programatically. In other words IApplicationAssociationRegistration
     // has been rendered useless. What you can do is to launch
     // "Set Program Associations" section of the "Default Programs"
     // control panel. This action does not require elevation and we
     // don't get to control window activation. More info at:
     // http://msdn.microsoft.com/en-us/library/cc144154(VS.85).aspx
-    return LaunchApplicationAssociationDialog(app_name.c_str());
+    // Since this will show a modal UI elementm this has been split into
+    // a separate flow (see ShowMakeChromeDefaultSystemUI).
+    return false;
+  }
 
-  } else if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
+  if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
     // On Windows Vista and Win7 we still can set ourselves via the
     // the IApplicationAssociationRegistration interface.
     VLOG(1) << "Registering Chrome as default browser on Vista.";
     base::win::ScopedComPtr<IApplicationAssociationRegistration> pAAR;
     HRESULT hr = pAAR.CreateInstance(CLSID_ApplicationAssociationRegistration,
         NULL, CLSCTX_INPROC);
     if (SUCCEEDED(hr)) {
       for (int i = 0; ShellUtil::kBrowserProtocolAssociations[i] != NULL; i++) {
         hr = pAAR->SetAppAsDefault(app_name.c_str(),
             ShellUtil::kBrowserProtocolAssociations[i], AT_URLPROTOCOL);
@@ skipping 41 matching lines @@
     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::ShowMakeChromeDefaultSystemUI(
+    BrowserDistribution* dist, int shell_change, const string16& chrome_exe,
+        bool elevate_if_not_admin) {
+  if (!dist->CanSetAsDefault())
+    return false;
+
+  ShellUtil::RegisterChromeBrowser(dist, chrome_exe, L"", elevate_if_not_admin);
+
+  // On Windows 8, you can't set yourself as the default handler
+  // programatically. In other words IApplicationAssociationRegistration
+  // has been rendered useless. What you can do is to launch
+  // "Set Program Associations" section of the "Default Programs"
+  // control panel. This action does not require elevation and we
+  // don't get to control window activation. More info at:
+  // http://msdn.microsoft.com/en-us/library/cc144154(VS.85).aspx
+  return LaunchApplicationAssociationDialog();
+}
+
 bool ShellUtil::MakeChromeDefaultProtocolClient(BrowserDistribution* dist,
                                                 const string16& chrome_exe,
                                                 const string16& 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
@@ skipping 60 matching lines @@
     suffix = L"";
   }
 
   // TODO(grt): remove this on or after 2012-08-01; see impl for details.
   RemoveBadWindows8RegistrationIfNeeded(dist, chrome_exe, suffix);
 
   // Check if Chromium is already registered with this suffix.
   if (IsChromeRegistered(dist, chrome_exe, suffix))
     return true;
 
-  // If user is an admin try to register and return the status.
-  if (IsUserAnAdmin()) {
+  bool user_level = InstallUtil::IsPerUserInstall(chrome_exe.c_str());
+  HKEY root = DetermineRegistrationRoot(user_level);
+
+  // Do the full registration if we can do it at user-level or if the user is an
+  // admin.
+  if (root == HKEY_CURRENT_USER || IsUserAnAdmin()) {
     std::list<RegistryEntry*> progids;
     STLElementDeleter<std::list<RegistryEntry*> > progids_deleter(&progids);
     std::list<RegistryEntry*> sys_entries;
     STLElementDeleter<std::list<RegistryEntry*> > sys_deleter(&sys_entries);
     RegistryEntry::GetProgIdEntries(dist, chrome_exe, suffix, &progids);
     RegistryEntry::GetSystemEntries(dist, chrome_exe, suffix, &sys_entries);
-    return AddRegistryEntries(
-               InstallUtil::IsPerUserInstall(chrome_exe.c_str()) ?
-                   HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE,
-               progids) &&
-           AddRegistryEntries(HKEY_LOCAL_MACHINE, sys_entries);
+    return AddRegistryEntries(user_level ? HKEY_CURRENT_USER :
+                                           HKEY_LOCAL_MACHINE,
+                              progids) &&
+           AddRegistryEntries(root, sys_entries);
   }
 
-  // If user is not an admin and OS is Vista, try to elevate and register.
+  // If the user is not an admin and OS is between Vista and Windows 7
+  // inclusively, try to elevate and register. This is only intended for
+  // user-level installs as system-level installs should always be run with
+  // admin rights.
   if (elevate_if_not_admin &&
       base::win::GetVersion() >= base::win::VERSION_VISTA &&
       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.
+  // If we got to this point then all we can do is create ProgIds under HKCU.
   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 string16& chrome_exe,
                                           const string16& unique_suffix,
                                           const string16& 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.
   string16 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, suffix, protocol))
     return true;
 
-  if (IsUserAnAdmin()) {
+  HKEY root = DetermineRegistrationRoot(
+      InstallUtil::IsPerUserInstall(chrome_exe.c_str()));
+
+  if (root == HKEY_CURRENT_USER || 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, suffix, protocol,
         &entries);
-    return AddRegistryEntries(HKEY_LOCAL_MACHINE, entries);
+    return AddRegistryEntries(root, 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.
+    // Admin rights are required to register capabilities before Windows 8.
     return false;
   }
 }
 
 bool ShellUtil::RemoveChromeDesktopShortcut(BrowserDistribution* dist,
                                             int shell_change, uint32 options) {
   // Only SHORTCUT_ALTERNATE is a valid option for this function.
   DCHECK(!options || options == ShellUtil::SHORTCUT_ALTERNATE);
 
   string16 shortcut_name;
@@ skipping 97 matching lines @@
       chrome_exe.c_str(),
       shortcut.c_str(),
       chrome_path.c_str(),
       arguments.c_str(),
       description.c_str(),
       icon_path.c_str(),
       icon_index,
       dist->GetBrowserAppId().c_str(),
       ConvertShellUtilShortcutOptionsToFileUtil(options));
 }