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

chrome/installer/setup/setup_main.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.
 
 #include "chrome/installer/setup/setup_main.h"
 
 #include <windows.h>
 #include <msi.h>
 #include <shellapi.h>
 #include <shlobj.h>
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/file_version_info.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/path_service.h"
 #include "base/process/launch.h"
 #include "base/process/memory.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
@@ skipping 132 matching lines @@
   base::Process writer = base::LaunchProcess(command_line, launch_options);
   if (!writer.IsValid()) {
     PLOG(ERROR) << "Failed to set DisplayVersion: "
                 << "could not launch subprocess to make desired changes."
                 << " <<" << command_line.GetCommandLineString() << ">>";
   }
 }
 
 // Returns NULL if no compressed archive is available for processing, otherwise
 // returns a patch helper configured to uncompress and patch.
-scoped_ptr<installer::ArchivePatchHelper> CreateChromeArchiveHelper(
+std::unique_ptr<installer::ArchivePatchHelper> CreateChromeArchiveHelper(
     const base::FilePath& setup_exe,
     const base::CommandLine& command_line,
     const installer::InstallerState& installer_state,
     const base::FilePath& working_directory) {
   // A compressed archive is ordinarily given on the command line by the mini
   // installer. If one was not given, look for chrome.packed.7z next to the
   // running program.
   base::FilePath compressed_archive(
       command_line.GetSwitchValuePath(installer::switches::kInstallArchive));
   bool compressed_archive_specified = !compressed_archive.empty();
   if (!compressed_archive_specified) {
     compressed_archive = setup_exe.DirName().Append(
         installer::kChromeCompressedArchive);
   }
 
   // Fail if no compressed archive is found.
   if (!base::PathExists(compressed_archive)) {
     if (compressed_archive_specified) {
       LOG(ERROR) << installer::switches::kInstallArchive << "="
                  << compressed_archive.value() << " not found.";
     }
-    return scoped_ptr<installer::ArchivePatchHelper>();
+    return std::unique_ptr<installer::ArchivePatchHelper>();
   }
 
   // chrome.7z is either extracted directly from the compressed archive into the
   // working dir or is the target of patching in the working dir.
   base::FilePath target(working_directory.Append(installer::kChromeArchive));
   DCHECK(!base::PathExists(target));
 
   // Specify an empty path for the patch source since it isn't yet known that
   // one is needed. It will be supplied in UncompressAndPatchChromeArchive if it
   // is.
-  return scoped_ptr<installer::ArchivePatchHelper>(
-      new installer::ArchivePatchHelper(working_directory,
-                                        compressed_archive,
-                                        base::FilePath(),
-                                        target));
+  return std::unique_ptr<installer::ArchivePatchHelper>(
+      new installer::ArchivePatchHelper(working_directory, compressed_archive,
+                                        base::FilePath(), target));
 }
 
 // Returns the MSI product ID from the ClientState key that is populated for MSI
 // installs.  This property is encoded in a value name whose format is
 // "EnterpriseId<GUID>" where <GUID> is the MSI product id.  <GUID> is in the
 // format XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX.  The id will be returned if
 // found otherwise this method will return an empty string.
 //
 // This format is strange and its provenance is shrouded in mystery but it has
 // the data we need, so use it.
@@ skipping 161 matching lines @@
   // Create a temporary backup directory on the same volume as chrome.exe so
   // that moving in-use files doesn't lead to trouble.
   installer::SelfCleaningTempDir temp_path;
   if (!temp_path.Initialize(target_path.DirName(),
                             installer::kInstallTempDir)) {
     PLOG(ERROR) << "Failed to create Temp directory "
                 << target_path.DirName()
                        .Append(installer::kInstallTempDir).value();
     return installer::RENAME_FAILED;
   }
-  scoped_ptr<WorkItemList> install_list(WorkItem::CreateWorkItemList());
+  std::unique_ptr<WorkItemList> install_list(WorkItem::CreateWorkItemList());
   // Move chrome.exe to old_chrome.exe, then move new_chrome.exe to chrome.exe.
   install_list->AddMoveTreeWorkItem(chrome_exe.value(),
                                     chrome_old_exe.value(),
                                     temp_path.path().value(),
                                     WorkItem::ALWAYS_MOVE);
   install_list->AddMoveTreeWorkItem(chrome_new_exe.value(),
                                     chrome_exe.value(),
                                     temp_path.path().value(),
                                     WorkItem::ALWAYS_MOVE);
   install_list->AddDeleteTreeWorkItem(chrome_new_exe, temp_path.path());
@@ skipping 73 matching lines @@
       }
     } else {
       // This will only be hit if --multi-install is given with no products.
       return true;
     }
 
     if (!chrome && chrome_state) {
       // A product other than Chrome is being installed in multi-install mode,
       // and Chrome is already present. Add Chrome to the set of products
       // (making it multi-install in the process) so that it is updated, too.
-      scoped_ptr<Product> multi_chrome(new Product(
-          BrowserDistribution::GetSpecificDistribution(
+      std::unique_ptr<Product> multi_chrome(
+          new Product(BrowserDistribution::GetSpecificDistribution(
               BrowserDistribution::CHROME_BROWSER)));
       multi_chrome->SetOption(installer::kOptionMultiInstall, true);
       chrome = installer_state->AddProduct(&multi_chrome);
       VLOG(1) << "Upgrading existing Chrome browser in multi-install mode.";
     }
   }  // else migrate multi-install Chrome to single-install.
 
   return true;
 }
 
@@ skipping 727 matching lines @@
     if (chrome_install) {
       installer::DeleteChromeRegistrationKeys(*installer_state,
           chrome_install->distribution(), HKEY_LOCAL_MACHINE, suffix, &tmp);
     }
     *exit_code = tmp;
   } else if (cmd_line.HasSwitch(installer::switches::kOnOsUpgrade)) {
     const Product* chrome_install =
         installer_state->FindProduct(BrowserDistribution::CHROME_BROWSER);
     installer::InstallStatus status = installer::INVALID_STATE_FOR_OPTION;
     if (chrome_install) {
-      scoped_ptr<FileVersionInfo> version_info(
+      std::unique_ptr<FileVersionInfo> version_info(
           FileVersionInfo::CreateFileVersionInfo(setup_exe));
       const base::Version installed_version(
           base::UTF16ToUTF8(version_info->product_version()));
       if (installed_version.IsValid()) {
         installer::HandleOsUpgradeForBrowser(*installer_state, *chrome_install,
                                              installed_version);
         status = installer::INSTALL_REPAIRED;
       } else {
         LOG(DFATAL) << "Failed to extract product version from "
                     << setup_exe.value();
@@ skipping 175 matching lines @@
   *archive_type = UNKNOWN_ARCHIVE_TYPE;
   base::FilePath uncompressed_archive(cmd_line.GetSwitchValuePath(
       switches::kUncompressedArchive));
   if (uncompressed_archive.empty()) {
     base::Version previous_version;
     if (cmd_line.HasSwitch(installer::switches::kPreviousVersion)) {
       previous_version = base::Version(cmd_line.GetSwitchValueASCII(
           installer::switches::kPreviousVersion));
     }
 
-    scoped_ptr<ArchivePatchHelper> archive_helper(
+    std::unique_ptr<ArchivePatchHelper> archive_helper(
         CreateChromeArchiveHelper(setup_exe, cmd_line, installer_state,
                                   unpack_path));
     if (archive_helper) {
       VLOG(1) << "Installing Chrome from compressed archive "
               << archive_helper->compressed_archive().value();
       if (!UncompressAndPatchChromeArchive(original_state,
                                            installer_state,
                                            archive_helper.get(),
                                            archive_type,
                                            &install_status,
@@ skipping 40 matching lines @@
     UMA_HISTOGRAM_MEDIUM_TIMES(
         "Setup.Install.UnpackFullArchiveTime.background", elapsed_time);
   } else {
     UMA_HISTOGRAM_MEDIUM_TIMES(
         "Setup.Install.UnpackFullArchiveTime", elapsed_time);
   }
 
   VLOG(1) << "unpacked to " << unpack_path.value();
   base::FilePath src_path(
       unpack_path.Append(kInstallSourceChromeDir));
-  scoped_ptr<Version>
-      installer_version(GetMaxVersionFromArchiveDir(src_path));
+  std::unique_ptr<Version> installer_version(
+      GetMaxVersionFromArchiveDir(src_path));
   if (!installer_version.get()) {
     LOG(ERROR) << "Did not find any valid version in installer.";
     install_status = INVALID_ARCHIVE;
     installer_state.WriteInstallerResult(install_status,
         IDS_INSTALL_INVALID_ARCHIVE_BASE, NULL);
   } else {
     VLOG(1) << "version to install: " << installer_version->GetString();
     bool proceed_with_installation = true;
 
     uint32_t higher_products = 0;
@@ skipping 340 matching lines @@
     // to pass through, since this is only returned on uninstall which is
     // never invoked directly by Google Update.
     return_code = InstallUtil::GetInstallReturnCode(install_status);
   }
 
   installer::EndPersistentHistogramStorage(installer_state.target_path());
   VLOG(1) << "Installation complete, returning: " << return_code;
 
   return return_code;
 }