Convert //components/[a-e]* from scoped_ptr to std::unique_ptr

components/component_updater/default_component_installer.cc

 // Copyright 2014 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 "components/component_updater/default_component_installer.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 20 matching lines @@
 // Version "0" corresponds to no installed version. By the server's conventions,
 // we represent it as a dotted quad.
 const char kNullVersion[] = "0.0.0.0";
 
 }  // namespace
 
 ComponentInstallerTraits::~ComponentInstallerTraits() {
 }
 
 DefaultComponentInstaller::DefaultComponentInstaller(
-    scoped_ptr<ComponentInstallerTraits> installer_traits)
+    std::unique_ptr<ComponentInstallerTraits> installer_traits)
     : current_version_(kNullVersion),
       main_task_runner_(base::ThreadTaskRunnerHandle::Get()) {
   installer_traits_ = std::move(installer_traits);
 }
 
 DefaultComponentInstaller::~DefaultComponentInstaller() {
 }
 
 void DefaultComponentInstaller::Register(
     ComponentUpdateService* cus,
@@ skipping 58 matching lines @@
       installer_traits_->GetBaseDirectory().AppendASCII(version.GetString());
   if (base::PathExists(install_path)) {
     if (!base::DeleteFile(install_path, true))
       return false;
   }
   if (!InstallHelper(manifest, unpack_path, install_path)) {
     base::DeleteFile(install_path, true);
     return false;
   }
   current_version_ = version;
-  // TODO(ddorwin): Change the parameter to scoped_ptr<base::DictionaryValue>
+  // TODO(ddorwin): Change the parameter to
+  // std::unique_ptr<base::DictionaryValue>
   // so we can avoid this DeepCopy.

[danakj, 2016/04/26 01:27:53]

fix comment wrapping

[dcheng, 2016/04/26 01:35:02]

Done.

   current_manifest_.reset(manifest.DeepCopy());
-  scoped_ptr<base::DictionaryValue> manifest_copy(
+  std::unique_ptr<base::DictionaryValue> manifest_copy(
       current_manifest_->DeepCopy());
   main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DefaultComponentInstaller::ComponentReady,
                  this, base::Passed(&manifest_copy)));
   return true;
 }
 
 bool DefaultComponentInstaller::GetInstalledFile(
     const std::string& file,
@@ skipping 21 matching lines @@
   base::FilePath base_dir = installer_traits_->GetBaseDirectory();
   if (!base::PathExists(base_dir) && !base::CreateDirectory(base_dir)) {
     PLOG(ERROR) << "Could not create the base directory for "
                 << installer_traits_->GetName() << " ("
                 << base_dir.MaybeAsASCII() << ").";
     return;
   }
 
   base::FilePath latest_path;
   base::Version latest_version(kNullVersion);
-  scoped_ptr<base::DictionaryValue> latest_manifest;
+  std::unique_ptr<base::DictionaryValue> latest_manifest;
 
   std::vector<base::FilePath> older_paths;
   base::FileEnumerator file_enumerator(
       base_dir, false, base::FileEnumerator::DIRECTORIES);
   for (base::FilePath path = file_enumerator.Next();
        !path.value().empty();
        path = file_enumerator.Next()) {
     base::Version version(path.BaseName().MaybeAsASCII());
 
     // Ignore folders that don't have valid version names. These folders are not
     // managed by component installer so do not try to remove them.
     if (!version.IsValid())
       continue;
 
     // |version| not newer than the latest found version (kNullVersion if no
     // version has been found yet) is marked for removal.
     if (version.CompareTo(latest_version) <= 0) {
       older_paths.push_back(path);
       continue;
     }
 
-    scoped_ptr<base::DictionaryValue> manifest =
+    std::unique_ptr<base::DictionaryValue> manifest =
         update_client::ReadManifest(path);
     if (!manifest || !installer_traits_->VerifyInstallation(*manifest, path)) {
       PLOG(ERROR) << "Failed to read manifest or verify installation for "
                   << installer_traits_->GetName() << " (" << path.MaybeAsASCII()
                   << ").";
       older_paths.push_back(path);
       continue;
     }
 
     // New valid |version| folder found!
@@ skipping 74 matching lines @@
       return;
     }
 
     if (!callback.is_null())
       callback.Run();
   }
 
   if (!current_manifest_)
     return;
 
-  scoped_ptr<base::DictionaryValue> manifest_copy(
+  std::unique_ptr<base::DictionaryValue> manifest_copy(
       current_manifest_->DeepCopy());
   ComponentReady(std::move(manifest_copy));
 }
 
 void DefaultComponentInstaller::ComponentReady(
-    scoped_ptr<base::DictionaryValue> manifest) {
+    std::unique_ptr<base::DictionaryValue> manifest) {
   VLOG(1) << "Component ready, version " << current_version_.GetString()
           << " in " << GetInstallDirectory().value();
   installer_traits_->ComponentReady(current_version_, GetInstallDirectory(),
                                     std::move(manifest));
 }
 
 }  // namespace component_updater