Prototype version of the first-run dialog for Windows 8

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 109 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.

[grt (UTC plus 2), 2012/06/20 19:42:12]

has it been a long time since you rebased?

[motek., 2012/06/20 22:02:29]

Not really. This is some git accident, gab@ says likely because I yanked a
branch out. This should be fixed now.

   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(ShellUtil::GetBrowserModelId(dist, chrome_exe));
@@ 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 verb handler being set.
+    // depend on the DelegateExecute.
     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 333 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 34 matching lines @@
 // It is required that Chrome be already *registered* for the given protocol.
 bool LaunchSelectDefaultProtocolHandlerDialog(const wchar_t* protocol) {
   DCHECK(protocol);
   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);
   DLOG_IF(WARNING, FAILED(hr)) << "Failed to set as default " << protocol
       << " handler; hr=0x" << std::hex << hr;
+
   if (FAILED(hr))
     return false;
   SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, NULL, NULL);
-  return true;
+  return SUCCEEDED(hr);
 }
 
 // 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;
@@ skipping 508 matching lines @@
 
 // static
 bool ShellUtil::CanMakeChromeDefaultUnattended() {
   return base::win::GetVersion() < base::win::VERSION_WIN8;
 }
 
 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 (!CanMakeChromeDefaultUnattended()) {
     NOTREACHED();
     return false;
   }
@@ skipping 77 matching lines @@
 
   if (!RegisterChromeBrowser(dist, chrome_exe, string16(), true))
       return false;
 
   // 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, which is a mess, or pop the concise "How you want to open
   // webpages?" dialog.  We choose the latter.
+  // Return true only when the user took an action and there was no error.
   return LaunchSelectDefaultProtocolHandlerDialog(L"http");
 }
 
 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);
@@ skipping 72 matching lines @@
     STLElementDeleter<std::list<RegistryEntry*> > shell_deleter(&shell_entries);
     RegistryEntry::GetProgIdEntries(dist, chrome_exe, suffix, &progids);
     RegistryEntry::GetShellIntegrationEntries(
         dist, chrome_exe, suffix, &shell_entries);
     return AddRegistryEntries(user_level ? HKEY_CURRENT_USER :
                                            HKEY_LOCAL_MACHINE,
                               progids) &&
            AddRegistryEntries(root, shell_entries);
   }
 
-  // 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 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, L""))
     return true;
 
-  // If we got to this point then all we can do is create ProgIds under HKCU.
+  // 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);
   // Prefer to use |suffix|; unless Chrome's ProgIds are already registered with
   // no suffix (as per the old registration style): in which case some other
   // registry entries could refer to them and since we were not able to set our
   // HKLM entries above, we are better off not altering these here.
   if (!AreEntriesRegistered(entries, RegistryEntry::LOOK_IN_HKCU)) {
     if (!suffix.empty()) {
       STLDeleteElements(&entries);
@@ skipping 30 matching lines @@
     // We can do this operation directly.
     // First, make sure Chrome is fully registered on this machine.
     if (!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(root, 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 {
-    // Admin rights are required to register capabilities before Windows 8.
+    // 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, uint32 options) {
   // Only SHORTCUT_ALTERNATE is a valid option for this function.
   DCHECK(!options || options == ShellUtil::SHORTCUT_ALTERNATE);
 
   string16 shortcut_name;
@@ skipping 98 matching lines @@
       chrome_exe.c_str(),
       shortcut.c_str(),
       chrome_path.value().c_str(),
       arguments.c_str(),
       description.c_str(),
       icon_path.c_str(),
       icon_index,
       app_id.c_str(),
       ConvertShellUtilShortcutOptionsToFileUtil(options));
 }