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

tools/json_schema_compiler/test/enums_unittest.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 "tools/json_schema_compiler/test/enums.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 using namespace test::api::enums;
 
@@ skipping 15 matching lines @@
 }
 
 TEST(JsonSchemaCompilerEnumsTest, EnumsAsTypes) {
   {
     ListValue args;
     args.Append(Value::CreateStringValue("one"));
 
     scoped_ptr<TakesEnumAsType::Params> params(
         TakesEnumAsType::Params::Create(args));
     ASSERT_TRUE(params.get());
-    EXPECT_EQ(ENUMS_ENUMERATION_ONE, params->enumeration);
+    EXPECT_EQ(ENUMERATION_ONE, params->enumeration);
 
     EXPECT_TRUE(args.Equals(ReturnsEnumAsType::Results::Create(
-        ENUMS_ENUMERATION_ONE).get()));
+        ENUMERATION_ONE).get()));
   }
   {
     HasEnumeration enumeration;
     DictionaryValue value;
     ASSERT_FALSE(HasEnumeration::Populate(value, &enumeration));
 
     value.Set("enumeration", Value::CreateStringValue("one"));
     ASSERT_TRUE(HasEnumeration::Populate(value, &enumeration));
     EXPECT_TRUE(value.Equals(enumeration.ToValue().get()));
 
     value.Set("optional_enumeration", Value::CreateStringValue("two"));
     ASSERT_TRUE(HasEnumeration::Populate(value, &enumeration));
     EXPECT_TRUE(value.Equals(enumeration.ToValue().get()));
   }
 }
 
 TEST(JsonSchemaCompilerEnumsTest, ReturnsEnumCreate) {
   {
     ReturnsEnum::Results::State state = ReturnsEnum::Results::STATE_FOO;
-    scoped_ptr<Value> result = ReturnsEnum::Results::CreateEnumValue(state);
+    scoped_ptr<Value> result(
+        new base::StringValue(ReturnsEnum::Results::ToString(state)));
     scoped_ptr<Value> expected(Value::CreateStringValue("foo"));
     EXPECT_TRUE(result->Equals(expected.get()));
   }
   {
     ReturnsEnum::Results::State state = ReturnsEnum::Results::STATE_FOO;
     scoped_ptr<ListValue> results = ReturnsEnum::Results::Create(state);
     ListValue expected;
     expected.Append(Value::CreateStringValue("foo"));
     EXPECT_TRUE(results->Equals(&expected));
   }
@@ skipping 112 matching lines @@
     params_value.Append(Value::CreateStringValue("invalid"));
     scoped_ptr<TakesMultipleOptionalEnums::Params> params(
         TakesMultipleOptionalEnums::Params::Create(params_value));
     EXPECT_FALSE(params.get());
   }
 }
 
 TEST(JsonSchemaCompilerEnumsTest, OnEnumFiredCreate) {
   {
     OnEnumFired::SomeEnum some_enum = OnEnumFired::SOME_ENUM_FOO;
-    scoped_ptr<Value> result(OnEnumFired::CreateEnumValue(some_enum));
+    scoped_ptr<Value> result(
+        new base::StringValue(OnEnumFired::ToString(some_enum)));
     scoped_ptr<Value> expected(Value::CreateStringValue("foo"));
     EXPECT_TRUE(result->Equals(expected.get()));
   }
   {
     OnEnumFired::SomeEnum some_enum = OnEnumFired::SOME_ENUM_FOO;
     scoped_ptr<ListValue> results(OnEnumFired::Create(some_enum));
     ListValue expected;
     expected.Append(Value::CreateStringValue("foo"));
     EXPECT_TRUE(results->Equals(&expected));
   }
 }
 
 TEST(JsonSchemaCompilerEnumsTest, OnTwoEnumsFiredCreate) {
   {
     scoped_ptr<Value> results(OnTwoEnumsFired::Create(
         OnTwoEnumsFired::FIRST_ENUM_FOO,
         OnTwoEnumsFired::SECOND_ENUM_HAM));
     ListValue expected;
     expected.Append(Value::CreateStringValue("foo"));
     expected.Append(Value::CreateStringValue("ham"));
     EXPECT_TRUE(results->Equals(&expected));
   }
 }