Convert //services from scoped_ptr to std::unique_ptr

services/catalog/instance.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/instance.h"
 
 #include "base/bind.h"
 #include "services/catalog/entry.h"
 #include "services/catalog/manifest_provider.h"
 #include "services/catalog/reader.h"
 #include "services/catalog/store.h"
 #include "services/shell/public/cpp/names.h"
 
 namespace catalog {
 namespace {
 
 void AddEntry(const Entry& entry, mojo::Array<mojom::EntryPtr>* ary) {
   mojom::EntryPtr entry_ptr(mojom::Entry::New());
   entry_ptr->name = entry.name();
   entry_ptr->display_name = entry.display_name();
   ary->push_back(std::move(entry_ptr));
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // Instance, public:
 
-Instance::Instance(scoped_ptr<Store> store, Reader* system_reader)
+Instance::Instance(std::unique_ptr<Store> store, Reader* system_reader)
     : store_(std::move(store)),
       system_reader_(system_reader),
       weak_factory_(this) {}
 Instance::~Instance() {}
 
 void Instance::BindShellResolver(
     shell::mojom::ShellResolverRequest request) {
   if (system_cache_)
     shell_resolver_bindings_.AddBinding(this, std::move(request));
   else
@@ skipping 18 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // Instance, shell::mojom::ShellResolver:
 
 void Instance::ResolveMojoName(const mojo::String& mojo_name,
                                const ResolveMojoNameCallback& callback) {
   DCHECK(system_cache_);
 
   std::string type = shell::GetNameType(mojo_name);
   if (type != shell::kNameType_Mojo && type != shell::kNameType_Exe) {
-    scoped_ptr<Entry> entry(new Entry(mojo_name));
+    std::unique_ptr<Entry> entry(new Entry(mojo_name));
     callback.Run(shell::mojom::ResolveResult::From(*entry));
     return;
   }
 
   // TODO(beng): per-user catalogs.
   auto entry = system_cache_->find(mojo_name);
   if (entry != system_cache_->end()) {
     callback.Run(shell::mojom::ResolveResult::From(*entry->second));
     return;
   }
@@ skipping 63 matching lines @@
   if (!store_)
     return;
   const base::ListValue* catalog = store_->GetStore();
   CHECK(catalog);
   // TODO(sky): make this handle aliases.
   // TODO(beng): implement this properly!
   for (auto it = catalog->begin(); it != catalog->end(); ++it) {
     const base::DictionaryValue* dictionary = nullptr;
     const base::Value* v = *it;
     CHECK(v->GetAsDictionary(&dictionary));
-    scoped_ptr<Entry> entry = Entry::Deserialize(*dictionary);
+    std::unique_ptr<Entry> entry = Entry::Deserialize(*dictionary);
     // TODO(beng): user catalog.
     if (entry)
       (*system_cache_)[entry->name()] = std::move(entry);
   }
 }
 
 void Instance::SerializeCatalog() {
   DCHECK(system_cache_);
-  scoped_ptr<base::ListValue> catalog(new base::ListValue);
+  std::unique_ptr<base::ListValue> catalog(new base::ListValue);
   // TODO(beng): user catalog.
   for (const auto& entry : *system_cache_)
     catalog->Append(entry.second->Serialize());
   if (store_)
     store_->UpdateStore(std::move(catalog));
 }
 
 // static
 void Instance::OnReadManifest(base::WeakPtr<Instance> instance,
                               const std::string& mojo_name,
                               const ResolveMojoNameCallback& callback,
                               shell::mojom::ResolveResultPtr result) {
   callback.Run(std::move(result));
   if (instance)
     instance->SerializeCatalog();
 }
 
 }  // namespace catalog