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

extensions/browser/api/declarative/declarative_api.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/declarative_api.h"
 
 #include <stddef.h>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 23 matching lines @@
 namespace extensions {
 
 namespace {
 
 const char kDeclarativeEventPrefix[] = "declarative";
 
 void ConvertBinaryDictionaryValuesToBase64(base::DictionaryValue* dict);
 
 // Encodes |binary| as base64 and returns a new StringValue populated with the
 // encoded string.
-scoped_ptr<base::StringValue> ConvertBinaryToBase64(base::BinaryValue* binary) {
+std::unique_ptr<base::StringValue> ConvertBinaryToBase64(
+    base::BinaryValue* binary) {
   std::string binary_data = std::string(binary->GetBuffer(), binary->GetSize());
   std::string data64;
   base::Base64Encode(binary_data, &data64);
-  return scoped_ptr<base::StringValue>(new base::StringValue(data64));
+  return std::unique_ptr<base::StringValue>(new base::StringValue(data64));
 }
 
 // Parses through |args| replacing any BinaryValues with base64 encoded
 // StringValues. Recurses over any nested ListValues, and calls
 // ConvertBinaryDictionaryValuesToBase64 for any nested DictionaryValues.
 void ConvertBinaryListElementsToBase64(base::ListValue* args) {
   size_t index = 0;
   for (base::ListValue::iterator iter = args->begin(); iter != args->end();
        ++iter, ++index) {
     if ((*iter)->IsType(base::Value::TYPE_BINARY)) {
@@ skipping 102 matching lines @@
         thread_task_runner.get(), FROM_HERE,
         base::Bind(&RulesFunction::RunAsyncOnCorrectThread, this),
         base::Bind(&RulesFunction::SendResponse, this));
   }
 
   return true;
 }
 
 bool EventsEventAddRulesFunction::RunAsyncOnCorrectThread() {
   ConvertBinaryListElementsToBase64(args_.get());
-  scoped_ptr<AddRules::Params> params(AddRules::Params::Create(*args_));
+  std::unique_ptr<AddRules::Params> params(AddRules::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   // TODO(devlin): Remove the dependency on linked_ptr here.
   std::vector<linked_ptr<api::events::Rule>> linked_rules;
   for (api::events::Rule& rule : params->rules) {
     linked_rules.push_back(
         make_linked_ptr(new api::events::Rule(std::move(rule))));
   }
   error_ = rules_registry_->AddRules(extension_id(), linked_rules);
 
   if (error_.empty()) {
-    scoped_ptr<base::ListValue> rules_value(new base::ListValue());
+    std::unique_ptr<base::ListValue> rules_value(new base::ListValue());
     for (const auto& rule : linked_rules)
       rules_value->Append(rule->ToValue());
     SetResult(std::move(rules_value));
   }
 
   return error_.empty();
 }
 
 bool EventsEventRemoveRulesFunction::RunAsyncOnCorrectThread() {
-  scoped_ptr<RemoveRules::Params> params(RemoveRules::Params::Create(*args_));
+  std::unique_ptr<RemoveRules::Params> params(
+      RemoveRules::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   if (params->rule_identifiers.get()) {
     error_ = rules_registry_->RemoveRules(extension_id(),
                                           *params->rule_identifiers);
   } else {
     error_ = rules_registry_->RemoveAllRules(extension_id());
   }
 
   return error_.empty();
 }
 
 bool EventsEventGetRulesFunction::RunAsyncOnCorrectThread() {
-  scoped_ptr<GetRules::Params> params(GetRules::Params::Create(*args_));
+  std::unique_ptr<GetRules::Params> params(GetRules::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   std::vector<linked_ptr<Rule> > rules;
   if (params->rule_identifiers.get()) {
     rules_registry_->GetRules(
         extension_id(), *params->rule_identifiers, &rules);
   } else {
     rules_registry_->GetAllRules(extension_id(), &rules);
   }
 
-  scoped_ptr<base::ListValue> rules_value(new base::ListValue());
+  std::unique_ptr<base::ListValue> rules_value(new base::ListValue());
   for (const auto& rule : rules)
     rules_value->Append(rule->ToValue());
   SetResult(std::move(rules_value));
 
   return true;
 }
 
 }  // namespace extensions