Convert //services from scoped_ptr to std::unique_ptr

services/catalog/entry.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/entry.h"
 
 #include "base/values.h"
 #include "mojo/util/filename_util.h"
 #include "services/catalog/store.h"
 #include "services/shell/public/cpp/names.h"
@@ skipping 88 matching lines @@
 }
 
 }  // namespace
 
 Entry::Entry() {}
 Entry::Entry(const std::string& name)
     : name_(name), qualifier_(shell::GetNamePath(name)), display_name_(name) {}
 Entry::Entry(const Entry& other) = default;
 Entry::~Entry() {}
 
-scoped_ptr<base::DictionaryValue> Entry::Serialize() const {
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
+std::unique_ptr<base::DictionaryValue> Entry::Serialize() const {
+  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue);
   value->SetInteger(Store::kManifestVersionKey, 1);
   value->SetString(Store::kNameKey, name_);
   value->SetString(Store::kDisplayNameKey, display_name_);
   value->SetString(Store::kQualifierKey, qualifier_);
-  scoped_ptr<base::DictionaryValue> spec(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> spec(new base::DictionaryValue);
 
-  scoped_ptr<base::DictionaryValue> provided(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> provided(new base::DictionaryValue);
   for (const auto& i : capabilities_.provided) {
-    scoped_ptr<base::ListValue> interfaces(new base::ListValue);
+    std::unique_ptr<base::ListValue> interfaces(new base::ListValue);
     for (const auto& interface_name : i.second)
       interfaces->AppendString(interface_name);
     provided->Set(i.first, std::move(interfaces));
   }
   spec->Set(Store::kCapabilities_ProvidedKey, std::move(provided));
 
-  scoped_ptr<base::DictionaryValue> required(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> required(new base::DictionaryValue);
   for (const auto& i : capabilities_.required) {
-    scoped_ptr<base::DictionaryValue> request(new base::DictionaryValue);
-    scoped_ptr<base::ListValue> classes(new base::ListValue);
+    std::unique_ptr<base::DictionaryValue> request(new base::DictionaryValue);
+    std::unique_ptr<base::ListValue> classes(new base::ListValue);
     for (const auto& class_name : i.second.classes)
       classes->AppendString(class_name);
     request->Set(Store::kCapabilities_ClassesKey, std::move(classes));
-    scoped_ptr<base::ListValue> interfaces(new base::ListValue);
+    std::unique_ptr<base::ListValue> interfaces(new base::ListValue);
     for (const auto& interface_name : i.second.interfaces)
       interfaces->AppendString(interface_name);
     request->Set(Store::kCapabilities_InterfacesKey, std::move(interfaces));
     required->Set(i.first, std::move(request));
   }
   spec->Set(Store::kCapabilities_RequiredKey, std::move(required));
 
   value->Set(Store::kCapabilitiesKey, std::move(spec));
   return value;
 }
 
 // static
-scoped_ptr<Entry> Entry::Deserialize(const base::DictionaryValue& value) {
-  scoped_ptr<Entry> entry(new Entry);
+std::unique_ptr<Entry> Entry::Deserialize(const base::DictionaryValue& value) {
+  std::unique_ptr<Entry> entry(new Entry);
   int manifest_version = 0;
   if (value.HasKey(Store::kManifestVersionKey))
     CHECK(value.GetInteger(Store::kManifestVersionKey, &manifest_version));
   std::string name_string;
   if (!value.GetString(Store::kNameKey, &name_string)) {
     LOG(ERROR) << "Entry::Deserialize: dictionary has no name key";
     return nullptr;
   }
   if (!shell::IsValidName(name_string)) {
     LOG(WARNING) << "Entry::Deserialize: " << name_string << " is not a valid "
@@ skipping 23 matching lines @@
     entry->set_capabilities(BuildCapabilitiesV0(*capabilities));
   else
     entry->set_capabilities(BuildCapabilitiesV1(*capabilities));
 
   if (value.HasKey(Store::kApplicationsKey)) {
     const base::ListValue* applications = nullptr;
     value.GetList(Store::kApplicationsKey, &applications);
     for (size_t i = 0; i < applications->GetSize(); ++i) {
       const base::DictionaryValue* application = nullptr;
       applications->GetDictionary(i, &application);
-      scoped_ptr<Entry> child = Entry::Deserialize(*application);
+      std::unique_ptr<Entry> child = Entry::Deserialize(*application);
       if (child) {
         child->set_package(entry.get());
         // Caller must assume ownership of these items.
         entry->applications_.insert(child.release());
       }
     }
   }
 
   return entry;
 }
@@ skipping 37 matching lines @@
 catalog::mojom::EntryPtr
     TypeConverter<catalog::mojom::EntryPtr, catalog::Entry>::Convert(
         const catalog::Entry& input) {
   catalog::mojom::EntryPtr result(catalog::mojom::Entry::New());
   result->name = input.name();
   result->display_name = input.display_name();
   return result;
 }
 
 }  // namespace mojo