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

extensions/browser/api/declarative/declarative_rule_unittest.cc

 // Copyright (c) 2013 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_rule.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/test/values_test_util.h"
 #include "base/values.h"
 #include "components/url_matcher/url_matcher_constants.h"
 #include "extensions/common/extension_builder.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::test::ParseJson;
 using url_matcher::URLMatcher;
 using url_matcher::URLMatcherConditionFactory;
 using url_matcher::URLMatcherConditionSet;
 
 namespace extensions {
 
 namespace {
 
-scoped_ptr<base::DictionaryValue> SimpleManifest() {
+std::unique_ptr<base::DictionaryValue> SimpleManifest() {
   return DictionaryBuilder()
       .Set("name", "extension")
       .Set("manifest_version", 2)
       .Set("version", "1.0")
       .Build();
 }
 
 }  // namespace
 
 struct RecordingCondition {
   typedef int MatchData;
 
   URLMatcherConditionFactory* factory;
-  scoped_ptr<base::Value> value;
+  std::unique_ptr<base::Value> value;
 
   void GetURLMatcherConditionSets(
       URLMatcherConditionSet::Vector* condition_sets) const {
     // No condition sets.
   }
 
-  static scoped_ptr<RecordingCondition> Create(
+  static std::unique_ptr<RecordingCondition> Create(
       const Extension* extension,
       URLMatcherConditionFactory* url_matcher_condition_factory,
       const base::Value& condition,
       std::string* error) {
     const base::DictionaryValue* dict = NULL;
     if (condition.GetAsDictionary(&dict) && dict->HasKey("bad_key")) {
       *error = "Found error key";
-      return scoped_ptr<RecordingCondition>();
+      return std::unique_ptr<RecordingCondition>();
     }
 
-    scoped_ptr<RecordingCondition> result(new RecordingCondition());
+    std::unique_ptr<RecordingCondition> result(new RecordingCondition());
     result->factory = url_matcher_condition_factory;
     result->value.reset(condition.DeepCopy());
     return result;
   }
 };
 typedef DeclarativeConditionSet<RecordingCondition> RecordingConditionSet;
 
 TEST(DeclarativeConditionTest, ErrorConditionSet) {
   URLMatcher matcher;
   RecordingConditionSet::Values conditions;
   conditions.push_back(ParseJson("{\"key\": 1}"));
   conditions.push_back(ParseJson("{\"bad_key\": 2}"));
 
   std::string error;
-  scoped_ptr<RecordingConditionSet> result = RecordingConditionSet::Create(
+  std::unique_ptr<RecordingConditionSet> result = RecordingConditionSet::Create(
       NULL, matcher.condition_factory(), conditions, &error);
   EXPECT_EQ("Found error key", error);
   ASSERT_FALSE(result);
 }
 
 TEST(DeclarativeConditionTest, CreateConditionSet) {
   URLMatcher matcher;
   RecordingConditionSet::Values conditions;
   conditions.push_back(ParseJson("{\"key\": 1}"));
   conditions.push_back(ParseJson("[\"val1\", 2]"));
 
   // Test insertion
   std::string error;
-  scoped_ptr<RecordingConditionSet> result = RecordingConditionSet::Create(
+  std::unique_ptr<RecordingConditionSet> result = RecordingConditionSet::Create(
       NULL, matcher.condition_factory(), conditions, &error);
   EXPECT_EQ("", error);
   ASSERT_TRUE(result);
   EXPECT_EQ(2u, result->conditions().size());
 
   EXPECT_EQ(matcher.condition_factory(), result->conditions()[0]->factory);
   EXPECT_TRUE(ParseJson("{\"key\": 1}")->Equals(
       result->conditions()[0]->value.get()));
 }
 
@@ skipping 21 matching lines @@
       condition_sets->push_back(condition_set);
   }
 
   bool IsFulfilled(const MatchData& match_data) const {
     if (condition_set_id != -1 &&
         !ContainsKey(match_data.url_matches, condition_set_id))
       return false;
     return match_data.value <= max_value;
   }
 
-  static scoped_ptr<FulfillableCondition> Create(
+  static std::unique_ptr<FulfillableCondition> Create(
       const Extension* extension,
       URLMatcherConditionFactory* url_matcher_condition_factory,
       const base::Value& condition,
       std::string* error) {
-    scoped_ptr<FulfillableCondition> result(new FulfillableCondition());
+    std::unique_ptr<FulfillableCondition> result(new FulfillableCondition());
     const base::DictionaryValue* dict;
     if (!condition.GetAsDictionary(&dict)) {
       *error = "Expected dict";
       return result;
     }
     if (!dict->GetInteger("url_id", &result->condition_set_id))
       result->condition_set_id = -1;
     if (!dict->GetInteger("max", &result->max_value))
       *error = "Expected integer at ['max']";
     if (result->condition_set_id != -1) {
       result->condition_set = new URLMatcherConditionSet(
           result->condition_set_id,
           URLMatcherConditionSet::Conditions());
     }
     return result;
   }
 };
 
 TEST(DeclarativeConditionTest, FulfillConditionSet) {
   typedef DeclarativeConditionSet<FulfillableCondition> FulfillableConditionSet;
   FulfillableConditionSet::Values conditions;
   conditions.push_back(ParseJson("{\"url_id\": 1, \"max\": 3}"));
   conditions.push_back(ParseJson("{\"url_id\": 2, \"max\": 5}"));
   conditions.push_back(ParseJson("{\"url_id\": 3, \"max\": 1}"));
   conditions.push_back(ParseJson("{\"max\": -5}"));  // No url.
 
   // Test insertion
   std::string error;
-  scoped_ptr<FulfillableConditionSet> result =
+  std::unique_ptr<FulfillableConditionSet> result =
       FulfillableConditionSet::Create(NULL, NULL, conditions, &error);
   ASSERT_EQ("", error);
   ASSERT_TRUE(result);
   EXPECT_EQ(4u, result->conditions().size());
 
   std::set<URLMatcherConditionSet::ID> url_matches;
   FulfillableCondition::MatchData match_data = { 0, url_matches };
   EXPECT_FALSE(result->IsFulfilled(1, match_data))
       << "Testing an ID that's not in url_matches forwards to the Condition, "
       << "which doesn't match.";
@@ skipping 80 matching lines @@
 };
 typedef DeclarativeActionSet<SummingAction> SummingActionSet;
 
 TEST(DeclarativeActionTest, ErrorActionSet) {
   SummingActionSet::Values actions;
   actions.push_back(ParseJson("{\"value\": 1}"));
   actions.push_back(ParseJson("{\"error\": \"the error\"}"));
 
   std::string error;
   bool bad = false;
-  scoped_ptr<SummingActionSet> result =
+  std::unique_ptr<SummingActionSet> result =
       SummingActionSet::Create(NULL, NULL, actions, &error, &bad);
   EXPECT_EQ("the error", error);
   EXPECT_FALSE(bad);
   EXPECT_FALSE(result);
 
   actions.clear();
   actions.push_back(ParseJson("{\"value\": 1}"));
   actions.push_back(ParseJson("{\"bad\": 3}"));
   result = SummingActionSet::Create(NULL, NULL, actions, &error, &bad);
   EXPECT_EQ("", error);
   EXPECT_TRUE(bad);
   EXPECT_FALSE(result);
 }
 
 TEST(DeclarativeActionTest, ApplyActionSet) {
   SummingActionSet::Values actions;
   actions.push_back(
       ParseJson("{\"value\": 1,"
                 " \"priority\": 5}"));
   actions.push_back(ParseJson("{\"value\": 2}"));
 
   // Test insertion
   std::string error;
   bool bad = false;
-  scoped_ptr<SummingActionSet> result =
+  std::unique_ptr<SummingActionSet> result =
       SummingActionSet::Create(NULL, NULL, actions, &error, &bad);
   EXPECT_EQ("", error);
   EXPECT_FALSE(bad);
   ASSERT_TRUE(result);
   EXPECT_EQ(2u, result->actions().size());
 
   int sum = 0;
   result->Apply("ext_id", base::Time(), &sum);
   EXPECT_EQ(3, sum);
   EXPECT_EQ(5, result->GetMinimumPriority());
@@ skipping 21 matching lines @@
   const char kExtensionId[] = "ext1";
   scoped_refptr<Extension> extension = ExtensionBuilder()
                                            .SetManifest(SimpleManifest())
                                            .SetID(kExtensionId)
                                            .Build();
 
   base::Time install_time = base::Time::Now();
 
   URLMatcher matcher;
   std::string error;
-  scoped_ptr<Rule> rule(Rule::Create(matcher.condition_factory(),
-                                     NULL,
-                                     extension.get(),
-                                     install_time,
-                                     json_rule,
-                                     Rule::ConsistencyChecker(),
-                                     &error));
+  std::unique_ptr<Rule> rule(Rule::Create(
+      matcher.condition_factory(), NULL, extension.get(), install_time,
+      json_rule, Rule::ConsistencyChecker(), &error));
   EXPECT_EQ("", error);
   ASSERT_TRUE(rule.get());
 
   EXPECT_EQ(kExtensionId, rule->id().first);
   EXPECT_EQ("rule1", rule->id().second);
 
   EXPECT_EQ(200, rule->priority());
 
   const Rule::ConditionSet& condition_set = rule->conditions();
   const Rule::ConditionSet::Conditions& conditions =
@@ skipping 42 matching lines @@
                  "    {\"url_id\": 2, \"max\": 5}, \n"
                  "  ], \n"
                  "  \"actions\": [ \n"
                  "    { \n"
                  "      \"value\": 2 \n"
                  "    } \n"
                  "  ], \n"
                  "  \"priority\": 200 \n"
                  "}"),
       json_rule.get()));
-  scoped_ptr<Rule> rule(Rule::Create(matcher.condition_factory(),
-                                     NULL,
-                                     extension.get(),
-                                     base::Time(),
-                                     json_rule,
-                                     base::Bind(AtLeastOneCondition),
-                                     &error));
+  std::unique_ptr<Rule> rule(Rule::Create(
+      matcher.condition_factory(), NULL, extension.get(), base::Time(),
+      json_rule, base::Bind(AtLeastOneCondition), &error));
   EXPECT_TRUE(rule);
   EXPECT_EQ("", error);
 
   ASSERT_TRUE(Rule::JsonRule::Populate(
       *ParseJson("{ \n"
                  "  \"id\": \"rule1\", \n"
                  "  \"conditions\": [ \n"
                  "  ], \n"
                  "  \"actions\": [ \n"
                  "    { \n"
                  "      \"value\": 2 \n"
                  "    } \n"
                  "  ], \n"
                  "  \"priority\": 200 \n"
                  "}"),
       json_rule.get()));
   rule = Rule::Create(matcher.condition_factory(),
                       NULL,
                       extension.get(),
                       base::Time(),
                       json_rule,
                       base::Bind(AtLeastOneCondition),
                       &error);
   EXPECT_FALSE(rule);
   EXPECT_EQ("No conditions", error);
 }
 
 }  // namespace extensions