Mojo's C++ and JavaScript bindings should produce identical messages

mojo/public/bindings/sample/sample_test.cc

 // Copyright 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 <stdio.h>
 #include <string.h>
 
 #include <algorithm>
 #include <string>
 
 #include "mojom/sample_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace sample {
 
+// Set this variable to true to print the binary message in hex.
+bool g_dump_message_as_hex = true;
+
 // Make a sample |Foo| in the given |ScratchBuffer|.
 Foo* MakeFoo(mojo::ScratchBuffer* buf) {
   const std::string kName("foopy");
   mojo::String* name = mojo::String::NewCopyOf(buf, kName);
 
   Bar* bar = Bar::New(buf);
   bar->set_alpha(20);
   bar->set_beta(40);
   bar->set_gamma(60);
 
@@ skipping 141 matching lines @@
     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, "files", foo->files());
     --depth;
   }
 }
 
+static void DumpHex(const uint8_t* bytes, uint32_t num_bytes) {
+  for (uint32_t i = 0; i < num_bytes; ++i) {
+    printf("%02x", bytes[i]);
+
+    if (i % 16 == 15) {
+      printf("\n");
+      continue;
+    }
+
+    if (i % 2 == 1)
+      printf(" ");
+    if (i % 8 == 7)
+      printf(" ");
+  }
+}
+
 class ServiceImpl : public ServiceStub {
  public:
   virtual void Frobinate(const Foo* foo, bool baz, mojo::Handle port)
       MOJO_OVERRIDE {
     // Users code goes here to handle the incoming Frobinate message.
 
     // We mainly check that we're given the expected arguments.
     CheckFoo(foo);
     EXPECT_TRUE(baz);
     EXPECT_EQ(static_cast<MojoHandle>(10), port.value);
 
     // Also dump the Foo structure and all of its members.
     // TODO(vtl): Make it optional, so that the test spews less?
     printf("Frobinate:\n");
     int depth = 1;
     Print(depth, "foo", foo);
     Print(depth, "baz", baz);
     Print(depth, "port", port);
   }
 };
 
 class SimpleMessageReceiver : public mojo::MessageReceiver {
  public:
   virtual bool Accept(mojo::Message* message) MOJO_OVERRIDE {
     // Imagine some IPC happened here.
 
+    if (g_dump_message_as_hex) {
+      DumpHex(reinterpret_cast<const uint8_t*>(message->data),
+              message->data->header.num_bytes);
+    }
+
     // In the receiving process, an implementation of ServiceStub is known to
     // the system. It receives the incoming message.
     ServiceImpl impl;
 
     ServiceStub* stub = &impl;
     return stub->Accept(message);
   }
 };
 
 TEST(BindingsSampleTest, Basic) {
@@ skipping 11 matching lines @@
   mojo::ScratchBuffer buf;
   Foo* foo = MakeFoo(&buf);
   CheckFoo(foo);
 
   mojo::Handle port = { 10 };
 
   service->Frobinate(foo, true, port);
 }
 
 }  // namespace sample