Mojo: RemotePtr<S> + bindings changes for Peer attribute.

mojo/public/bindings/sample/sample_service.idl

Index: mojo/public/bindings/sample/sample_service.idl
diff --git a/mojo/public/bindings/sample/sample_service.idl b/mojo/public/bindings/sample/sample_service.idl
index 3358a58f07ec02a6c7898eafcbdb17bf00cb1d3e..a1079a518359b973284489e1e37b78da16201691 100644
--- a/mojo/public/bindings/sample/sample_service.idl
+++ b/mojo/public/bindings/sample/sample_service.idl
@@ -26,8 +26,14 @@ struct Foo {
   handle[] files @9;
 };
 
+[Peer=ServiceClient]

[DaveMoore, 2013/11/11 18:49:05]

It's a bit fragile that you have to specify this pairing in both places instead
of one. It might be better to have an approach that lists pairs
[Peers=ServiceClient,Service]

I don't like that much either though. Maybe instead of putting the attributes on
both interaces we would just list it on one.

Do we expect these to pretty much always be Acks? Maybe the binding should be at
the method level.

interface Service {
  [Ack=ServiceClient::DidFrobinate]
  void Frobinate(Foo foo @0, bool baz @1, handle port @2) @0;
};

interface ServiceClient {
  // No need to declare anything here
  void DidFrobinate(int32 result @0) @0;
};

Going even farther we could drop the second interface declaration and generate
it out of the Ack declaration itself. As a consumer of the interface it might
read really well

[Client=ServiceClient]
interface Service {
  void Frobinate(Foo foo @0, bool baz @1, handle port @2) @0;
  -> void DidFrobinate(int32 result @0) @0;
}

I'm sure there's a better decl format, but I'd rather see us institutionalize
Acks instead of having a large number of our clients cons them up. We could do
something with message ids too.

[Ben Goodger (Google), 2013/11/11 19:10:16]

I'm not sure you can guarantee it'd be only ack-type method calls though. Some
calls to Service might result in N calls to ServiceClient.

A counterpoint to that could be that in that case the N calls should be routed
to some other interface that is passed to Service at an opportune moment. This
would limit the use of *Client interfaces to pure acks and the syntax you
propose would work, just not sure how useful that'd be.

 interface Service {
   void Frobinate(Foo foo @0, bool baz @1, handle port @2) @0;
 };
 
+[Peer=Service]
+interface ServiceClient {
+  void DidFrobinate(int32 result @0) @0;
+};
+
 }