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

mojo/public/bindings/sample/sample_service.idl

 // 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.
 
 // HYPOTHETICAL IDL:
 
 module sample {
 
 struct Bar {
   uint8 alpha @0;
   uint8 beta @1;
   uint8 gamma @2;
 };
 
 [RequiredFields=7]
 struct Foo {
   string name @8;
   int32 x @0;
   int32 y @1;
   bool a @2;
   bool b @3;
   bool c @4;
   Bar bar @5;
   Bar[] extra_bars @7;
   uint8[] data @6;
   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;
+};
+
 }