Convert //services from scoped_ptr to std::unique_ptr

services/catalog/reader.cc

 // Copyright 2016 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 "services/catalog/reader.h"
 
 #include "base/bind.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/json/json_reader.h"
+#include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/task_runner_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "services/catalog/constants.h"
 #include "services/catalog/entry.h"
 #include "services/catalog/manifest_provider.h"
 #include "services/shell/public/cpp/names.h"
 
 namespace catalog {
 namespace {
@@ skipping 25 matching lines @@
 #if defined OS_WIN
     std::string extension = ".exe";
 #else
     std::string extension;
 #endif
     return package_dir.AppendASCII(shell::GetNamePath(name) + extension);
   }
   return base::FilePath();
 }
 
-scoped_ptr<Entry> ProcessManifest(scoped_ptr<base::Value> manifest_root,
-                                  const base::FilePath& package_dir) {
+std::unique_ptr<Entry> ProcessManifest(
+    std::unique_ptr<base::Value> manifest_root,
+    const base::FilePath& package_dir) {
   // Manifest was malformed or did not exist.
   if (!manifest_root)
     return nullptr;
 
   const base::DictionaryValue* dictionary = nullptr;
   if (!manifest_root->GetAsDictionary(&dictionary))
     return nullptr;
 
-  scoped_ptr<Entry> entry = Entry::Deserialize(*dictionary);
+  std::unique_ptr<Entry> entry = Entry::Deserialize(*dictionary);
   if (!entry)
     return nullptr;
   entry->set_path(GetPackagePath(package_dir, entry->name()));
   return entry;
 }
 
-scoped_ptr<Entry> CreateEntryForManifestAt(
+std::unique_ptr<Entry> CreateEntryForManifestAt(
     const base::FilePath& manifest_path,
     const base::FilePath& package_dir) {
   JSONFileValueDeserializer deserializer(manifest_path);
   int error = 0;
   std::string message;
 
   // TODO(beng): probably want to do more detailed error checking. This should
   //             be done when figuring out if to unblock connection completion.
   return ProcessManifest(deserializer.Deserialize(&error, &message),
                          package_dir);
 }
 
 void ScanDir(
     const base::FilePath& package_dir,
     const Reader::ReadManifestCallback& read_manifest_callback,
     scoped_refptr<base::SingleThreadTaskRunner> original_thread_task_runner,
     const base::Closure& read_complete_closure) {
   base::FileEnumerator enumerator(package_dir, false,
                                   base::FileEnumerator::DIRECTORIES);
   while (1) {
     base::FilePath path = enumerator.Next();
     if (path.empty())
       break;
     base::FilePath manifest_path = path.AppendASCII("manifest.json");
-    scoped_ptr<Entry> entry =
+    std::unique_ptr<Entry> entry =
         CreateEntryForManifestAt(manifest_path, package_dir);
     if (!entry)
       continue;
 
     // Skip over subdirs that contain only manifests, they're artifacts of the
     // build (e.g. for applications that are packaged into others) and are not
     // valid standalone packages.
     base::FilePath package_path = GetPackagePath(package_dir, entry->name());
     if (!base::PathExists(package_path))
       continue;
 
     original_thread_task_runner->PostTask(
         FROM_HERE,
         base::Bind(read_manifest_callback, base::Passed(&entry)));
   }
 
   original_thread_task_runner->PostTask(FROM_HERE, read_complete_closure);
 }
 
-scoped_ptr<Entry> ReadManifest(const base::FilePath& package_dir,
-                               const std::string& mojo_name) {
-  scoped_ptr<Entry> entry = CreateEntryForManifestAt(
+std::unique_ptr<Entry> ReadManifest(const base::FilePath& package_dir,
+                                    const std::string& mojo_name) {
+  std::unique_ptr<Entry> entry = CreateEntryForManifestAt(
       GetManifestPath(package_dir, mojo_name), package_dir);
   if (!entry) {
     entry.reset(new Entry(mojo_name));
     entry->set_path(GetPackagePath(
         package_dir.AppendASCII(kMojoApplicationsDirName), mojo_name));
   }
   return entry;
 }
 
-void AddEntryToCache(EntryCache* cache, scoped_ptr<Entry> entry) {
+void AddEntryToCache(EntryCache* cache, std::unique_ptr<Entry> entry) {
   for (auto child : entry->applications())
-    AddEntryToCache(cache, make_scoped_ptr(child));
+    AddEntryToCache(cache, base::WrapUnique(child));
   (*cache)[entry->name()] = std::move(entry);
 }
 
 void DoNothing(shell::mojom::ResolveResultPtr) {}
 
 }  // namespace
 
 Reader::Reader(base::TaskRunner* file_task_runner,
                ManifestProvider* manifest_provider)
     : file_task_runner_(file_task_runner),
@@ skipping 16 matching lines @@
 }
 
 void Reader::CreateEntryForName(
     const std::string& mojo_name,
     EntryCache* cache,
     const CreateEntryForNameCallback& entry_created_callback) {
   std::string manifest_contents;
   if (manifest_provider_ &&
       manifest_provider_->GetApplicationManifest(mojo_name,
                                                  &manifest_contents)) {
-    scoped_ptr<base::Value> manifest_root =
+    std::unique_ptr<base::Value> manifest_root =
         base::JSONReader::Read(manifest_contents);
     base::PostTaskAndReplyWithResult(
         file_task_runner_, FROM_HERE,
         base::Bind(&ProcessManifest, base::Passed(&manifest_root),
                    system_package_dir_),
         base::Bind(&Reader::OnReadManifest, weak_factory_.GetWeakPtr(),
                    cache, entry_created_callback));
   } else {
     base::PostTaskAndReplyWithResult(
         file_task_runner_, FROM_HERE,
         base::Bind(&ReadManifest, system_package_dir_, mojo_name),
         base::Bind(&Reader::OnReadManifest, weak_factory_.GetWeakPtr(),
                    cache, entry_created_callback));
 
   }
 }
 
 void Reader::OnReadManifest(
     EntryCache* cache,
     const CreateEntryForNameCallback& entry_created_callback,
-    scoped_ptr<Entry> entry) {
+    std::unique_ptr<Entry> entry) {
   shell::mojom::ResolveResultPtr result =
       shell::mojom::ResolveResult::From(*entry);
   AddEntryToCache(cache, std::move(entry));
   entry_created_callback.Run(std::move(result));
 }
 
 }  // namespace catalog