Convert //chrome/installer from scoped_ptr to std::unique_ptr

chrome/installer/setup/uninstall.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 the methods useful for uninstalling Chrome.
 
 #include "chrome/installer/setup/uninstall.h"
 
 #include <windows.h>
 #include <stddef.h>
@@ skipping 120 matching lines @@
       original_state.GetProductState(system_level, distribution->GetType());
   DCHECK(product_state != NULL);
   ChannelInfo channel_info;
 
   // Remove product's flags from the channel value.
   channel_info.set_value(product_state->channel().value());
   const bool modified = product.SetChannelFlags(false, &channel_info);
 
   // Apply the new channel value to all other products and to the multi package.
   if (modified) {
-    scoped_ptr<WorkItemList>
-        update_list(WorkItem::CreateNoRollbackWorkItemList());
+    std::unique_ptr<WorkItemList> update_list(
+        WorkItem::CreateNoRollbackWorkItemList());
     std::vector<BrowserDistribution::Type> dist_types;
     for (size_t i = 0; i < BrowserDistribution::NUM_TYPES; ++i) {
       BrowserDistribution::Type other_dist_type =
           static_cast<BrowserDistribution::Type>(i);
       if (distribution->GetType() != other_dist_type)
         dist_types.push_back(other_dist_type);
     }
     AddChannelValueUpdateWorkItems(original_state, installer_state,
                                    channel_info, dist_types,
                                    update_list.get());
     bool success = update_list->Do();
     LOG_IF(ERROR, !success) << "Failed updating channel values.";
   }
 }
 
 // Processes uninstall WorkItems from install_worker in no-rollback-list.
 void ProcessChromeWorkItems(const InstallerState& installer_state,
                             const Product& product) {
-  scoped_ptr<WorkItemList> work_item_list(
+  std::unique_ptr<WorkItemList> work_item_list(
       WorkItem::CreateNoRollbackWorkItemList());
   AddOsUpgradeWorkItems(installer_state, base::FilePath(), Version(), product,
                         work_item_list.get());
   // Perform a best-effort cleanup of per-user keys. On system-level installs
   // this will only cleanup keys for the user running the uninstall but it was
   // considered that this was good enough (better than triggering Active Setup
   // for all users solely for this cleanup).
   AddCleanupDeprecatedPerUserRegistrationsWorkItems(product,
                                                     work_item_list.get());
   if (!work_item_list->Do())
     LOG(ERROR) << "Failed to process Chrome WorkItems.";
 }
 
 void ProcessIELowRightsPolicyWorkItems(const InstallerState& installer_state) {
-  scoped_ptr<WorkItemList> work_items(WorkItem::CreateNoRollbackWorkItemList());
+  std::unique_ptr<WorkItemList> work_items(
+      WorkItem::CreateNoRollbackWorkItemList());
   AddDeleteOldIELowRightsPolicyWorkItems(installer_state, work_items.get());
   work_items->Do();
   RefreshElevationPolicy();
 }
 
 void ClearRlzProductState() {
   const rlz_lib::AccessPoint points[] = {rlz_lib::CHROME_OMNIBOX,
                                          rlz_lib::CHROME_HOME_PAGE,
                                          rlz_lib::CHROME_APP_LIST,
                                          rlz_lib::NO_ACCESS_POINT};
@@ skipping 878 matching lines @@
     base::string16 ext_association(ShellUtil::kRegClasses);
     ext_association.append(L"\\");
     ext_association.append(L".crx");
     InstallUtil::DeleteRegistryKey(roots[i], ext_association,
                                    WorkItem::kWow64Default);
   }
 }
 
 void UninstallFirewallRules(BrowserDistribution* dist,
                             const base::FilePath& chrome_exe) {
-  scoped_ptr<FirewallManager> manager =
+  std::unique_ptr<FirewallManager> manager =
       FirewallManager::Create(dist, chrome_exe);
   if (manager)
     manager->RemoveFirewallRules();
 }
 
 InstallStatus UninstallProduct(const InstallationState& original_state,
                                const InstallerState& installer_state,
                                const base::FilePath& setup_exe,
                                const Product& product,
                                bool remove_all,
@@ skipping 201 matching lines @@
     }
 
     // Unregister any dll servers that we may have registered for this
     // product.
     if (product_state != NULL) {
       std::vector<base::FilePath> com_dll_list;
       product.AddComDllList(&com_dll_list);
       base::FilePath dll_folder = installer_state.target_path().AppendASCII(
           product_state->version().GetString());
 
-      scoped_ptr<WorkItemList> unreg_work_item_list(
+      std::unique_ptr<WorkItemList> unreg_work_item_list(
           WorkItem::CreateWorkItemList());
 
       AddRegisterComDllWorkItems(dll_folder,
                                  com_dll_list,
                                  installer_state.system_install(),
                                  false,  // Unregister
                                  true,   // May fail
                                  unreg_work_item_list.get());
       unreg_work_item_list->Do();
     }
@@ skipping 122 matching lines @@
     // If we need a reboot to continue, schedule the parent directories for
     // deletion unconditionally. If they are not empty, the session manager
     // will not delete them on reboot.
     ScheduleParentAndGrandparentForDeletion(target_path);
   } else if (DeleteChromeDirectoriesIfEmpty(target_path) == DELETE_FAILED) {
     *uninstall_status = UNINSTALL_FAILED;
   }
 }
 
 }  // namespace installer