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

chrome/installer/util/installer_state.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/util/installer_state.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <functional>
+#include <memory>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/file_version_info.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_handle.h"
 #include "chrome/installer/util/delete_tree_work_item.h"
 #include "chrome/installer/util/helper.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/installation_state.h"
 #include "chrome/installer/util/master_preferences.h"
 #include "chrome/installer/util/master_preferences_constants.h"
@@ skipping 228 matching lines @@
   }
   return true;
 }
 
 // Adds |product|, installed in |product_dir| to this object's collection.  If
 // |product_dir| is NULL, the product's default install location is used.
 // Returns NULL if |product| is incompatible with this object.  Otherwise,
 // returns a pointer to the product (ownership is held by this object).
 Product* InstallerState::AddProductInDirectory(
     const base::FilePath* product_dir,
-    scoped_ptr<Product>* product) {
+    std::unique_ptr<Product>* product) {
   DCHECK(product != NULL);
   DCHECK(product->get() != NULL);
   const Product& the_product = *product->get();
 
   if (!CanAddProduct(the_product, product_dir))
     return NULL;
 
   if (package_type_ == UNKNOWN_PACKAGE_TYPE) {
     set_package_type(the_product.HasOption(kOptionMultiInstall) ?
                          MULTI_PACKAGE : SINGLE_PACKAGE);
   }
 
   if (target_path_.empty()) {
     if (product_dir == NULL)
       target_path_ = GetDefaultProductInstallPath(the_product.distribution());
     else
       target_path_ = *product_dir;
   }
 
   if (state_key_.empty())
     state_key_ = the_product.distribution()->GetStateKey();
 
   products_.push_back(product->release());
   return products_[products_.size() - 1];
 }
 
