Overhaul JSON Schema Compiler to support a number of features required to

chrome/browser/extensions/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 "chrome/browser/extensions/api/declarative/declarative_rule.h"
 
 #include "base/message_loop.h"
 #include "base/test/values_test_util.h"
 #include "base/values.h"
 #include "chrome/common/extensions/matcher/url_matcher_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace extensions {
 
-using json_schema_compiler::any::Any;
 using base::test::ParseJson;
 
+namespace {
+
+template<typename T>
+linked_ptr<T> ScopedToLinkedPtr(scoped_ptr<T> ptr) {
+  return linked_ptr<T>(ptr.release());
+}
+
+}  // namespace
+
 struct RecordingCondition {
   typedef int MatchData;
 
   URLMatcherConditionFactory* factory;
   scoped_ptr<base::Value> value;
 
   void GetURLMatcherConditionSets(
       URLMatcherConditionSet::Vector* condition_sets) const {
     // No condition sets.
   }
@@ skipping 16 matching lines @@
     result->factory = url_matcher_condition_factory;
     result->value.reset(condition.DeepCopy());
     return result.Pass();
   }
 };
 typedef DeclarativeConditionSet<RecordingCondition> RecordingConditionSet;
 
 TEST(DeclarativeConditionTest, ErrorConditionSet) {
   URLMatcher matcher;
   RecordingConditionSet::AnyVector conditions;
-  conditions.push_back(make_linked_ptr(new Any(ParseJson("{\"key\": 1}"))));
-  conditions.push_back(make_linked_ptr(new Any(ParseJson("{\"bad_key\": 2}"))));
+  conditions.push_back(ScopedToLinkedPtr(ParseJson("{\"key\": 1}")));
+  conditions.push_back(ScopedToLinkedPtr(ParseJson("{\"bad_key\": 2}")));
 
   std::string error;
   scoped_ptr<RecordingConditionSet> result =
       RecordingConditionSet::Create(matcher.condition_factory(),
                                     conditions, &error);
   EXPECT_EQ("Found error key", error);
   ASSERT_FALSE(result);
 }
 
 TEST(DeclarativeConditionTest, CreateConditionSet) {
   URLMatcher matcher;
   RecordingConditionSet::AnyVector conditions;
-  conditions.push_back(make_linked_ptr(new Any(ParseJson("{\"key\": 1}"))));
-  conditions.push_back(make_linked_ptr(new Any(ParseJson("[\"val1\", 2]"))));
+  conditions.push_back(ScopedToLinkedPtr(ParseJson("{\"key\": 1}")));
+  conditions.push_back(ScopedToLinkedPtr(ParseJson("[\"val1\", 2]")));
 
   // Test insertion
   std::string error;
   scoped_ptr<RecordingConditionSet> result =
       RecordingConditionSet::Create(matcher.condition_factory(),
                                     conditions, &error);
   EXPECT_EQ("", error);
   ASSERT_TRUE(result);
   EXPECT_EQ(2u, result->conditions().size());
 
@@ skipping 53 matching lines @@
           result->condition_set_id,
           URLMatcherConditionSet::Conditions());
     }
     return result.Pass();
   }
 };
 
 TEST(DeclarativeConditionTest, FulfillConditionSet) {
   typedef DeclarativeConditionSet<FulfillableCondition> FulfillableConditionSet;
   FulfillableConditionSet::AnyVector conditions;
-  conditions.push_back(make_linked_ptr(new Any(ParseJson(
-      "{\"url_id\": 1, \"max\": 3}"))));
-  conditions.push_back(make_linked_ptr(new Any(ParseJson(
-      "{\"url_id\": 2, \"max\": 5}"))));
-  conditions.push_back(make_linked_ptr(new Any(ParseJson(
-      "{\"url_id\": 3, \"max\": 1}"))));
-  conditions.push_back(make_linked_ptr(new Any(ParseJson(
-      "{\"max\": -5}"))));  // No url.
+  conditions.push_back(ScopedToLinkedPtr(ParseJson(
+      "{\"url_id\": 1, \"max\": 3}")));
+  conditions.push_back(ScopedToLinkedPtr(ParseJson(
+      "{\"url_id\": 2, \"max\": 5}")));
+  conditions.push_back(ScopedToLinkedPtr(ParseJson(
+      "{\"url_id\": 3, \"max\": 1}")));
+  conditions.push_back(ScopedToLinkedPtr(ParseJson(
+      "{\"max\": -5}")));  // No url.
 
   // Test insertion
   std::string error;
   scoped_ptr<FulfillableConditionSet> result =
       FulfillableConditionSet::Create(NULL, conditions, &error);
   ASSERT_EQ("", error);
   ASSERT_TRUE(result);
   EXPECT_EQ(4u, result->conditions().size());
 
   std::set<URLMatcherConditionSet::ID> url_matches;
@@ skipping 61 matching lines @@
   }
 
   int GetMinimumPriority() const {
     return min_priority;
   }
 };
 typedef DeclarativeActionSet<SummingAction> SummingActionSet;
 
 TEST(DeclarativeActionTest, ErrorActionSet) {
   SummingActionSet::AnyVector actions;
-  actions.push_back(make_linked_ptr(new Any(ParseJson("{\"value\": 1}"))));
-  actions.push_back(make_linked_ptr(new Any(ParseJson(
-      "{\"error\": \"the error\"}"))));
+  actions.push_back(ScopedToLinkedPtr(ParseJson("{\"value\": 1}")));
+  actions.push_back(ScopedToLinkedPtr(ParseJson("{\"error\": \"the error\"}")));
 
   std::string error;
   bool bad = false;
   scoped_ptr<SummingActionSet> result =
       SummingActionSet::Create(actions, &error, &bad);
   EXPECT_EQ("the error", error);
   EXPECT_FALSE(bad);
   EXPECT_FALSE(result);
 
   actions.clear();
-  actions.push_back(make_linked_ptr(new Any(ParseJson("{\"value\": 1}"))));
-  actions.push_back(make_linked_ptr(new Any(ParseJson("{\"bad\": 3}"))));
+  actions.push_back(ScopedToLinkedPtr(ParseJson("{\"value\": 1}")));
+  actions.push_back(ScopedToLinkedPtr(ParseJson("{\"bad\": 3}")));
   result = SummingActionSet::Create(actions, &error, &bad);
   EXPECT_EQ("", error);
   EXPECT_TRUE(bad);
   EXPECT_FALSE(result);
 }
 
 TEST(DeclarativeActionTest, ApplyActionSet) {
   SummingActionSet::AnyVector actions;
-  actions.push_back(make_linked_ptr(new Any(ParseJson(
+  actions.push_back(ScopedToLinkedPtr(ParseJson(
       "{\"value\": 1,"
-      " \"priority\": 5}"))));
-  actions.push_back(make_linked_ptr(new Any(ParseJson("{\"value\": 2}"))));
+      " \"priority\": 5}")));
+  actions.push_back(ScopedToLinkedPtr(ParseJson("{\"value\": 2}")));
 
   // Test insertion
   std::string error;
   bool bad = false;
   scoped_ptr<SummingActionSet> result =
       SummingActionSet::Create(actions, &error, &bad);
   EXPECT_EQ("", error);
   EXPECT_FALSE(bad);
   ASSERT_TRUE(result);
   EXPECT_EQ(2u, result->actions().size());
@@ skipping 108 matching lines @@
                  "  \"priority\": 200 \n"
                  "}"),
       json_rule.get()));
   rule = Rule::Create(matcher.condition_factory(), kExtensionId, base::Time(),
                       json_rule, &AtLeastOneCondition, &error);
   EXPECT_FALSE(rule);
   EXPECT_EQ("No conditions", error);
 }
 
 }  // namespace extensions