C++ bindings: support using a callback as connection error handler.

mojo/public/cpp/bindings/binding.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_BINDING_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_BINDING_H_
 
 #include "mojo/public/c/environment/async_waiter.h"
+#include "mojo/public/cpp/bindings/callback.h"
 #include "mojo/public/cpp/bindings/error_handler.h"
 #include "mojo/public/cpp/bindings/interface_ptr.h"
 #include "mojo/public/cpp/bindings/interface_ptr_info.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "mojo/public/cpp/bindings/lib/filter_chain.h"
 #include "mojo/public/cpp/bindings/lib/message_header_validator.h"
 #include "mojo/public/cpp/bindings/lib/router.h"
 #include "mojo/public/cpp/environment/logging.h"
 #include "mojo/public/cpp/system/core.h"
 
@@ skipping 31 matching lines @@
 // The caller may specify a |MojoAsyncWaiter| to be used by the connection when
 // waiting for calls to arrive. Normally it is fine to use the default waiter.
 // However, the caller may provide their own implementation if needed. The
 // |Binding| will not take ownership of the waiter, and the waiter must outlive
 // the |Binding|. The provided waiter must be able to signal the implementation
 // which generally means it needs to be able to schedule work on the thread the
 // implementation runs on. If writing library code that has to work on different
 // types of threads callers may need to provide different waiter
 // implementations.
 template <typename Interface>
-class Binding : public ErrorHandler {
+class Binding {
  public:
   // Constructs an incomplete binding that will use the implementation |impl|.
   // The binding may be completed with a subsequent call to the |Bind| method.
   // Does not take ownership of |impl|, which must outlive the binding.
   explicit Binding(Interface* impl) : impl_(impl) { stub_.set_sink(impl_); }
 
   // Constructs a completed binding of message pipe |handle| to implementation
   // |impl|. Does not take ownership of |impl|, which must outlive the binding.
   // See class comment for definition of |waiter|.
   Binding(Interface* impl,
@@ skipping 22 matching lines @@
   // |waiter|.
   Binding(Interface* impl,
           InterfaceRequest<Interface> request,
           const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter())
       : Binding(impl) {
     Bind(request.PassMessagePipe(), waiter);
   }
 
   // Tears down the binding, closing the message pipe and leaving the interface
   // implementation unbound.
-  ~Binding() override {
+  ~Binding() {
     if (internal_router_) {
       Close();
     }
   }
 
   // Completes a binding that was constructed with only an interface
   // implementation. Takes ownership of |handle| and binds it to the previously
   // specified implementation. See class comment for definition of |waiter|.
   void Bind(
       ScopedMessagePipeHandle handle,
       const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter()) {
     MOJO_DCHECK(!internal_router_);
     internal::FilterChain filters;
     filters.Append<internal::MessageHeaderValidator>();
     filters.Append<typename Interface::RequestValidator_>();
 
     internal_router_ =
         new internal::Router(handle.Pass(), filters.Pass(), waiter);
     internal_router_->set_incoming_receiver(&stub_);
-    internal_router_->set_error_handler(this);
+    internal_router_->set_connection_error_handler(
+        [this]() { connection_error_handler_.Run(); });

[qsr, 2015/06/11 09:37:53]

I'm missing something. Why do you need to do this, why not just having
set_connection_error_handler delegate to the router?

[yzshen1, 2015/06/11 16:51:45]

The current code matches the previous behavior:
* set_connection_error_handler() can be called at any time, before or after
|internal_router_| is created;
* the error handler is preserved after Close() and Unbind().

I understand that this is not consistent with what we do with InterfacePtr. But
I think it is beyond the scope of this CL to try to unify their behavior.

What do you think? Thanks!

   }
 
   // Completes a binding that was constructed with only an interface
   // implementation by creating a new message pipe, binding one end of it to the
   // previously specified implementation, and passing the other to |ptr|, which
   // takes ownership of it. The caller is expected to pass |ptr| on to the
   // eventual client of the service. Does not take ownership of |ptr|. See
   // class comment for definition of |waiter|.
   void Bind(
       InterfacePtr<Interface>* ptr,
@@ skipping 40 matching lines @@
     InterfaceRequest<Interface> request =
         MakeRequest<Interface>(internal_router_->PassMessagePipe());
     DestroyRouter();
     // TODO(vtl): The |.Pass()| below is only needed due to an MSVS bug; remove
     // it once that's fixed.
     return request.Pass();
   }
 
   // Sets an error handler that will be called if a connection error occurs on
   // the bound message pipe.
-  void set_error_handler(ErrorHandler* error_handler) {
-    error_handler_ = error_handler;
+  void set_connection_error_handler(const Closure& error_handler) {
+    connection_error_handler_ = error_handler;
   }
 
-  // Implements the |Binding|'s response to a connection error.
-  void OnConnectionError() override {
-    if (error_handler_)
-      error_handler_->OnConnectionError();
+  // Similar to the method above but uses the ErrorHandler interface instead of
+  // a callback.
+  // NOTE: Deprecated. Please use the method above.
+  // TODO(yzshen): Remove this method once all callsites are converted.
+  void set_error_handler(ErrorHandler* error_handler) {
+    set_connection_error_handler(
+        [error_handler]() { error_handler->OnConnectionError(); });
   }
 
   // Returns the interface implementation that was previously specified. Caller
   // does not take ownership.
   Interface* impl() { return impl_; }
 
   // Indicates whether the binding has been completed (i.e., whether a message
   // pipe has been bound to the implementation).
   bool is_bound() const { return !!internal_router_; }
 
   // Returns the value of the handle currently bound to this Binding which can
   // be used to make explicit Wait/WaitMany calls. Requires that the Binding be
   // bound. Ownership of the handle is retained by the Binding, it is not
   // transferred to the caller.
   MessagePipeHandle handle() const {
     MOJO_DCHECK(is_bound());
     return internal_router_->handle();
   }
 
   // Exposed for testing, should not generally be used.
   internal::Router* internal_router() { return internal_router_; }
 
  private:
   void DestroyRouter() {
-    internal_router_->set_error_handler(nullptr);
+    internal_router_->set_connection_error_handler(Closure());
     delete internal_router_;
     internal_router_ = nullptr;
   }
 
   internal::Router* internal_router_ = nullptr;
   typename Interface::Stub_ stub_;
   Interface* impl_;
-  ErrorHandler* error_handler_ = nullptr;
+  Closure connection_error_handler_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(Binding);
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_BINDING_H_