Convert //extensions/browser/api from scoped_ptr to std::unique_ptr

extensions/browser/api/declarative/rules_registry.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 "extensions/browser/api/declarative/rules_registry.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 20 matching lines @@
 
 namespace extensions {
 
 namespace {
 
 const char kSuccess[] = "";
 const char kDuplicateRuleId[] = "Duplicate rule ID: %s";
 const char kErrorCannotRemoveManifestRules[] =
     "Rules declared in the 'event_rules' manifest field cannot be removed";
 
-scoped_ptr<base::Value> RulesToValue(
+std::unique_ptr<base::Value> RulesToValue(
     const std::vector<linked_ptr<api::events::Rule>>& rules) {
-  scoped_ptr<base::ListValue> list(new base::ListValue());
+  std::unique_ptr<base::ListValue> list(new base::ListValue());
   for (size_t i = 0; i < rules.size(); ++i)
     list->Append(rules[i]->ToValue().release());
   return std::move(list);
 }
 
 std::vector<linked_ptr<api::events::Rule>> RulesFromValue(
     const base::Value* value) {
   std::vector<linked_ptr<api::events::Rule>> rules;
 
   const base::ListValue* list = NULL;
@@ skipping 236 matching lines @@
            used_rule_identifiers_.begin();
        extension != used_rule_identifiers_.end();
        ++extension) {
     // Each extension is counted as 1 just for being there. Otherwise we miss
     // keys with empty values.
     entry_count += 1u + extension->second.size();
   }
   return entry_count;
 }
 
-void RulesRegistry::DeserializeAndAddRules(
-    const std::string& extension_id,
-    scoped_ptr<base::Value> rules) {
+void RulesRegistry::DeserializeAndAddRules(const std::string& extension_id,
+                                           std::unique_ptr<base::Value> rules) {
   DCHECK_CURRENTLY_ON(owner_thread());
 
   std::string error =
       AddRulesNoFill(extension_id, RulesFromValue(rules.get()), &rules_);
   if (!error.empty())
     ReportInternalError(extension_id, error);
 }
 
 void RulesRegistry::ReportInternalError(const std::string& extension_id,
                                         const std::string& error) {
-  scoped_ptr<ExtensionError> error_instance(new InternalError(
+  std::unique_ptr<ExtensionError> error_instance(new InternalError(
       extension_id, base::ASCIIToUTF16(error), logging::LOG_ERROR));
   ExtensionsBrowserClient::Get()->ReportError(browser_context_,
                                               std::move(error_instance));
 }
 
 RulesRegistry::~RulesRegistry() {
 }
 
 void RulesRegistry::MarkReady(base::Time storage_init_time) {
   DCHECK_CURRENTLY_ON(owner_thread());
@@ skipping 104 matching lines @@
   for (i = identifiers.begin(); i != identifiers.end(); ++i)
     used_rule_identifiers_[extension_id].erase(*i);
 }
 
 void RulesRegistry::RemoveAllUsedRuleIdentifiers(
     const std::string& extension_id) {
   used_rule_identifiers_.erase(extension_id);
 }
 
 }  // namespace extensions