Register Chrome in Open With for File Associations at install on 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 186 matching lines @@
 
   // Returns the Windows Default Programs capabilities key for Chrome.  For
   // example:
   // "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.
+  // are needed to register this installation's ProgId and AppId.
   // These entries should be registered in HKCU for user-level installs and in
   // HKLM for system-level installs.
-  static bool GetProgIdEntries(BrowserDistribution* dist,
+  static void 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));
     string16 delegate_guid;
@@ skipping 74 matching lines @@
       entries->push_front(new RegistryEntry(
           chrome_application, ShellUtil::kRegApplicationName,
           dist->GetAppShortCutName()));
       entries->push_front(new RegistryEntry(
           chrome_application, ShellUtil::kRegApplicationDescription,
           dist->GetAppDescription()));
       entries->push_front(new RegistryEntry(
           chrome_application, ShellUtil::kRegApplicationCompany,
           dist->GetPublisherName()));
     }
-
-    return true;
   }
 
   // This method returns a list of the registry entries needed to declare a
   // capability of handling a protocol on Windows.
-  static bool GetProtocolCapabilityEntries(BrowserDistribution* dist,
+  static void GetProtocolCapabilityEntries(BrowserDistribution* dist,
                                            const string16& suffix,
                                            const string16& protocol,
                                            std::list<RegistryEntry*>* entries) {
     entries->push_front(new RegistryEntry(
         GetCapabilitiesKey(dist, suffix).append(L"\\URLAssociations"),
         protocol, GetBrowserProgId(suffix)));
-    return true;
   }
 
-  // This method returns a list of all the registry entries required to fully
-  // integrate Chrome with Windows (i.e. StartMenuInternet, Default Programs,
-  // AppPaths, etc.). This entries need to be registered in HKLM prior to Win8.
-  static bool GetShellIntegrationEntries(BrowserDistribution* dist,
+  // This method returns a list of the registry entries required to register
+  // this installation in "RegisteredApplications" on Windows (to appear in
+  // Default Programs, StartMenuInternet, etc.).
+  // These entries need to be registered in HKLM prior to Win8.
+  // If |suffix| is not empty, these entries are guaranteed to be unique on this
+  // machine.
+  static void GetShellIntegrationEntries(BrowserDistribution* dist,
                                          const string16& chrome_exe,
                                          const string16& suffix,
                                          std::list<RegistryEntry*>* entries) {
-    string16 icon_path = ShellUtil::GetChromeIcon(dist, chrome_exe);
-    string16 quoted_exe_path = L"\"" + chrome_exe + L"\"";
+    const string16 icon_path(ShellUtil::GetChromeIcon(dist, chrome_exe));
+    const string16 quoted_exe_path(L"\"" + chrome_exe + L"\"");
 
     // Register for the Start Menu "Internet" link (pre-Win7).
     const string16 start_menu_entry(GetBrowserClientKey(dist, suffix));
     // Register Chrome's display name.
     // TODO(grt): http://crbug.com/75152 Also set LocalizedString; see
     // http://msdn.microsoft.com/en-us/library/windows/desktop/cc144109(v=VS.85).aspx#registering_the_display_name
     entries->push_front(new RegistryEntry(
         start_menu_entry, dist->GetAppShortCutName()));
     // Register the "open" verb for launching Chrome via the "Internet" link.
     entries->push_front(new RegistryEntry(
         start_menu_entry + ShellUtil::kRegShellOpen, quoted_exe_path));
     // Register Chrome's icon for the Start Menu "Internet" link.
     entries->push_front(new RegistryEntry(
         start_menu_entry + ShellUtil::kRegDefaultIcon, icon_path));
 
     // Register installation information.
     string16 install_info(start_menu_entry + L"\\InstallInfo");
     // Note: not using CommandLine since it has ambiguous rules for quoting
     // strings.
     entries->push_front(new RegistryEntry(install_info, kReinstallCommand,
         quoted_exe_path + L" --" + ASCIIToWide(switches::kMakeDefaultBrowser)));
     entries->push_front(new RegistryEntry(install_info, L"HideIconsCommand",
         quoted_exe_path + L" --" + ASCIIToWide(switches::kHideIcons)));
     entries->push_front(new RegistryEntry(install_info, L"ShowIconsCommand",
         quoted_exe_path + L" --" + ASCIIToWide(switches::kShowIcons)));
     entries->push_front(new RegistryEntry(install_info, L"IconsVisible", 1));
 
     // Register with Default Programs.
-    string16 reg_app_name(dist->GetBaseAppName().append(suffix));
+    const string16 reg_app_name(dist->GetBaseAppName().append(suffix));
     // Tell Windows where to find Chrome's Default Programs info.
-    string16 capabilities(GetCapabilitiesKey(dist, suffix));
+    const string16 capabilities(GetCapabilitiesKey(dist, suffix));
     entries->push_front(new RegistryEntry(ShellUtil::kRegRegisteredApplications,
         reg_app_name, capabilities));
     // Write out Chrome's Default Programs info.
     // TODO(grt): http://crbug.com/75152 Write a reference to a localized
     // resource rather than this.
     entries->push_front(new RegistryEntry(
         capabilities, ShellUtil::kRegApplicationDescription,
         dist->GetLongAppDescription()));
     entries->push_front(new RegistryEntry(
         capabilities, ShellUtil::kRegApplicationIcon, icon_path));
     entries->push_front(new RegistryEntry(
         capabilities, ShellUtil::kRegApplicationName,
         dist->GetAppShortCutName()));
 
     entries->push_front(new RegistryEntry(capabilities + L"\\Startmenu",
         L"StartMenuInternet", reg_app_name));
 
-    string16 html_prog_id(GetBrowserProgId(suffix));
+    const string16 html_prog_id(GetBrowserProgId(suffix));
     for (int i = 0; ShellUtil::kFileAssociations[i] != NULL; i++) {
       entries->push_front(new RegistryEntry(
           capabilities + L"\\FileAssociations",
           ShellUtil::kFileAssociations[i], html_prog_id));
     }
     for (int i = 0; ShellUtil::kPotentialProtocolAssociations[i] != NULL;
         i++) {
       entries->push_front(new RegistryEntry(
           capabilities + L"\\URLAssociations",
           ShellUtil::kPotentialProtocolAssociations[i], html_prog_id));
     }
+  }
 
-    // Application Registration.
-    FilePath chrome_path(chrome_exe);
+  // This method returns a list of the registry entries required for this
+  // installation to be registered in the Windows shell.
+  // In particular: App Paths and File Associations.

[robertshield, 2012/08/05 15:01:12]

Please add links to
http://msdn.microsoft.com/en-us/library/windows/desktop/ee872121 and
http://msdn.microsoft.com/en-us/library/bb166549 in the comment.

[gab, 2012/08/06 19:39:27]

Done.

+  // These entries should be registered in HKCU for user-level installs and in
+  // HKLM for system-level installs.
+  static void GetAppRegistrationEntries(const string16& chrome_exe,
+                                        const string16& suffix,
+                                        std::list<RegistryEntry*>* entries) {

[robertshield, 2012/08/05 15:01:12]

any reason not to use base::ScopedVector here? it would reduce the burden on
callers a bit

[gab, 2012/08/06 19:39:27]

shell_util has been using std::list forever, but I'm also in favor of this
change so, done :)!

+    const FilePath chrome_path(chrome_exe);
     string16 app_path_key(ShellUtil::kAppPathsRegistryKey);
     app_path_key.push_back(FilePath::kSeparators[0]);
     app_path_key.append(chrome_path.BaseName().value());
     entries->push_front(new RegistryEntry(app_path_key, chrome_exe));
     entries->push_front(new RegistryEntry(app_path_key,
         ShellUtil::kAppPathsRegistryPathName, chrome_path.DirName().value()));
 
-    // TODO: add chrome to open with list (Bug 16726).
-    return true;
+    const string16 html_prog_id(GetBrowserProgId(suffix));
+    for (int i = 0; ShellUtil::kFileAssociations[i] != NULL; i++) {
+      string16 key(ShellUtil::kRegClasses);
+      key.push_back(FilePath::kSeparators[0]);
+      key.append(ShellUtil::kFileAssociations[i]);
+      key.push_back(FilePath::kSeparators[0]);
+      key.append(ShellUtil::kRegOpenWithProgids);
+      entries->push_front(new RegistryEntry(key, html_prog_id, string16()));
+    }
   }
 
   // This method returns a list of all the user level registry entries that
   // are needed to make Chromium the default handler for a protocol.
-  static bool GetUserProtocolEntries(const string16& protocol,
+  static void GetUserProtocolEntries(const string16& protocol,
                                      const string16& chrome_icon,
                                      const string16& chrome_open,
                                      std::list<RegistryEntry*>* entries) {
     // Protocols associations.
     string16 url_key(ShellUtil::kRegClasses);
     url_key.push_back(FilePath::kSeparators[0]);
     url_key.append(protocol);
 
     // This registry value tells Windows that this 'class' is a URL scheme
     // so IE, explorer and other apps will route it to our handler.
     // <root hkey>\Software\Classes\<protocol>\URL Protocol
     entries->push_front(new RegistryEntry(url_key,
         ShellUtil::kRegUrlProtocol, L""));
 
     // <root hkey>\Software\Classes\<protocol>\DefaultIcon
     string16 icon_key = url_key + ShellUtil::kRegDefaultIcon;
     entries->push_front(new RegistryEntry(icon_key, chrome_icon));
 
     // <root hkey>\Software\Classes\<protocol>\shell\open\command
     string16 shell_key = url_key + ShellUtil::kRegShellOpen;
     entries->push_front(new RegistryEntry(shell_key, chrome_open));
 
     // <root hkey>\Software\Classes\<protocol>\shell\open\ddeexec
     string16 dde_key = url_key + L"\\shell\\open\\ddeexec";
     entries->push_front(new RegistryEntry(dde_key, L""));
 
     // <root hkey>\Software\Classes\<protocol>\shell\@
     string16 protocol_shell_key = url_key + ShellUtil::kRegShellPath;
     entries->push_front(new RegistryEntry(protocol_shell_key, L"open"));
-
-    return true;
   }
 
   // This method returns a list of all the user level registry entries that
   // are needed to make Chromium default browser.
-  static bool GetUserEntries(BrowserDistribution* dist,
-                             const string16& chrome_exe,
-                             const string16& suffix,
-                             std::list<RegistryEntry*>* entries) {
+  // Some of these entries are irrelevant in recent versions of Windows, but
+  // we register them anyways as some legacy apps are hardcoded to lookup those
+  // values.
+  static void GetDefaultBrowserUserEntries(BrowserDistribution* dist,
+                                           const string16& chrome_exe,
+                                           const string16& suffix,
+                                           std::list<RegistryEntry*>* entries) {

[robertshield, 2012/08/05 15:01:12]

same comment about base::ScopedVector

[gab, 2012/08/06 19:39:27]

Done.

     // File extension associations.
     string16 html_prog_id(GetBrowserProgId(suffix));
     for (int i = 0; ShellUtil::kFileAssociations[i] != NULL; i++) {
       string16 ext_key(ShellUtil::kRegClasses);
       ext_key.push_back(FilePath::kSeparators[0]);
       ext_key.append(ShellUtil::kFileAssociations[i]);
       entries->push_front(new RegistryEntry(ext_key, html_prog_id));
     }
 
     // Protocols associations.
     string16 chrome_open = ShellUtil::GetChromeShellOpenCmd(chrome_exe);
     string16 chrome_icon = ShellUtil::GetChromeIcon(dist, chrome_exe);
     for (int i = 0; ShellUtil::kBrowserProtocolAssociations[i] != NULL; i++) {
       GetUserProtocolEntries(ShellUtil::kBrowserProtocolAssociations[i],
                              chrome_icon, chrome_open, entries);
     }
 
     // start->Internet shortcut.
     string16 start_menu(ShellUtil::kRegStartMenuInternet);
     string16 app_name = dist->GetBaseAppName() + suffix;
     entries->push_front(new RegistryEntry(start_menu, app_name));
-    return true;
   }
 
   // Generate work_item tasks required to create current registry entry and
   // add them to the given work item list.
   void AddToWorkItemList(HKEY root, WorkItemList *items) const {
     items->AddCreateRegKeyWorkItem(root, _key_path);
     if (_is_string) {
       items->AddSetRegValueWorkItem(root, _key_path, _name, _value, true);
     } else {
       items->AddSetRegValueWorkItem(root, _key_path, _name, _int_value, true);
@@ skipping 119 matching lines @@
 }
 
 // Checks that all required registry entries for Chrome are already present
 // on this computer.
 bool IsChromeRegistered(BrowserDistribution* dist,
                         const string16& chrome_exe,
                         const string16& suffix) {
   std::list<RegistryEntry*> entries;
   STLElementDeleter<std::list<RegistryEntry*> > entries_deleter(&entries);
   RegistryEntry::GetProgIdEntries(dist, chrome_exe, suffix, &entries);
-  RegistryEntry::GetShellIntegrationEntries(
-      dist, chrome_exe, suffix, &entries);
+  RegistryEntry::GetShellIntegrationEntries(dist, chrome_exe, suffix, &entries);
+  RegistryEntry::GetAppRegistrationEntries(chrome_exe, suffix, &entries);
   return AreEntriesRegistered(entries, RegistryEntry::LOOK_IN_HKCU_THEN_HKLM);
 }
 
 // This method checks if Chrome is already registered on the local machine
 // for the requested protocol. It just checks the one value required for this.
 bool IsChromeRegisteredForProtocol(BrowserDistribution* dist,
                                    const string16& suffix,
                                    const string16& protocol) {
   std::list<RegistryEntry*> entries;
   STLElementDeleter<std::list<RegistryEntry*> > entries_deleter(&entries);
@@ skipping 242 matching lines @@
 }
 
 // Returns the root registry key (HKLM or HKCU) into which shell integration
 // registration for default protocols must be placed. As of Windows 8 everything
 // can go in HKCU for per-user installs.
 HKEY DetermineShellIntegrationRoot(bool is_per_user) {
   return is_per_user && base::win::GetVersion() >= base::win::VERSION_WIN8 ?
       HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE;
 }
 
+// Associates Chrome with supported protocols and file associations. This should
+// not be required on Vista+ but since some applications still read
+// Software\Classes\http key directly, we have to do this on Vista+ as well.
+bool RegisterChromeAsDefaultForXP(BrowserDistribution* dist,
+                                  int shell_change,
+                                  const string16& chrome_exe) {
+  bool ret = true;
+  std::list<RegistryEntry*> entries;
+  STLElementDeleter<std::list<RegistryEntry*> > entries_deleter(&entries);
+  RegistryEntry::GetDefaultBrowserUserEntries(
+      dist, chrome_exe,
+      ShellUtil::GetCurrentInstallationSuffix(dist, chrome_exe), &entries);
+  // Change the default browser for current user.

[robertshield, 2012/08/05 15:01:12]

nit: imo should add a blank line before the comment.

[gab, 2012/08/06 19:39:27]

Done.

+  if ((shell_change & ShellUtil::CURRENT_USER) &&
+      !AddRegistryEntries(HKEY_CURRENT_USER, entries)) {
+    ret = false;
+    LOG(ERROR) << "Could not make Chrome default browser (XP/current user).";
+  }
+
+  // Chrome as default browser at system level.
+  if ((shell_change & ShellUtil::SYSTEM_LEVEL) &&
+      !AddRegistryEntries(HKEY_LOCAL_MACHINE, entries)) {
+    ret = false;
+    LOG(ERROR) << "Could not make Chrome default browser (XP/system level).";
+  }
+
+  return ret;
+}
+
 }  // 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 26 matching lines @@
     L"ApplicationDescription";
 const wchar_t* ShellUtil::kRegApplicationName = L"ApplicationName";
 const wchar_t* ShellUtil::kRegApplicationIcon = L"ApplicationIcon";
 const wchar_t* ShellUtil::kRegApplicationCompany = L"ApplicationCompany";
 const wchar_t* ShellUtil::kRegExePath = L"\\.exe";
 const wchar_t* ShellUtil::kRegVerbOpen = L"open";
 const wchar_t* ShellUtil::kRegVerbOpenNewWindow = L"opennewwindow";
 const wchar_t* ShellUtil::kRegVerbRun = L"run";
 const wchar_t* ShellUtil::kRegCommand = L"command";
 const wchar_t* ShellUtil::kRegDelegateExecute = L"DelegateExecute";
+const wchar_t* ShellUtil::kRegOpenWithProgids = L"OpenWithProgids";
 
 bool ShellUtil::QuickIsChromeRegisteredInHKLM(BrowserDistribution* dist,
                                               const string16& chrome_exe,
                                               const string16& suffix) {
   return QuickIsChromeRegistered(dist, chrome_exe, suffix,
                                  CONFIRM_SHELL_REGISTRATION_IN_HKLM);
 }
 
 bool ShellUtil::CreateChromeDesktopShortcut(BrowserDistribution* dist,
                                             const string16& chrome_exe,
@@ skipping 354 matching lines @@
             ShellUtil::kFileAssociations[i], AT_FILEEXTENSION);
         if (!SUCCEEDED(hr)) {
           ret = false;
           LOG(ERROR) << "Failed to register as default for file extension "
                      << ShellUtil::kFileAssociations[i] << " (" << hr << ")";
         }
       }
     }
   }
 
