Update mojom parser to allow array of arrays.

mojo/public/cpp/bindings/tests/sample_service_unittest.cc

 // Copyright 2014 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 <algorithm>
 #include <ostream>
 #include <string>
 
 #include "mojo/public/cpp/bindings/allocation_scope.h"
 #include "mojo/public/cpp/environment/environment.h"
@@ skipping 57 matching lines @@
     options.flags = MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE;
     options.element_num_bytes = 1;
     options.capacity_num_bytes = 1024;
     mojo::ScopedDataPipeProducerHandle producer;
     mojo::ScopedDataPipeConsumerHandle consumer;
     mojo::CreateDataPipe(&options, &producer, &consumer);
     input_streams[i] = consumer.Pass();
     output_streams[i] = producer.Pass();
   }
 
+  mojo::Array<mojo::Array<bool> >::Builder array_of_array_of_bools(2);
+  for (size_t i = 0; i < 2; ++i) {
+    mojo::Array<bool>::Builder array_of_bools(2);
+    for (size_t j = 0; j < 2; ++j) {
+      array_of_bools[j] = j;
+    }
+    array_of_array_of_bools[i] = array_of_bools.Finish();
+  }
+
   mojo::ScopedMessagePipeHandle pipe0, pipe1;
   mojo::CreateMessagePipe(&pipe0, &pipe1);
 
   Foo::Builder foo;
   foo.set_name(name);
   foo.set_x(1);
   foo.set_y(2);
   foo.set_a(false);
   foo.set_b(true);
   foo.set_c(false);
   foo.set_bar(bar.Finish());
   foo.set_extra_bars(extra_bars.Finish());
   foo.set_data(data.Finish());
   foo.set_source(pipe1.Pass());
   foo.set_input_streams(input_streams.Finish());
   foo.set_output_streams(output_streams.Finish());
+  foo.set_array_of_array_of_bools(array_of_array_of_bools.Finish());
 
   return foo.Finish();
 }
 
 // Check that the given |Foo| is identical to the one made by |MakeFoo()|.
 void CheckFoo(const Foo& foo) {
   const std::string kName("foopy");
   ASSERT_FALSE(foo.name().is_null());
   EXPECT_EQ(kName.size(), foo.name().size());
   for (size_t i = 0; i < std::min(kName.size(), foo.name().size()); i++) {
@@ skipping 27 matching lines @@
   EXPECT_EQ(10u, foo.data().size());
   for (size_t i = 0; i < foo.data().size(); ++i) {
     EXPECT_EQ(static_cast<uint8_t>(foo.data().size() - i), foo.data()[i]) << i;
   }
 
   EXPECT_FALSE(foo.input_streams().is_null());
   EXPECT_EQ(2u, foo.input_streams().size());
 
   EXPECT_FALSE(foo.output_streams().is_null());
   EXPECT_EQ(2u, foo.output_streams().size());
+
+  EXPECT_EQ(2u, foo.array_of_array_of_bools().size());
+  for (size_t i = 0; i < foo.array_of_array_of_bools().size(); ++i) {
+    EXPECT_EQ(2u, foo.array_of_array_of_bools()[i].size());
+    for (size_t j = 0; j < foo.array_of_array_of_bools()[i].size(); ++j) {
+      EXPECT_EQ(bool(j), foo.array_of_array_of_bools()[i][j]);
+    }
+  }
 }
 
 void PrintSpacer(int depth) {
   for (int i = 0; i < depth; ++i)
     std::cout << "   ";
 }
 
 void Print(int depth, const char* name, bool value) {
   PrintSpacer(depth);
   std::cout << name << ": " << (value ? "true" : "false") << std::endl;
@@ skipping 64 matching lines @@
     Print(depth, "y", foo.y());
     Print(depth, "a", foo.a());
     Print(depth, "b", foo.b());
     Print(depth, "c", foo.c());
     Print(depth, "bar", foo.bar());
     Print(depth, "extra_bars", foo.extra_bars());
     Print(depth, "data", foo.data());
     Print(depth, "source", foo.source().get());
     Print(depth, "input_streams", foo.input_streams());
     Print(depth, "output_streams", foo.output_streams());
+    Print(depth, "array_of_array_of_bools", foo.array_of_array_of_bools());
     --depth;
   }
 }
 
 void DumpHex(const uint8_t* bytes, uint32_t num_bytes) {
   for (uint32_t i = 0; i < num_bytes; ++i) {
     std::cout << std::setw(2) << std::setfill('0') << std::hex <<
         uint32_t(bytes[i]);
 
     if (i % 16 == 15) {
@@ skipping 111 matching lines @@
 
   EXPECT_EQ(1u, full.shape_masks().size());
   EXPECT_EQ(1 << imported::SHAPE_RECTANGLE, full.shape_masks()[0]);
 
   EXPECT_EQ(imported::SHAPE_CIRCLE, full.thing().shape());
   EXPECT_EQ(imported::COLOR_BLACK, full.thing().color());
 }
 
 }  // namespace
 }  // namespace sample