C++ bindings

mojo/public/bindings/generated/sample_service_proxy.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 "mojo/public/bindings/generated/sample_service_proxy.h"
+
+#include "mojo/public/bindings/generated/sample_service_internal.h"
+
+namespace sample {
+
+ServiceProxy::ServiceProxy(mojo::MessageSender* sender)
+    : sender_(sender) {
+}
+
+void ServiceProxy::Frobinate(const Foo* foo, bool baz, mojo::Handle port) {
+  mojo::MessageBuffer buf;
+
+  // TODO: We should allocate the MessageHeader here to reserve space.
+
+  // We now go about allocating the anonymous Frobinate_Params struct.  It
+  // holds the parameters to the Frobinate message.
+  //
+  // Notice how foo is cloned. This causes a copy of foo to be generated
+  // within the same buffer as the Frobinate_Params struct. That's what we
+  // need in order to generate a continguous blob of message data.
+
+  internal::Service_Frobinate_Params* params =

[viettrungluu, 2013/10/02 01:17:06]

I wonder if in the case that params is small (and has no arrays/pointers), we
should allocate this on the stack.

+      buf.New<internal::Service_Frobinate_Params>();
+  params->set_foo(mojo::internal::Clone(foo, &buf));
+  params->set_baz(baz);
+  params->set_port(port);
+
+  // NOTE: If foo happened to be a graph with cycles, then Clone would not
+  // have returned.
+
+  // Last step before sending the message is to encode pointers and handles
+  // so that messages become hermetic. Pointers become offsets and handles
+  // becomes indices into the handles array.
+
+  std::vector<mojo::Handle> handles;
+  mojo::internal::EncodePointersAndHandles(params, &handles);
+
+  mojo::Message message;
+  message.name = internal::kService_Frobinate_Name;
+  message.data_start = buf.data();

[viettrungluu, 2013/10/02 01:17:06]

... which makes me think that MessageBuffer should reserve some space for things
like this.

It'd be nice if Send() could just take a fully serialized message (including the
name) + a separate handles array, so that it could pass these off immediately to
the low-level C primitive. (Or, we could add the message type as an explicit
field to the low-level SendMessage(). This is okay, since a copy is necessary
between "user" and "kernel" space anyway.)

+  message.data_end = buf.data() + buf.size();
+  message.handles.swap(handles);
+
+  sender_->Send(message);
+}
+
+}  // namespace sample