Update mojo sdk to rev c02a28868825edfa57ab77947b8cb15e741c5598

third_party/mojo/src/mojo/public/cpp/bindings/interface_ptr.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_PTR_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_INTERFACE_PTR_H_
 
 #include <algorithm>
 
 #include "mojo/public/cpp/bindings/callback.h"
-#include "mojo/public/cpp/bindings/error_handler.h"
 #include "mojo/public/cpp/bindings/interface_ptr_info.h"
 #include "mojo/public/cpp/bindings/lib/interface_ptr_internal.h"
 #include "mojo/public/cpp/environment/environment.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace mojo {
 
 // A pointer to a local proxy of a remote Interface implementation. Uses a
 // message pipe to communicate with the remote implementation, and automatically
 // closes the pipe and deletes the proxy on destruction. The pointer must be
@@ skipping 45 matching lines @@
   // has the same effect as reset(). In this case, the InterfacePtr is not
   // considered as bound.
   void Bind(
       InterfacePtrInfo<Interface> info,
       const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter()) {
     reset();
     if (info.is_valid())
       internal_state_.Bind(info.Pass(), waiter);
   }
 
+  // Returns whether or not this InterfacePtr is bound to a message pipe.
+  bool is_bound() const { return internal_state_.is_bound(); }
+
   // Returns a raw pointer to the local proxy. Caller does not take ownership.
   // Note that the local proxy is thread hostile, as stated above.
   Interface* get() const { return internal_state_.instance(); }
 
   // Functions like a pointer to Interface. Must already be bound.
   Interface* operator->() const { return get(); }
   Interface& operator*() const { return *get(); }
 
   // Returns the version number of the interface that the remote side supports.
   uint32_t version() const { return internal_state_.version(); }
@@ skipping 40 matching lines @@
 
   // Registers a handler to receive error notifications. The handler will be
   // called from the thread that owns this InterfacePtr.
   //
   // This method may only be called after the InterfacePtr has been bound to a
   // message pipe.
   void set_connection_error_handler(const Closure& error_handler) {
     internal_state_.set_connection_error_handler(error_handler);
   }
 
-  // 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) {
-    if (error_handler) {
-      set_connection_error_handler(
-          [error_handler]() { error_handler->OnConnectionError(); });
-    } else {
-      set_connection_error_handler(Closure());
-    }
-  }
-
   // Unbinds the InterfacePtr and returns the information which could be used
   // to setup an InterfacePtr again. This method may be used to move the proxy
   // to a different thread (see class comments for details).
   InterfacePtrInfo<Interface> PassInterface() {
     State state;
     internal_state_.Swap(&state);
 
     return state.PassInterface();
   }
 
@@ skipping 27 matching lines @@
     const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter()) {
   InterfacePtr<Interface> ptr;
   if (info.is_valid())
     ptr.Bind(info.Pass(), waiter);
   return ptr.Pass();
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_INTERFACE_PTR_H_