Mojo: Replace RemotePtr with InterfacePtr and InterfaceImpl

mojo/public/cpp/bindings/interface.h

 // 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.
 
 #ifndef MOJO_PUBLIC_CPP_BINDINGS_INTERFACE_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_INTERFACE_H_
 
 #include <assert.h>
 
 #include "mojo/public/cpp/bindings/message.h"
 #include "mojo/public/cpp/system/core.h"
 
 namespace mojo {
 
 
 // NoInterface is for use in cases when a non-existent or empty interface is
 // needed (e.g., when the Mojom "Peer" attribute is not present).
 
-class NoInterface;
+class NoInterfaceProxy;
+class NoInterfaceStub;
+
+class NoInterface {
+ public:
+  typedef NoInterfaceProxy Proxy_;
+  typedef NoInterfaceStub Stub_;
+  typedef NoInterface Client_;
+  virtual ~NoInterface() {}
+  virtual void SetClient(NoInterface* client) {}
+};
+
+class NoInterfaceProxy : public NoInterface {
+ public:
+  explicit NoInterfaceProxy(MessageReceiver* receiver) {}
+};
 
 class NoInterfaceStub : public MessageReceiver {
  public:
-  NoInterfaceStub(NoInterface* unused) {}
+  NoInterfaceStub() {}
+  void set_sink(NoInterface* sink) {}
   virtual bool Accept(Message* message) MOJO_OVERRIDE;
   virtual bool AcceptWithResponder(Message* message, MessageReceiver* responder)
       MOJO_OVERRIDE;
 };
 
-class NoInterface {
- public:
-  typedef NoInterfaceStub _Stub;
-  typedef NoInterface _Peer;
-};
-
 
 // AnyInterface is for use in cases where any interface would do (e.g., see the
 // Shell::Connect method).
 
 typedef NoInterface AnyInterface;
 
+#if 0
 
 // InterfaceHandle<S>
 
 template <typename S>
 class InterfaceHandle : public MessagePipeHandle {
  public:
   InterfaceHandle() {}
   explicit InterfaceHandle(MojoHandle value) : MessagePipeHandle(value) {}
 };
 
@@ skipping 25 matching lines @@
     MojoResult result MOJO_ALLOW_UNUSED =
         MojoCreateMessagePipe(h0.mutable_value(), h1.mutable_value());
     assert(result == MOJO_RESULT_OK);
     handle_to_self.reset(h0);
     handle_to_peer.reset(h1);
   }
 
   typename Interface<S>::ScopedHandle handle_to_self;
   typename Interface<P>::ScopedHandle handle_to_peer;
 };
+#endif
 
 // TODO(darin): Once we have the ability to use C++11 features, consider
 // defining a template alias for ScopedInterfaceHandle<S>.
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_INTERFACE_H_