Mojo: abstract interface implementation from generated Stub classes

mojo/public/bindings/lib/remote_ptr.h

 // 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.
 
 #ifndef MOJO_PUBLIC_BINDINGS_LIB_REMOTE_PTR_H_
 #define MOJO_PUBLIC_BINDINGS_LIB_REMOTE_PTR_H_
 
 #include <assert.h>
 
 #include "mojo/public/bindings/lib/connector.h"
@@ skipping 36 matching lines @@
 //    private:
 //     mojo::RemotePtr<FooClient> client_;
 //   };
 //
 template <typename S>
 class RemotePtr {
   MOJO_MOVE_ONLY_TYPE_FOR_CPP_03(RemotePtr, RValue);
 
  public:
   RemotePtr() : state_(NULL) {}
-  explicit RemotePtr(ScopedMessagePipeHandle message_pipe)
-      : state_(new State(message_pipe.Pass())) {
+  RemotePtr(ScopedMessagePipeHandle message_pipe, typename S::_Peer* peer)
+      : state_(new State(message_pipe.Pass(), peer)) {
   }
 
   // Move-only constructor and operator=.
   RemotePtr(RValue other) : state_(other.object->release()) {}
   RemotePtr& operator=(RValue other) {
     state_ = other.object->release();
     return *this;
   }
 
   ~RemotePtr() {
@@ skipping 11 matching lines @@
 
   S* operator->() {
     return get();
   }
 
   void reset() {
     delete state_;
     state_ = NULL;
   }
 
-  void reset(ScopedMessagePipeHandle message_pipe) {
+  void reset(ScopedMessagePipeHandle message_pipe, typename S::_Peer* peer) {
     delete state_;
-    state_ = new State(message_pipe.Pass());
+    state_ = new State(message_pipe.Pass(), peer);
   }
 
   bool encountered_error() const {
     assert(state_);
     return state_->connector.encountered_error();
   }
 
-  void SetPeer(typename S::_Peer::_Stub* peer) {
-    assert(state_);
-    state_->connector.SetIncomingReceiver(peer);
-  }
-
  private:
   struct State {
-    State(ScopedMessagePipeHandle message_pipe)
+    State(ScopedMessagePipeHandle message_pipe, typename S::_Peer* peer)
         : connector(message_pipe.Pass()),
-          proxy(&connector) {
+          proxy(&connector),
+          stub(peer) {
+      connector.SetIncomingReceiver(&stub);
     }
     internal::Connector connector;
     typename S::_Proxy proxy;
+    typename S::_Peer::_Stub stub;
   };
 
   State* release() {
     State* state = state_;
     state_ = NULL;
     return state;
   }
 
   State* state_;
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_BINDINGS_LIB_REMOTE_PTR_H_