-Product* InstallerState::AddProduct(scoped_ptr<Product>* product) {
+Product* InstallerState::AddProduct(std::unique_ptr<Product>* product) {
   return AddProductInDirectory(NULL, product);
 }
 
 // Adds a product of type |distribution_type| constructed on the basis of
 // |prefs|, setting this object's msi flag if the product is represented in
 // |machine_state| and is msi-installed.  Returns the product that was added,
 // or NULL if |state| is incompatible with this object.  Ownership is not passed
 // to the caller.
 Product* InstallerState::AddProductFromPreferences(
     BrowserDistribution::Type distribution_type,
     const MasterPreferences& prefs,
     const InstallationState& machine_state) {
-  scoped_ptr<Product> product_ptr(
-      new Product(BrowserDistribution::GetSpecificDistribution(
-          distribution_type)));
+  std::unique_ptr<Product> product_ptr(new Product(
+      BrowserDistribution::GetSpecificDistribution(distribution_type)));
   product_ptr->InitializeFromPreferences(prefs);
 
   Product* product = AddProductInDirectory(NULL, &product_ptr);
 
   if (product != NULL && !msi_) {
     const ProductState* product_state = machine_state.GetProductState(
         system_install(), distribution_type);
     if (product_state != NULL)
       msi_ = product_state->is_msi();
   }
 
   return product;
 }
 
 Product* InstallerState::AddProductFromState(
     BrowserDistribution::Type type,
     const ProductState& state) {
-  scoped_ptr<Product> product_ptr(
+  std::unique_ptr<Product> product_ptr(
       new Product(BrowserDistribution::GetSpecificDistribution(type)));
   product_ptr->InitializeFromUninstallCommand(state.uninstall_command());
 
   // Strip off <version>/Installer/setup.exe; see GetInstallerDirectory().
   base::FilePath product_dir =
       state.GetSetupPath().DirName().DirName().DirName();
 
   Product* product = AddProductInDirectory(&product_dir, &product_ptr);
 
   if (product != NULL)
@@ skipping 28 matching lines @@
        scan != end; ++scan) {
      if ((*scan)->is_type(distribution_type))
        return *scan;
   }
   return NULL;
 }
 
 Version* InstallerState::GetCurrentVersion(
     const InstallationState& machine_state) const {
   DCHECK(!products_.empty());
-  scoped_ptr<Version> current_version;
+  std::unique_ptr<Version> current_version;
   // If we're doing a multi-install, the current version may be either an
   // existing multi or an existing single product that is being migrated
   // in place (i.e., Chrome).  In the latter case, there is no existing
   // CHROME_BINARIES installation so we need to search for the product.
   BrowserDistribution::Type prod_type;
   if (package_type_ == MULTI_PACKAGE) {
     prod_type = BrowserDistribution::CHROME_BINARIES;
     if (machine_state.GetProductState(level_ == SYSTEM_LEVEL,
                                       prod_type) == NULL) {
       // Search for a product on which we're operating that is installed in our
@@ skipping 105 matching lines @@
   static_assert(CHROME_FRAME_DLL == 2,
                 "binary file names and values must match");
   static_assert(CHROME_FRAME_HELPER_DLL == 4,
                 "binary file names and values must match");
   static_assert(CHROME_FRAME_HELPER_EXE == 8,
                 "binary file names and values must match");
 
   // Check only for the current version (i.e., the version we are upgrading
   // _from_). Later versions from pending in-use updates need not be checked
   // since the current version is guaranteed to be in use if any such are.
-  scoped_ptr<Version> current_version(GetCurrentVersion(machine_state));
+  std::unique_ptr<Version> current_version(GetCurrentVersion(machine_state));
   if (!current_version)
     return false;
   base::FilePath directory(
       target_path().AppendASCII(current_version->GetString()));
   for (int i = 0; i < NUM_BINARIES; ++i) {
     if (!(file_bits & (1U << i)))
       continue;
     base::FilePath file(directory.Append(kBinaryFileNames[i]));
     if (base::PathExists(file) && IsFileInUse(file))
       return true;
   }
   return false;
 }
 
 void InstallerState::GetExistingExeVersions(
     std::set<std::string>* existing_versions) const {
 
   static const wchar_t* const kChromeFilenames[] = {
     installer::kChromeExe,
     installer::kChromeNewExe,
     installer::kChromeOldExe,
   };
 
   for (size_t i = 0; i < arraysize(kChromeFilenames); ++i) {
     base::FilePath chrome_exe(target_path().Append(kChromeFilenames[i]));
-    scoped_ptr<FileVersionInfo> file_version_info(
+    std::unique_ptr<FileVersionInfo> file_version_info(
         FileVersionInfo::CreateFileVersionInfo(chrome_exe));
     if (file_version_info) {
       base::string16 version_string = file_version_info->file_version();
       if (!version_string.empty() && base::IsStringASCII(version_string))
         existing_versions->insert(base::UTF16ToASCII(version_string));
     }
   }
 }
 
 void InstallerState::RemoveOldVersionDirectories(
     const Version& new_version,
     Version* existing_version,
     const base::FilePath& temp_path) const {
   Version version;
-  scoped_ptr<WorkItem> item;
+  std::unique_ptr<WorkItem> item;
 
   std::set<std::string> existing_version_strings;
   existing_version_strings.insert(new_version.GetString());
   if (existing_version)
     existing_version_strings.insert(existing_version->GetString());
 
   // Make sure not to delete any version dir that is "referenced" by an existing
   // Chrome executable.
   GetExistingExeVersions(&existing_version_strings);
 
@@ skipping 110 matching lines @@
     LOG(ERROR) << "Failed opening key " << state_key_
                << " to update app channels; result: " << result;
   }
 }
 
 void InstallerState::WriteInstallerResult(
     InstallStatus status,
     int string_resource_id,
     const std::wstring* const launch_cmd) const {
   // Use a no-rollback list since this is a best-effort deal.
-  scoped_ptr<WorkItemList> install_list(
+  std::unique_ptr<WorkItemList> install_list(
       WorkItem::CreateNoRollbackWorkItemList());
   const bool system_install = this->system_install();
   // Write the value for all products upon which we're operating.
   Products::const_iterator end = products().end();
   for (Products::const_iterator scan = products().begin(); scan != end;
        ++scan) {
     InstallUtil::AddInstallerResultItems(
         system_install, (*scan)->distribution()->GetStateKey(), status,
         string_resource_id, launch_cmd, install_list.get());
   }
   // And for the binaries if this is a multi-install.
   if (is_multi_install()) {
     InstallUtil::AddInstallerResultItems(
         system_install, multi_package_binaries_distribution()->GetStateKey(),
         status, string_resource_id, launch_cmd, install_list.get());
   }
   if (!install_list->Do())
     LOG(ERROR) << "Failed to record installer error information in registry.";
 }
 
 bool InstallerState::RequiresActiveSetup() const {
   return system_install() && FindProduct(BrowserDistribution::CHROME_BROWSER);
 }
 
 }  // namespace installer