-  // Now use the old way to associate Chrome with supported protocols and file
-  // associations. This should not be required on Vista but since some
-  // applications still read Software\Classes\http key directly, we have to do
-  // this on Vista also.
-
-  std::list<RegistryEntry*> entries;
-  STLElementDeleter<std::list<RegistryEntry*> > entries_deleter(&entries);
-  RegistryEntry::GetUserEntries(
-      dist, chrome_exe, GetCurrentInstallationSuffix(dist, chrome_exe),
-      &entries);
-  // Change the default browser for current user.
-  if ((shell_change & ShellUtil::CURRENT_USER) &&
-      !AddRegistryEntries(HKEY_CURRENT_USER, entries)) {
+  if (!RegisterChromeAsDefaultForXP(dist, shell_change, chrome_exe))
     ret = false;
-    LOG(ERROR) << "Could not make Chrome default browser (XP/current user).";
-  }
-
-  // Chrome as default browser at system level.
-  if ((shell_change & ShellUtil::SYSTEM_LEVEL) &&
-      !AddRegistryEntries(HKEY_LOCAL_MACHINE, entries)) {
-    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,
                                               const string16& chrome_exe) {
   DCHECK_GE(base::win::GetVersion(), base::win::VERSION_WIN8);
   if (!dist->CanSetAsDefault())
     return false;
 
   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");
+  const bool ret = LaunchSelectDefaultProtocolHandlerDialog(L"http");
+
+  if (ret) {
+    const int shell_change =
+        InstallUtil::IsPerUserInstall(chrome_exe.c_str()) ? CURRENT_USER :
+                                                            SYSTEM_LEVEL;
+    RegisterChromeAsDefaultForXP(dist, shell_change, chrome_exe);
+  }
+
+  return ret;
 }
 
 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 58 matching lines @@
   // Check if Chromium is already registered with this suffix.
   if (IsChromeRegistered(dist, chrome_exe, suffix))
     return true;
 
   bool user_level = InstallUtil::IsPerUserInstall(chrome_exe.c_str());
   HKEY root = DetermineShellIntegrationRoot(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*> progid_and_appreg_entries;
+    STLElementDeleter<std::list<RegistryEntry*> > progdid_and_appreg_deleter(
+        &progid_and_appreg_entries);
     std::list<RegistryEntry*> shell_entries;
     STLElementDeleter<std::list<RegistryEntry*> > shell_deleter(&shell_entries);
-    RegistryEntry::GetProgIdEntries(dist, chrome_exe, suffix, &progids);
+    RegistryEntry::GetProgIdEntries(dist, chrome_exe, suffix,
+                                    &progid_and_appreg_entries);
+    RegistryEntry::GetAppRegistrationEntries(chrome_exe, suffix,
+                                             &progid_and_appreg_entries);
     RegistryEntry::GetShellIntegrationEntries(
         dist, chrome_exe, suffix, &shell_entries);
     return AddRegistryEntries(user_level ? HKEY_CURRENT_USER :
                                            HKEY_LOCAL_MACHINE,
-                              progids) &&
+                              progid_and_appreg_entries) &&
            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 (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 ProgId and basic app
+  // registrations under HKCU.
   std::list<RegistryEntry*> entries;
   STLElementDeleter<std::list<RegistryEntry*> > entries_deleter(&entries);
-  RegistryEntry::GetProgIdEntries(dist, chrome_exe, L"", &entries);
+  RegistryEntry::GetProgIdEntries(dist, chrome_exe, string16(), &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);
       RegistryEntry::GetProgIdEntries(dist, chrome_exe, suffix, &entries);
+      RegistryEntry::GetAppRegistrationEntries(chrome_exe, suffix, &entries);
     }
     return AddRegistryEntries(HKEY_CURRENT_USER, entries);
+  } else {
+    // The ProgId is registered unsuffixed in HKCU, also register the app with
+    // Windows in HKCU (this was not done in the old registration style and
+    // thus needs to be done after the above check for the unsuffixed
+    // registration).
+    STLDeleteElements(&entries);
+    RegistryEntry::GetAppRegistrationEntries(chrome_exe, string16(), &entries);
+    return AddRegistryEntries(HKEY_CURRENT_USER, entries);
   }
   return true;
 }
 
 bool ShellUtil::RegisterChromeForProtocol(BrowserDistribution* dist,
                                           const string16& chrome_exe,
                                           const string16& unique_suffix,
                                           const string16& protocol,
                                           bool elevate_if_not_admin) {
   if (!dist->CanSetAsDefault())
@@ skipping 210 matching lines @@
     // are any left...).
     if (free_bits >= 8 && next_byte_index < size) {
       free_bits -= 8;
       bit_stream += bytes[next_byte_index++] << free_bits;
     }
   }
 
   DCHECK_EQ(ret.length(), encoded_length);
   return ret;
 }