Remove ScopedVector from chrome/installer/

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 <windows.h>
 #include <shlobj.h>
 #include <shobjidl.h>
 
+#include <algorithm>
+#include <iterator>
 #include <limits>
 #include <memory>
 #include <string>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/md5.h"
-#include "base/memory/scoped_vector.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/path_service.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/cancellation_flag.h"
@@ skipping 177 matching lines @@
 
 // Returns the Windows Default Programs capabilities key for Chrome.  For
 // example:
 // "Software\Clients\StartMenuInternet\Chromium[.user]\Capabilities".
 base::string16 GetCapabilitiesKey(const base::string16& suffix) {
   return GetBrowserClientKey(suffix).append(L"\\Capabilities");
 }
 
 // DelegateExecute ProgId. Needed for Chrome Metro in Windows 8. This is only
 // needed for registring a web browser, not for general associations.
-ScopedVector<RegistryEntry> GetChromeDelegateExecuteEntries(
+std::vector<std::unique_ptr<RegistryEntry>> GetChromeDelegateExecuteEntries(
     const base::FilePath& chrome_exe,
     const ApplicationInfo& app_info) {
-  ScopedVector<RegistryEntry> entries;
+  std::vector<std::unique_ptr<RegistryEntry>> entries;
 
   base::string16 app_id_shell_key(ShellUtil::kRegClasses);
   app_id_shell_key.push_back(base::FilePath::kSeparators[0]);
   app_id_shell_key.append(app_info.app_id);
   app_id_shell_key.append(ShellUtil::kRegExePath);
   app_id_shell_key.append(ShellUtil::kRegShellPath);
 
   // <root hkey>\Software\Classes\<app_id>\.exe\shell @=open
-  entries.push_back(
-      new RegistryEntry(app_id_shell_key, ShellUtil::kRegVerbOpen));
+  entries.push_back(base::MakeUnique<RegistryEntry>(app_id_shell_key,
+                                                    ShellUtil::kRegVerbOpen));
 
   // The command to execute when opening this application via the Metro UI.
   const base::string16 delegate_command(
       ShellUtil::GetChromeDelegateCommand(chrome_exe));
 
   // Each of Chrome's shortcuts has an appid; which, as of Windows 8, is
   // registered to handle some verbs. This registration has the side-effect
   // that these verbs now show up in the shortcut's context menu. We
   // mitigate this side-effect by making the context menu entries
   // user readable/localized strings. See relevant MSDN article:
   // http://msdn.microsoft.com/en-US/library/windows/desktop/cc144171.aspx
   static const struct {
     const wchar_t* verb;
     int name_id;
   } verbs[] = {
       {ShellUtil::kRegVerbOpen, -1},
       {ShellUtil::kRegVerbOpenNewWindow, IDS_SHORTCUT_NEW_WINDOW_BASE},
   };
   for (const auto& verb_and_id : verbs) {
     base::string16 sub_path(app_id_shell_key);
     sub_path.push_back(base::FilePath::kSeparators[0]);
     sub_path.append(verb_and_id.verb);
 
     // <root hkey>\Software\Classes\<app_id>\.exe\shell\<verb>
     if (verb_and_id.name_id != -1) {
       // TODO(grt): http://crbug.com/75152 Write a reference to a localized
       // resource.
       const base::string16 verb_name(
           installer::GetLocalizedString(verb_and_id.name_id));
-      entries.push_back(new RegistryEntry(sub_path, verb_name.c_str()));
+      entries.push_back(
+          base::MakeUnique<RegistryEntry>(sub_path, verb_name.c_str()));
     }
-    entries.push_back(
-        new RegistryEntry(sub_path, L"CommandId", L"Browser.Launch"));
+    entries.push_back(base::MakeUnique<RegistryEntry>(sub_path, L"CommandId",
+                                                      L"Browser.Launch"));
 
     sub_path.push_back(base::FilePath::kSeparators[0]);
     sub_path.append(ShellUtil::kRegCommand);
 
     // <root hkey>\Software\Classes\<app_id>\.exe\shell\<verb>\command
-    entries.push_back(new RegistryEntry(sub_path, delegate_command));
-    entries.push_back(new RegistryEntry(
+    entries.push_back(
+        base::MakeUnique<RegistryEntry>(sub_path, delegate_command));
+    entries.push_back(base::MakeUnique<RegistryEntry>(
         sub_path, ShellUtil::kRegDelegateExecute, app_info.delegate_clsid));
   }
 
   return entries;
 }
 
 // Gets the registry entries to register an application in the Windows registry.
 // |app_info| provides all of the information needed.
 void GetProgIdEntries(const ApplicationInfo& app_info,
-                      ScopedVector<RegistryEntry>* entries) {
+                      std::vector<std::unique_ptr<RegistryEntry>>* entries) {
   // Basic sanity checks.
   DCHECK(!app_info.prog_id.empty());
   DCHECK_NE(L'.', app_info.prog_id[0]);
 
   // File association ProgId
   base::string16 prog_id_path(ShellUtil::kRegClasses);
   prog_id_path.push_back(base::FilePath::kSeparators[0]);
   prog_id_path.append(app_info.prog_id);
-  entries->push_back(new RegistryEntry(prog_id_path, app_info.file_type_name));
-  entries->push_back(new RegistryEntry(
+  entries->push_back(
+      base::MakeUnique<RegistryEntry>(prog_id_path, app_info.file_type_name));
+  entries->push_back(base::MakeUnique<RegistryEntry>(
       prog_id_path + ShellUtil::kRegDefaultIcon,
       ShellUtil::FormatIconLocation(app_info.file_type_icon_path,
                                     app_info.file_type_icon_index)));
-  entries->push_back(new RegistryEntry(prog_id_path + ShellUtil::kRegShellOpen,
-                                       app_info.command_line));
+  entries->push_back(base::MakeUnique<RegistryEntry>(
+      prog_id_path + ShellUtil::kRegShellOpen, app_info.command_line));
   if (!app_info.delegate_clsid.empty()) {
-    entries->push_back(new RegistryEntry(
+    entries->push_back(base::MakeUnique<RegistryEntry>(
         prog_id_path + ShellUtil::kRegShellOpen, ShellUtil::kRegDelegateExecute,
         app_info.delegate_clsid));
     // TODO(scottmg): Simplify after Metro removal. https://crbug.com/558054.
     entries->back()->set_removal_flag(RegistryEntry::RemovalFlag::VALUE);
   }
 
   // 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) {
     if (!app_info.app_id.empty()) {
-      entries->push_back(new RegistryEntry(
+      entries->push_back(base::MakeUnique<RegistryEntry>(
           prog_id_path, ShellUtil::kRegAppUserModelId, app_info.app_id));
     }
 
     // Add \Software\Classes\<prog_id>\Application entries
     base::string16 application_path(prog_id_path + ShellUtil::kRegApplication);
     if (!app_info.app_id.empty()) {
-      entries->push_back(new RegistryEntry(
+      entries->push_back(base::MakeUnique<RegistryEntry>(
           application_path, ShellUtil::kRegAppUserModelId, app_info.app_id));
     }
     if (!app_info.application_icon_path.empty()) {
-      entries->push_back(new RegistryEntry(
+      entries->push_back(base::MakeUnique<RegistryEntry>(
           application_path, ShellUtil::kRegApplicationIcon,
           ShellUtil::FormatIconLocation(app_info.application_icon_path,
                                         app_info.application_icon_index)));
     }
     if (!app_info.application_name.empty()) {
-      entries->push_back(new RegistryEntry(application_path,
-                                           ShellUtil::kRegApplicationName,
-                                           app_info.application_name));
+      entries->push_back(base::MakeUnique<RegistryEntry>(
+          application_path, ShellUtil::kRegApplicationName,
+          app_info.application_name));
     }
     if (!app_info.application_description.empty()) {
-      entries->push_back(new RegistryEntry(
+      entries->push_back(base::MakeUnique<RegistryEntry>(
           application_path, ShellUtil::kRegApplicationDescription,
           app_info.application_description));
     }
     if (!app_info.publisher_name.empty()) {
-      entries->push_back(new RegistryEntry(application_path,
-                                           ShellUtil::kRegApplicationCompany,
-                                           app_info.publisher_name));
+      entries->push_back(base::MakeUnique<RegistryEntry>(
+          application_path, ShellUtil::kRegApplicationCompany,
+          app_info.publisher_name));
     }
   }
 }
 
 // This method returns a list of all the registry entries that are needed to
 // register this installation's ProgId and AppId. These entries need to be
 // registered in HKLM prior to Win8.
-void GetChromeProgIdEntries(BrowserDistribution* dist,
-                            const base::FilePath& chrome_exe,
-                            const base::string16& suffix,
-                            ScopedVector<RegistryEntry>* entries) {
+void GetChromeProgIdEntries(
+    BrowserDistribution* dist,
+    const base::FilePath& chrome_exe,
+    const base::string16& suffix,
+    std::vector<std::unique_ptr<RegistryEntry>>* entries) {
   int chrome_icon_index = install_static::GetIconResourceIndex();
 
   ApplicationInfo app_info;
   app_info.prog_id = GetBrowserProgId(suffix);
   app_info.file_type_name = install_static::GetProgIdDescription();
   // File types associated with Chrome are just given the Chrome icon.
   app_info.file_type_icon_path = chrome_exe;
   app_info.file_type_icon_index = chrome_icon_index;
   app_info.command_line = ShellUtil::GetChromeShellOpenCmd(chrome_exe);
   // For user-level installs: entries for the app id will be in HKCU; thus we
   // do not need a suffix on those entries.
   app_info.app_id =
       ShellUtil::GetBrowserModelId(InstallUtil::IsPerUserInstall());
 
   // TODO(grt): http://crbug.com/75152 Write a reference to a localized
   // resource for name, description, and company.
   app_info.application_name = dist->GetDisplayName();
   app_info.application_icon_path = chrome_exe;
   app_info.application_icon_index = chrome_icon_index;
   app_info.application_description = dist->GetAppDescription();
   app_info.publisher_name = dist->GetPublisherName();
   app_info.delegate_clsid = install_static::GetLegacyCommandExecuteImplClsid();
 
   GetProgIdEntries(app_info, entries);
 
   if (!app_info.delegate_clsid.empty()) {
-    ScopedVector<RegistryEntry> delegate_execute_entries =
+    auto delegate_execute_entries =
         GetChromeDelegateExecuteEntries(chrome_exe, app_info);
     // Remove the keys (not only their values) so that Windows will continue
     // to launch Chrome without a pesky association error.
     // TODO(scottmg): Simplify after Metro removal. https://crbug.com/558054.
-    for (RegistryEntry* entry : delegate_execute_entries)
+    for (const auto& entry : delegate_execute_entries)
       entry->set_removal_flag(RegistryEntry::RemovalFlag::KEY);
     // Move |delegate_execute_entries| to |entries|.
-    entries->insert(entries->end(), delegate_execute_entries.begin(),
-                    delegate_execute_entries.end());
-    delegate_execute_entries.weak_clear();
+    std::move(delegate_execute_entries.begin(), delegate_execute_entries.end(),
+              std::back_inserter(*entries));
   }
 }
 
 // This method returns a list of the registry entries needed to declare a
 // capability of handling a protocol on Windows.
-void GetProtocolCapabilityEntries(const base::string16& suffix,
-                                  const base::string16& protocol,
-                                  ScopedVector<RegistryEntry>* entries) {
-  entries->push_back(
-      new RegistryEntry(GetCapabilitiesKey(suffix).append(L"\\URLAssociations"),
-                        protocol, GetBrowserProgId(suffix)));
+void GetProtocolCapabilityEntries(
+    const base::string16& suffix,
+    const base::string16& protocol,
+    std::vector<std::unique_ptr<RegistryEntry>>* entries) {
+  entries->push_back(base::MakeUnique<RegistryEntry>(
+      GetCapabilitiesKey(suffix).append(L"\\URLAssociations"), protocol,
+      GetBrowserProgId(suffix)));
 }
 
 // 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.
-void GetShellIntegrationEntries(BrowserDistribution* dist,
-                                const base::FilePath& chrome_exe,
-                                const base::string16& suffix,
-                                ScopedVector<RegistryEntry>* entries) {
+void GetShellIntegrationEntries(
+    BrowserDistribution* dist,
+    const base::FilePath& chrome_exe,
+    const base::string16& suffix,
+    std::vector<std::unique_ptr<RegistryEntry>>* entries) {
   const base::string16 icon_path(ShellUtil::FormatIconLocation(
       chrome_exe, install_static::GetIconResourceIndex()));
   const base::string16 quoted_exe_path(L"\"" + chrome_exe.value() + L"\"");
 
   // Register for the Start Menu "Internet" link (pre-Win7).
   const base::string16 start_menu_entry(GetBrowserClientKey(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_back(
-      new RegistryEntry(start_menu_entry, dist->GetDisplayName()));
+  entries->push_back(base::MakeUnique<RegistryEntry>(start_menu_entry,
+                                                     dist->GetDisplayName()));
   // Register the "open" verb for launching Chrome via the "Internet" link.
-  entries->push_back(new RegistryEntry(
+  entries->push_back(base::MakeUnique<RegistryEntry>(
       start_menu_entry + ShellUtil::kRegShellOpen, quoted_exe_path));
   // Register Chrome's icon for the Start Menu "Internet" link.
-  entries->push_back(new RegistryEntry(
+  entries->push_back(base::MakeUnique<RegistryEntry>(
       start_menu_entry + ShellUtil::kRegDefaultIcon, icon_path));
 
   // Register installation information.
   base::string16 install_info(start_menu_entry + L"\\InstallInfo");
   // Note: not using CommandLine since it has ambiguous rules for quoting
   // strings.
-  entries->push_back(
-      new RegistryEntry(install_info, kReinstallCommand,
-                        quoted_exe_path + L" --" +
-                            base::ASCIIToUTF16(switches::kMakeDefaultBrowser)));
-  entries->push_back(new RegistryEntry(
+  entries->push_back(base::MakeUnique<RegistryEntry>(
+      install_info, kReinstallCommand,
+      quoted_exe_path + L" --" +
+          base::ASCIIToUTF16(switches::kMakeDefaultBrowser)));
+  entries->push_back(base::MakeUnique<RegistryEntry>(
       install_info, L"HideIconsCommand",
       quoted_exe_path + L" --" + base::ASCIIToUTF16(switches::kHideIcons)));
-  entries->push_back(new RegistryEntry(
+  entries->push_back(base::MakeUnique<RegistryEntry>(
       install_info, L"ShowIconsCommand",
       quoted_exe_path + L" --" + base::ASCIIToUTF16(switches::kShowIcons)));
-  entries->push_back(new RegistryEntry(install_info, L"IconsVisible", 1));
+  entries->push_back(
+      base::MakeUnique<RegistryEntry>(install_info, L"IconsVisible", 1));
 
   // Register with Default Programs.
   const base::string16 reg_app_name(
       install_static::GetBaseAppName().append(suffix));
   // Tell Windows where to find Chrome's Default Programs info.
   const base::string16 capabilities(GetCapabilitiesKey(suffix));
-  entries->push_back(new RegistryEntry(ShellUtil::kRegRegisteredApplications,
-                                       reg_app_name, capabilities));
+  entries->push_back(base::MakeUnique<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_back(new RegistryEntry(capabilities,
-                                       ShellUtil::kRegApplicationDescription,
-                                       dist->GetLongAppDescription()));
-  entries->push_back(new RegistryEntry(
+  entries->push_back(base::MakeUnique<RegistryEntry>(
+      capabilities, ShellUtil::kRegApplicationDescription,
+      dist->GetLongAppDescription()));
+  entries->push_back(base::MakeUnique<RegistryEntry>(
       capabilities, ShellUtil::kRegApplicationIcon, icon_path));
-  entries->push_back(new RegistryEntry(
+  entries->push_back(base::MakeUnique<RegistryEntry>(
       capabilities, ShellUtil::kRegApplicationName, dist->GetDisplayName()));
 
-  entries->push_back(new RegistryEntry(capabilities + L"\\Startmenu",
-                                       L"StartMenuInternet", reg_app_name));
+  entries->push_back(base::MakeUnique<RegistryEntry>(
+      capabilities + L"\\Startmenu", L"StartMenuInternet", reg_app_name));
 
   const base::string16 html_prog_id(GetBrowserProgId(suffix));
   for (int i = 0; ShellUtil::kPotentialFileAssociations[i] != NULL; i++) {
-    entries->push_back(new RegistryEntry(
+    entries->push_back(base::MakeUnique<RegistryEntry>(
         capabilities + L"\\FileAssociations",
         ShellUtil::kPotentialFileAssociations[i], html_prog_id));
   }
   for (int i = 0; ShellUtil::kPotentialProtocolAssociations[i] != NULL; i++) {
-    entries->push_back(new RegistryEntry(
+    entries->push_back(base::MakeUnique<RegistryEntry>(
         capabilities + L"\\URLAssociations",
         ShellUtil::kPotentialProtocolAssociations[i], html_prog_id));
   }
 }
 
 // Gets the registry entries to register an application as a handler for a
 // particular file extension. |prog_id| is the ProgId used by Windows for the
 // application. |ext| is the file extension, which must begin with a '.'.
-void GetAppExtRegistrationEntries(const base::string16& prog_id,
-                                  const base::string16& ext,
-                                  ScopedVector<RegistryEntry>* entries) {
+void GetAppExtRegistrationEntries(
+    const base::string16& prog_id,
+    const base::string16& ext,
+    std::vector<std::unique_ptr<RegistryEntry>>* entries) {
   // In HKEY_CURRENT_USER\Software\Classes\EXT\OpenWithProgids, create an
   // empty value with this class's ProgId.
   base::string16 key_name(ShellUtil::kRegClasses);
   key_name.push_back(base::FilePath::kSeparators[0]);
   key_name.append(ext);
   key_name.push_back(base::FilePath::kSeparators[0]);
   key_name.append(ShellUtil::kRegOpenWithProgids);
-  entries->push_back(new RegistryEntry(key_name, prog_id, base::string16()));
+  entries->push_back(
+      base::MakeUnique<RegistryEntry>(key_name, prog_id, base::string16()));
 }
 
 // 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 need to be registered in HKLM prior to Win8.
-void GetChromeAppRegistrationEntries(const base::FilePath& chrome_exe,
-                                     const base::string16& suffix,
-                                     ScopedVector<RegistryEntry>* entries) {
+void GetChromeAppRegistrationEntries(
+    const base::FilePath& chrome_exe,
+    const base::string16& suffix,
+    std::vector<std::unique_ptr<RegistryEntry>>* entries) {
   base::string16 app_path_key(ShellUtil::kAppPathsRegistryKey);
   app_path_key.push_back(base::FilePath::kSeparators[0]);
   app_path_key.append(chrome_exe.BaseName().value());
-  entries->push_back(new RegistryEntry(app_path_key, chrome_exe.value()));
-  entries->push_back(new RegistryEntry(app_path_key,
-                                       ShellUtil::kAppPathsRegistryPathName,
-                                       chrome_exe.DirName().value()));
+  entries->push_back(
+      base::MakeUnique<RegistryEntry>(app_path_key, chrome_exe.value()));
+  entries->push_back(base::MakeUnique<RegistryEntry>(
+      app_path_key, ShellUtil::kAppPathsRegistryPathName,
+      chrome_exe.DirName().value()));
 
   const base::string16 html_prog_id(GetBrowserProgId(suffix));
   for (int i = 0; ShellUtil::kPotentialFileAssociations[i] != NULL; i++) {
     GetAppExtRegistrationEntries(
         html_prog_id, ShellUtil::kPotentialFileAssociations[i], entries);
   }
 }
 
 // Gets the registry entries to register an application as the default handler
 // for a particular file extension. |prog_id| is the ProgId used by Windows for
 // the application. |ext| is the file extension, which must begin with a '.'. If
 // |overwrite_existing|, always sets the default handler; otherwise only sets if
 // there is no existing default.
 //
 // This has no effect on Windows 8. Windows 8 ignores the default and lets the
 // user choose. If there is only one handler for a file, it will automatically
 // become the default. Otherwise, the first time the user opens a file, they are
 // presented with the dialog to set the default handler. (This is roughly
 // equivalent to being called with |overwrite_existing| false.)
-void GetAppDefaultRegistrationEntries(const base::string16& prog_id,
-                                      const base::string16& ext,
-                                      bool overwrite_existing,
-                                      ScopedVector<RegistryEntry>* entries) {
+void GetAppDefaultRegistrationEntries(
+    const base::string16& prog_id,
+    const base::string16& ext,
+    bool overwrite_existing,
+    std::vector<std::unique_ptr<RegistryEntry>>* entries) {
   // Set the default value of HKEY_CURRENT_USER\Software\Classes\EXT to this
   // class's name.
   base::string16 key_name(ShellUtil::kRegClasses);
   key_name.push_back(base::FilePath::kSeparators[0]);
   key_name.append(ext);
-  std::unique_ptr<RegistryEntry> default_association(
-      new RegistryEntry(key_name, prog_id));
+  auto default_association = base::MakeUnique<RegistryEntry>(key_name, prog_id);
   if (overwrite_existing ||
       !default_association->KeyExistsInRegistry(RegistryEntry::LOOK_IN_HKCU)) {
-    entries->push_back(default_association.release());
+    entries->push_back(std::move(default_association));
   }
 }
 
 // This method returns a list of all the user level registry entries that are
 // needed to make Chromium the default handler for a protocol on XP.
-void GetXPStyleUserProtocolEntries(const base::string16& protocol,
-                                   const base::string16& chrome_icon,
-                                   const base::string16& chrome_open,
-                                   ScopedVector<RegistryEntry>* entries) {
+void GetXPStyleUserProtocolEntries(
+    const base::string16& protocol,
+    const base::string16& chrome_icon,
+    const base::string16& chrome_open,
+    std::vector<std::unique_ptr<RegistryEntry>>* entries) {
   // Protocols associations.
   base::string16 url_key(ShellUtil::kRegClasses);
   url_key.push_back(base::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_back(
-      new RegistryEntry(url_key, ShellUtil::kRegUrlProtocol, base::string16()));
+  entries->push_back(base::MakeUnique<RegistryEntry>(
+      url_key, ShellUtil::kRegUrlProtocol, base::string16()));
 
   // <root hkey>\Software\Classes\<protocol>\DefaultIcon
   base::string16 icon_key = url_key + ShellUtil::kRegDefaultIcon;
-  entries->push_back(new RegistryEntry(icon_key, chrome_icon));
+  entries->push_back(base::MakeUnique<RegistryEntry>(icon_key, chrome_icon));
 
   // <root hkey>\Software\Classes\<protocol>\shell\open\command
   base::string16 shell_key = url_key + ShellUtil::kRegShellOpen;
-  entries->push_back(new RegistryEntry(shell_key, chrome_open));
+  entries->push_back(base::MakeUnique<RegistryEntry>(shell_key, chrome_open));
 
   // <root hkey>\Software\Classes\<protocol>\shell\open\ddeexec
   base::string16 dde_key = url_key + L"\\shell\\open\\ddeexec";
-  entries->push_back(new RegistryEntry(dde_key, base::string16()));
+  entries->push_back(
+      base::MakeUnique<RegistryEntry>(dde_key, base::string16()));
 
   // <root hkey>\Software\Classes\<protocol>\shell\@
   base::string16 protocol_shell_key = url_key + ShellUtil::kRegShellPath;
-  entries->push_back(new RegistryEntry(protocol_shell_key, L"open"));
+  entries->push_back(
+      base::MakeUnique<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 on XP. 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.
-void GetXPStyleDefaultBrowserUserEntries(const base::FilePath& chrome_exe,
-                                         const base::string16& suffix,
-                                         ScopedVector<RegistryEntry>* entries) {
+void GetXPStyleDefaultBrowserUserEntries(
+    const base::FilePath& chrome_exe,
+    const base::string16& suffix,
+    std::vector<std::unique_ptr<RegistryEntry>>* entries) {
   // File extension associations.
   base::string16 html_prog_id(GetBrowserProgId(suffix));
   for (int i = 0; ShellUtil::kDefaultFileAssociations[i] != NULL; i++) {
     GetAppDefaultRegistrationEntries(
         html_prog_id, ShellUtil::kDefaultFileAssociations[i], true, entries);
   }
 
   // Protocols associations.
   base::string16 chrome_open = ShellUtil::GetChromeShellOpenCmd(chrome_exe);
   base::string16 chrome_icon = ShellUtil::FormatIconLocation(
       chrome_exe, install_static::GetIconResourceIndex());
   for (int i = 0; ShellUtil::kBrowserProtocolAssociations[i] != NULL; i++) {
     GetXPStyleUserProtocolEntries(ShellUtil::kBrowserProtocolAssociations[i],
                                   chrome_icon, chrome_open, entries);
   }
 
   // start->Internet shortcut.
   base::string16 start_menu(ShellUtil::kRegStartMenuInternet);
   base::string16 app_name = install_static::GetBaseAppName().append(suffix);
-  entries->push_back(new RegistryEntry(start_menu, app_name));
+  entries->push_back(base::MakeUnique<RegistryEntry>(start_menu, app_name));
 }
 
 // Checks that all |entries| are present on this computer (or absent if their
 // |removal_flag_| is set). |look_for_in| is passed to
 // RegistryEntry::ExistsInRegistry(). Documentation for it can be found there.
-bool AreEntriesAsDesired(const ScopedVector<RegistryEntry>& entries,
-                         uint32_t look_for_in) {
-  for (const auto* entry : entries) {
+bool AreEntriesAsDesired(
+    const std::vector<std::unique_ptr<RegistryEntry>>& entries,
+    uint32_t look_for_in) {
+  for (const auto& entry : entries) {
     if (entry->ExistsInRegistry(look_for_in) != !entry->IsFlaggedForRemoval())
       return false;
   }
   return true;
 }
 
 // Checks that all required registry entries for Chrome are already present on
 // this computer (or absent if their |removal_flag_| is set).
 // See RegistryEntry::ExistsInRegistry for the behavior of |look_for_in|.
 // Note: between r133333 and r154145 we were registering parts of Chrome in HKCU
 // and parts in HKLM for user-level installs; we now always register everything
 // under a single registry root. Not doing so caused http://crbug.com/144910 for
 // users who first-installed Chrome in that revision range (those users are
 // still impacted by http://crbug.com/144910). This method will keep returning
 // true for affected users (i.e. who have all the registrations, but over both
 // registry roots).
 bool IsChromeRegistered(BrowserDistribution* dist,
                         const base::FilePath& chrome_exe,
                         const base::string16& suffix,
                         uint32_t look_for_in) {
-  ScopedVector<RegistryEntry> entries;
+  std::vector<std::unique_ptr<RegistryEntry>> entries;
   GetChromeProgIdEntries(dist, chrome_exe, suffix, &entries);
   GetShellIntegrationEntries(dist, chrome_exe, suffix, &entries);
   GetChromeAppRegistrationEntries(chrome_exe, suffix, &entries);
   return AreEntriesAsDesired(entries, look_for_in);
 }
 
 // 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.
 // See RegistryEntry::ExistsInRegistry for the behavior of |look_for_in|.
 bool IsChromeRegisteredForProtocol(const base::string16& suffix,
                                    const base::string16& protocol,
                                    uint32_t look_for_in) {
-  ScopedVector<RegistryEntry> entries;
+  std::vector<std::unique_ptr<RegistryEntry>> entries;
   GetProtocolCapabilityEntries(suffix, protocol, &entries);
   return AreEntriesAsDesired(entries, look_for_in);
 }
 
 // This method registers Chrome by launching an elevated setup.exe. That will
 // show the user the standard 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. This is most commonly used on per-user
 // installs on Windows 7 where setup.exe did not have permission to register
@@ skipping 212 matching lines @@
   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 RegisterChromeAsDefaultXPStyle(int shell_change,
                                     const base::FilePath& chrome_exe) {
   bool ret = true;
-  ScopedVector<RegistryEntry> entries;
+  std::vector<std::unique_ptr<RegistryEntry>> entries;
   GetXPStyleDefaultBrowserUserEntries(
       chrome_exe, ShellUtil::GetCurrentInstallationSuffix(chrome_exe),
       &entries);
 
   // Change the default browser for current user.
   if ((shell_change & ShellUtil::CURRENT_USER) &&
       !ShellUtil::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) &&
       !ShellUtil::AddRegistryEntries(HKEY_LOCAL_MACHINE, entries)) {
     ret = false;
     LOG(ERROR) << "Could not make Chrome default browser (XP/system level).";
   }
 
   return ret;
 }
 
 // Associates Chrome with |protocol| in the registry. This should not be
 // required on Vista+ but since some applications still read these registry
 // keys directly, we have to do this on Vista+ as well.
 // See http://msdn.microsoft.com/library/aa767914.aspx for more details.
 bool RegisterChromeAsDefaultProtocolClientXPStyle(
     const base::FilePath& chrome_exe,
     const base::string16& protocol) {
-  ScopedVector<RegistryEntry> entries;
+  std::vector<std::unique_ptr<RegistryEntry>> entries;
   const base::string16 chrome_open(
       ShellUtil::GetChromeShellOpenCmd(chrome_exe));
   const base::string16 chrome_icon(ShellUtil::FormatIconLocation(
       chrome_exe, install_static::GetIconResourceIndex()));
   GetXPStyleUserProtocolEntries(protocol, chrome_icon, chrome_open, &entries);
   // Change the default protocol handler for current user.
   if (!ShellUtil::AddRegistryEntries(HKEY_CURRENT_USER, entries)) {
     LOG(ERROR) << "Could not make Chrome default protocol client (XP).";
     return false;
   }
@@ skipping 1136 matching lines @@
                                     : RegistryEntry::LOOK_IN_HKLM;
 
   // Check if chrome is already registered with this suffix.
   if (IsChromeRegistered(dist, chrome_exe, suffix, look_for_in))
     return true;
 
   bool result = true;
   if (root == HKEY_CURRENT_USER || IsUserAnAdmin()) {
     // Do the full registration if we can do it at user-level or if the user is
     // an admin.
-    ScopedVector<RegistryEntry> progid_and_appreg_entries;
-    ScopedVector<RegistryEntry> shell_entries;
+    std::vector<std::unique_ptr<RegistryEntry>> progid_and_appreg_entries;
+    std::vector<std::unique_ptr<RegistryEntry>> shell_entries;
     GetChromeProgIdEntries(dist, chrome_exe, suffix,
                            &progid_and_appreg_entries);
     GetChromeAppRegistrationEntries(chrome_exe, suffix,
                                     &progid_and_appreg_entries);
     GetShellIntegrationEntries(dist, chrome_exe, suffix, &shell_entries);
     result = (AddRegistryEntries(root, progid_and_appreg_entries) &&
               AddRegistryEntries(root, shell_entries));
   } else if (elevate_if_not_admin &&
       base::win::GetVersion() >= base::win::VERSION_VISTA &&
       ElevateAndRegisterChrome(dist, chrome_exe, suffix, base::string16())) {
     // 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.
     result = true;
   } else {
     // If we got to this point then all we can do is create ProgId and basic app
     // registrations under HKCU.
-    ScopedVector<RegistryEntry> entries;
+    std::vector<std::unique_ptr<RegistryEntry>> entries;
     GetChromeProgIdEntries(dist, chrome_exe, base::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 (!AreEntriesAsDesired(entries, RegistryEntry::LOOK_IN_HKCU)) {
       if (!suffix.empty()) {
         entries.clear();
         GetChromeProgIdEntries(dist, chrome_exe, suffix, &entries);
         GetChromeAppRegistrationEntries(chrome_exe, suffix, &entries);
@@ skipping 42 matching lines @@
   if (IsChromeRegisteredForProtocol(suffix, protocol, look_for_in))
     return true;
 
   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.
-    ScopedVector<RegistryEntry> entries;
+    std::vector<std::unique_ptr<RegistryEntry>> entries;
     GetProtocolCapabilityEntries(suffix, protocol, &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 91 matching lines @@
   return true;
 }
 
 // static
 bool ShellUtil::AddFileAssociations(
     const base::string16& prog_id,
     const base::CommandLine& command_line,
     const base::string16& file_type_name,
     const base::FilePath& icon_path,
     const std::set<base::string16>& file_extensions) {
-  ScopedVector<RegistryEntry> entries;
+  std::vector<std::unique_ptr<RegistryEntry>> entries;
 
   // Create a class for this app.
   ApplicationInfo app_info;
   app_info.prog_id = prog_id;
   app_info.file_type_name = file_type_name;
   app_info.file_type_icon_path = icon_path;
   app_info.file_type_icon_index = 0;
   app_info.command_line = command_line.GetCommandLineStringWithPlaceholders();
   GetProgIdEntries(app_info, &entries);
 
@@ skipping 27 matching lines @@
   key_path.append(prog_id);
   return InstallUtil::DeleteRegistryKey(
       HKEY_CURRENT_USER, key_path, WorkItem::kWow64Default);
 
   // TODO(mgiuca): Remove the extension association entries. This requires that
   // the extensions associated with a particular prog_id are stored in that
   // prog_id's key.
 }
 
 // static
-bool ShellUtil::AddRegistryEntries(HKEY root,
-                                   const ScopedVector<RegistryEntry>& entries) {
+bool ShellUtil::AddRegistryEntries(
+    HKEY root,
+    const std::vector<std::unique_ptr<RegistryEntry>>& entries) {
   std::unique_ptr<WorkItemList> items(WorkItem::CreateWorkItemList());
 
-  for (ScopedVector<RegistryEntry>::const_iterator itr = entries.begin();
-       itr != entries.end(); ++itr)
-    (*itr)->AddToWorkItemList(root, items.get());
+  for (const auto& entry : entries)
+    entry->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;
 }