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"
 
 #include <shlobj.h>
 #include <windows.h>
 
 #include <limits>
-#include <list>
 #include <string>
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/md5.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/scoped_vector.h"
 #include "base/path_service.h"
-#include "base/stl_util.h"
+#include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/win_util.h"
 #include "base/win/windows_version.h"
 #include "chrome/common/chrome_constants.h"
@@ skipping 159 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) {
+                               ScopedVector<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;
     // TODO(grt): remove HasDelegateExecuteHandler when the exe is ever-present;
     // see also install_worker.cc's AddDelegateExecuteWorkItems.
     bool set_delegate_execute =
         IsChromeMetroSupported() &&
         dist->GetDelegateExecuteHandlerData(&delegate_guid, NULL, NULL, NULL) &&
         InstallUtil::HasDelegateExecuteHandler(dist, chrome_exe);
 
     // DelegateExecute ProgId. Needed for Chrome Metro in Windows 8.
     if (set_delegate_execute) {
       string16 model_id_shell(ShellUtil::kRegClasses);
       model_id_shell.push_back(FilePath::kSeparators[0]);
       model_id_shell.append(app_id);
       model_id_shell.append(ShellUtil::kRegExePath);
       model_id_shell.append(ShellUtil::kRegShellPath);
 
       // <root hkey>\Software\Classes\<app_id>\.exe\shell @=open
-      entries->push_front(new RegistryEntry(model_id_shell,
-                                            ShellUtil::kRegVerbOpen));
+      entries->push_back(new RegistryEntry(model_id_shell,
+                                          ShellUtil::kRegVerbOpen));
 
       const wchar_t* const verbs[] = { ShellUtil::kRegVerbOpen,
                                        ShellUtil::kRegVerbOpenNewWindow,
                                        ShellUtil::kRegVerbRun };
       for (size_t i = 0; i < arraysize(verbs); ++i) {
         string16 sub_path(model_id_shell);
         sub_path.push_back(FilePath::kSeparators[0]);
         sub_path.append(verbs[i]);
 
         // <root hkey>\Software\Classes\<app_id>\.exe\shell\<verb>
-        entries->push_front(new RegistryEntry(
+        entries->push_back(new RegistryEntry(
             sub_path, L"CommandId", L"Browser.Launch"));
 
         sub_path.push_back(FilePath::kSeparators[0]);
         sub_path.append(ShellUtil::kRegCommand);
 
         // <root hkey>\Software\Classes\<app_id>\.exe\shell\<verb>\command
-        entries->push_front(new RegistryEntry(sub_path, delegate_command));
-        entries->push_front(new RegistryEntry(
+        entries->push_back(new RegistryEntry(sub_path, delegate_command));
+        entries->push_back(new RegistryEntry(
             sub_path, ShellUtil::kRegDelegateExecute, delegate_guid));
       }
     }
 
     // File association ProgId
     string16 chrome_html_prog_id(ShellUtil::kRegClasses);
     chrome_html_prog_id.push_back(FilePath::kSeparators[0]);
     chrome_html_prog_id.append(GetBrowserProgId(suffix));
-    entries->push_front(new RegistryEntry(
+    entries->push_back(new RegistryEntry(
         chrome_html_prog_id, ShellUtil::kChromeHTMLProgIdDesc));
-    entries->push_front(new RegistryEntry(
+    entries->push_back(new RegistryEntry(
         chrome_html_prog_id, ShellUtil::kRegUrlProtocol, L""));
-    entries->push_front(new RegistryEntry(
+    entries->push_back(new RegistryEntry(
         chrome_html_prog_id + ShellUtil::kRegDefaultIcon, icon_path));
-    entries->push_front(new RegistryEntry(
+    entries->push_back(new RegistryEntry(
         chrome_html_prog_id + ShellUtil::kRegShellOpen, open_cmd));
     if (set_delegate_execute) {
-      entries->push_front(new RegistryEntry(
+      entries->push_back(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.
     if (base::win::GetVersion() >= base::win::VERSION_WIN8) {
-      entries->push_front(new RegistryEntry(
+      entries->push_back(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(
+      entries->push_back(new RegistryEntry(
           chrome_application, ShellUtil::kRegAppUserModelId, app_id));
-      entries->push_front(new RegistryEntry(
+      entries->push_back(new RegistryEntry(
           chrome_application, ShellUtil::kRegApplicationIcon, icon_path));
       // TODO(grt): http://crbug.com/75152 Write a reference to a localized
       // resource for name, description, and company.
-      entries->push_front(new RegistryEntry(
+      entries->push_back(new RegistryEntry(
           chrome_application, ShellUtil::kRegApplicationName,
           dist->GetAppShortCutName()));
-      entries->push_front(new RegistryEntry(
+      entries->push_back(new RegistryEntry(
           chrome_application, ShellUtil::kRegApplicationDescription,
           dist->GetAppDescription()));
-      entries->push_front(new RegistryEntry(
+      entries->push_back(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,
-                                           const string16& suffix,
-                                           const string16& protocol,
-                                           std::list<RegistryEntry*>* entries) {
-    entries->push_front(new RegistryEntry(
+  static void GetProtocolCapabilityEntries(
+      BrowserDistribution* dist,
+      const string16& suffix,
+      const string16& protocol,
+      ScopedVector<RegistryEntry>* entries) {
+    entries->push_back(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"\"";
+                                         ScopedVector<RegistryEntry>* entries) {
+    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(
+    entries->push_back(new RegistryEntry(
         start_menu_entry, dist->GetAppShortCutName()));
     // Register the "open" verb for launching Chrome via the "Internet" link.
-    entries->push_front(new RegistryEntry(
+    entries->push_back(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(
+    entries->push_back(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,
+    entries->push_back(new RegistryEntry(install_info, kReinstallCommand,
         quoted_exe_path + L" --" + ASCIIToWide(switches::kMakeDefaultBrowser)));
-    entries->push_front(new RegistryEntry(install_info, L"HideIconsCommand",
+    entries->push_back(new RegistryEntry(install_info, L"HideIconsCommand",
         quoted_exe_path + L" --" + ASCIIToWide(switches::kHideIcons)));
-    entries->push_front(new RegistryEntry(install_info, L"ShowIconsCommand",
+    entries->push_back(new RegistryEntry(install_info, L"ShowIconsCommand",
         quoted_exe_path + L" --" + ASCIIToWide(switches::kShowIcons)));
-    entries->push_front(new RegistryEntry(install_info, L"IconsVisible", 1));
+    entries->push_back(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));
-    entries->push_front(new RegistryEntry(ShellUtil::kRegRegisteredApplications,
+    const string16 capabilities(GetCapabilitiesKey(dist, suffix));
+    entries->push_back(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(
+    entries->push_back(new RegistryEntry(
         capabilities, ShellUtil::kRegApplicationDescription,
         dist->GetLongAppDescription()));
-    entries->push_front(new RegistryEntry(
+    entries->push_back(new RegistryEntry(
         capabilities, ShellUtil::kRegApplicationIcon, icon_path));
-    entries->push_front(new RegistryEntry(
+    entries->push_back(new RegistryEntry(
         capabilities, ShellUtil::kRegApplicationName,
         dist->GetAppShortCutName()));
 
-    entries->push_front(new RegistryEntry(capabilities + L"\\Startmenu",
+    entries->push_back(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(
+      entries->push_back(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(
+      entries->push_back(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
+  //    http://msdn.microsoft.com/en-us/library/windows/desktop/ee872121
+  //  - File Associations
+  //    http://msdn.microsoft.com/en-us/library/bb166549
+  // 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,
+                                        ScopedVector<RegistryEntry>* entries) {
+    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,
+    entries->push_back(new RegistryEntry(app_path_key, chrome_exe));
+    entries->push_back(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_back(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) {
+                                     ScopedVector<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,
+    entries->push_back(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));
+    entries->push_back(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));
+    entries->push_back(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""));
+    entries->push_back(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;
+    entries->push_back(new RegistryEntry(protocol_shell_key, L"open"));
   }
 
   // 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,
+      ScopedVector<RegistryEntry>* entries) {
     // 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));
+      entries->push_back(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;
+    entries->push_back(new RegistryEntry(start_menu, app_name));
   }
 
   // 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 81 matching lines @@
     return found ?
         (correct_value ? SAME_VALUE : DIFFERENT_VALUE) : DOES_NOT_EXIST;
   }
 
   DISALLOW_COPY_AND_ASSIGN(RegistryEntry);
 };  // class RegistryEntry
 
 
 // This method converts all the RegistryEntries from the given list to
 // Set/CreateRegWorkItems and runs them using WorkItemList.
-bool AddRegistryEntries(HKEY root, const std::list<RegistryEntry*>& entries) {
+bool AddRegistryEntries(HKEY root, const ScopedVector<RegistryEntry>& entries) {
   scoped_ptr<WorkItemList> items(WorkItem::CreateWorkItemList());
 
-  for (std::list<RegistryEntry*>::const_iterator itr = entries.begin();
+  for (ScopedVector<RegistryEntry>::const_iterator itr = entries.begin();
        itr != entries.end(); ++itr)
     (*itr)->AddToWorkItemList(root, items.get());
 
   // Apply all the registry changes and if there is a problem, rollback
   if (!items->Do()) {
     items->Rollback();
     return false;
   }
   return true;
 }
 
 // Checks that all |entries| are present on this computer.
 // |look_for_in| is passed to RegistryEntry::ExistsInRegistry(). Documentation
 // for it can be found there.
-bool AreEntriesRegistered(const std::list<RegistryEntry*>& entries,
+bool AreEntriesRegistered(const ScopedVector<RegistryEntry>& entries,
                           uint32 look_for_in) {
   bool registered = true;
-  for (std::list<RegistryEntry*>::const_iterator itr = entries.begin();
+  for (ScopedVector<RegistryEntry>::const_iterator itr = entries.begin();
        registered && itr != entries.end(); ++itr) {
     // We do not need registered = registered && ... since the loop condition
     // is set to exit early.
     registered = (*itr)->ExistsInRegistry(look_for_in);
   }
   return registered;
 }
 
 // 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);
+  ScopedVector<RegistryEntry> 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);
+  ScopedVector<RegistryEntry> entries;
   RegistryEntry::GetProtocolCapabilityEntries(dist, suffix, protocol, &entries);
   return AreEntriesRegistered(entries, RegistryEntry::LOOK_IN_HKCU_THEN_HKLM);
 }
 
 // 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.
@@ skipping 232 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;
+  ScopedVector<RegistryEntry> entries;
+  RegistryEntry::GetDefaultBrowserUserEntries(
+      dist, chrome_exe,
+      ShellUtil::GetCurrentInstallationSuffix(dist, chrome_exe), &entries);
+
+  // Change the default browser for current user.
+  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 15 matching lines @@
       ret = false;
       LOG(ERROR) << "Could not make Chrome default protocol client (Vista):"
                  << " HRESULT=" << hr << ".";
     }
   }
 
   // Now use the old way to associate Chrome with the desired protocol. 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);
+  ScopedVector<RegistryEntry> entries;
   const string16 suffix(GetCurrentInstallationSuffix(dist, chrome_exe));
   const string16 chrome_open(ShellUtil::GetChromeShellOpenCmd(chrome_exe));
   const string16 chrome_icon(ShellUtil::GetChromeIcon(dist, chrome_exe));
   RegistryEntry::GetUserProtocolEntries(protocol, chrome_icon, chrome_open,
                                         &entries);
   // Change the default protocol handler for current user.
   if (!AddRegistryEntries(HKEY_CURRENT_USER, entries)) {
       ret = false;
       LOG(ERROR) << "Could not make Chrome default protocol client (XP).";
   }
@@ skipping 21 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*> shell_entries;
-    STLElementDeleter<std::list<RegistryEntry*> > shell_deleter(&shell_entries);
-    RegistryEntry::GetProgIdEntries(dist, chrome_exe, suffix, &progids);
+    ScopedVector<RegistryEntry> progid_and_appreg_entries;
+    ScopedVector<RegistryEntry> shell_entries;
+    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.
-  std::list<RegistryEntry*> entries;
-  STLElementDeleter<std::list<RegistryEntry*> > entries_deleter(&entries);
-  RegistryEntry::GetProgIdEntries(dist, chrome_exe, L"", &entries);
+  // If we got to this point then all we can do is create ProgId and basic app
+  // registrations under HKCU.
+  ScopedVector<RegistryEntry> 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);
+      entries.clear();
       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).
+    entries.clear();
+    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 13 matching lines @@
   HKEY root = DetermineShellIntegrationRoot(
       InstallUtil::IsPerUserInstall(chrome_exe.c_str()));
 
   if (root == HKEY_CURRENT_USER || IsUserAnAdmin()) {
     // 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);
+    ScopedVector<RegistryEntry> entries;
     RegistryEntry::GetProtocolCapabilityEntries(dist, suffix, protocol,
-        &entries);
+                                                &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 {
     // Admin rights are required to register capabilities before Windows 8.
     return false;
   }
 }
@@ skipping 173 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;
 }