Mojo: Add ErrorHandler to RemotePtr

mojo/public/bindings/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_REMOTE_PTR_H_
 #define MOJO_PUBLIC_BINDINGS_REMOTE_PTR_H_
 
 #include <assert.h>
 
 #include "mojo/public/bindings/lib/connector.h"
 #include "mojo/public/system/macros.h"
 
 namespace mojo {
 
 // A RemotePtr is a smart-pointer for managing the connection of a message pipe
 // to an interface proxy.
 //
-// EXAMPLE
+// EXAMPLE:
 //
 // On the client side of a service, RemotePtr might be used like so:
 //
 //   class FooClientImpl : public FooClientStub {
 //    public:
 //     explicit FooClientImpl(const mojo::MessagePipeHandle& message_pipe)
 //         : foo_(message_pipe, this) {
 //       foo_.Ping();
 //     }
 //     virtual void Pong() {
@@ skipping 10 matching lines @@
 //     explicit FooImpl(const mojo::MessagePipeHandle& message_pipe)
 //         : client_(message_pipe, this) {
 //     }
 //     virtual void Ping() {
 //       client_->Pong();
 //     }
 //    private:
 //     mojo::RemotePtr<FooClient> client_;
 //   };
 //
+// NOTE:
+//
+// 1- It is valid to pass NULL for the peer if you are not interested in
+//    receiving incoming messages. Those messages will still be consumed.
+//
+// 2- You may optionally register an ErrorHandler on the RemotePtr to be
+//    notified if the peer has gone away. Alternatively, you may poll the
+//    |encountered_error()| method to check if the peer has gone away.
+//
 template <typename S>
 class RemotePtr {
   struct State;
   MOJO_MOVE_ONLY_TYPE_FOR_CPP_03(RemotePtr, RValue);
 
  public:
   RemotePtr() : state_(NULL) {}
   explicit RemotePtr(ScopedMessagePipeHandle message_pipe,
                      typename S::_Peer* peer = NULL,
+                     ErrorHandler* error_handler = NULL,
                      MojoAsyncWaiter* waiter = GetDefaultAsyncWaiter())
-      : state_(new State(message_pipe.Pass(), peer, waiter)) {
+      : state_(new State(message_pipe.Pass(), peer, error_handler, waiter)) {
   }
 
   // Move-only constructor and operator=.
   RemotePtr(RValue other) : state_(other.object->release()) {}
   RemotePtr& operator=(RValue other) {
     state_ = other.object->release();
     return *this;
   }
 
   ~RemotePtr() {
@@ skipping 13 matching lines @@
     return get();
   }
 
   void reset() {
     delete state_;
     state_ = NULL;
   }
 
   void reset(ScopedMessagePipeHandle message_pipe,
              typename S::_Peer* peer = NULL,
+             ErrorHandler* error_handler = NULL,
              MojoAsyncWaiter* waiter = GetDefaultAsyncWaiter()) {
     delete state_;
-    state_ = new State(message_pipe.Pass(), peer, waiter);
+    state_ = new State(message_pipe.Pass(), peer, error_handler, waiter);
   }
 
   bool encountered_error() const {
     assert(state_);
     return state_->connector.encountered_error();
   }
 
  private:
   struct State {
     State(ScopedMessagePipeHandle message_pipe, typename S::_Peer* peer,
-          MojoAsyncWaiter* waiter)
+          ErrorHandler* error_handler, MojoAsyncWaiter* waiter)
         : connector(message_pipe.Pass(), waiter),
           proxy(&connector),
           stub(peer) {
+      connector.set_error_handler(error_handler);
       if (peer)
-        connector.SetIncomingReceiver(&stub);
+        connector.set_incoming_receiver(&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_REMOTE_PTR_H_