Added support for parsing out data from simple repetitive values that should not be represented with class/structs.

BUG=chromium-os:30217
TEST=JSONValueConverterTest.*

Review URL: https://chromiumcodereview.appspot.com/10354015

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@135179 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 28 insertions, 0 deletions

diff --git a/base/json/json_value_converter_unittest.cc b/base/json/json_value_converter_unittest.cc
index 120dd48..925fd5c 100644
--- a/base/json/json_value_converter_unittest.cc
+++ b/base/json/json_value_converter_unittest.cc
@@ -28,6 +28,7 @@ struct SimpleMessage {
   bool bstruct;
   SimpleEnum simple_enum;
   ScopedVector<int> ints;
+  ScopedVector<std::string> string_values;
   SimpleMessage() : foo(0), baz(false), bstruct(false) {}
 
   static bool ParseSimpleEnum(const StringPiece& value, SimpleEnum* field) {
@@ -46,6 +47,17 @@ struct SimpleMessage {
     return true;
   }
 
+  static bool GetValueString(const base::Value* value, std::string* result) {
+    const base::DictionaryValue* dict = NULL;
+    if (!value->GetAsDictionary(&dict))
+      return false;
+
+    if (!dict->GetString("val", result))
+      return false;
+
+    return true;
+  }
+
   static void RegisterJSONConverter(
       base::JSONValueConverter<SimpleMessage>* converter) {
     converter->RegisterIntField("foo", &SimpleMessage::foo);
@@ -57,6 +69,10 @@ struct SimpleMessage {
     converter->RegisterCustomValueField<bool>("bstruct",
                                               &SimpleMessage::bstruct,
                                               &HasFieldPresent);
+    converter->RegisterRepeatedCustomValue<std::string>(
+        "string_values",
+        &SimpleMessage::string_values,
+        &GetValueString);
   }
 };
 
@@ -85,6 +101,7 @@ TEST(JSONValueConverterTest, ParseSimpleMessage) {
       "  \"bar\": \"bar\",\n"
       "  \"baz\": true,\n"
       "  \"bstruct\": {},\n"
+      "  \"string_values\": [{\"val\": \"value_1\"}, {\"val\": \"value_2\"}],"
       "  \"simple_enum\": \"foo\","
       "  \"ints\": [1, 2]"
       "}\n";
@@ -99,6 +116,9 @@ TEST(JSONValueConverterTest, ParseSimpleMessage) {
   EXPECT_TRUE(message.baz);
   EXPECT_EQ(SimpleMessage::FOO, message.simple_enum);
   EXPECT_EQ(2, static_cast<int>(message.ints.size()));
+  ASSERT_EQ(2U, message.string_values.size());
+  EXPECT_EQ("value_1", *message.string_values[0]);
+  EXPECT_EQ("value_2", *message.string_values[1]);
   EXPECT_EQ(1, *(message.ints[0]));
   EXPECT_EQ(2, *(message.ints[1]));
 }
@@ -111,12 +131,14 @@ TEST(JSONValueConverterTest, ParseNestedMessage) {
       "    \"foo\": 1,\n"
       "    \"bar\": \"bar\",\n"
       "    \"bstruct\": {},\n"
+      "    \"string_values\": [{\"val\": \"value_1\"}, {\"val\": \"value_2\"}],"
       "    \"baz\": true\n"
       "  },\n"
       "  \"children\": [{\n"
       "    \"foo\": 2,\n"
       "    \"bar\": \"foobar\",\n"
       "    \"bstruct\": \"\",\n"
+      "    \"string_values\": [{\"val\": \"value_1\"}],"
       "    \"baz\": true\n"
       "  },\n"
       "  {\n"
@@ -136,6 +158,9 @@ TEST(JSONValueConverterTest, ParseNestedMessage) {
   EXPECT_EQ("bar", message.child.bar);
   EXPECT_TRUE(message.child.baz);
   EXPECT_TRUE(message.child.bstruct);
+  ASSERT_EQ(2U, message.child.string_values.size());
+  EXPECT_EQ("value_1", *message.child.string_values[0]);
+  EXPECT_EQ("value_2", *message.child.string_values[1]);
 
   EXPECT_EQ(2, static_cast<int>(message.children.size()));
   const SimpleMessage* first_child = message.children[0];
@@ -144,6 +169,8 @@ TEST(JSONValueConverterTest, ParseNestedMessage) {
   EXPECT_EQ("foobar", first_child->bar);
   EXPECT_TRUE(first_child->baz);
   EXPECT_TRUE(first_child->bstruct);
+  ASSERT_EQ(1U, first_child->string_values.size());
+  EXPECT_EQ("value_1", *first_child->string_values[0]);
 
   const SimpleMessage* second_child = message.children[1];
   ASSERT_TRUE(second_child);
@@ -151,6 +178,7 @@ TEST(JSONValueConverterTest, ParseNestedMessage) {
   EXPECT_EQ("barbaz", second_child->bar);
   EXPECT_FALSE(second_child->baz);
   EXPECT_FALSE(second_child->bstruct);
+  EXPECT_EQ(0U, second_child->string_values.size());
 }
 
 TEST(JSONValueConverterTest, ParseFailures) {