Mojo C++ bindings: remove the single-threaded Router.

mojo/public/cpp/bindings/lib/interface_ptr_state.h

Index: mojo/public/cpp/bindings/lib/interface_ptr_state.h
diff --git a/mojo/public/cpp/bindings/lib/interface_ptr_state.h b/mojo/public/cpp/bindings/lib/interface_ptr_state.h
index 8f73a25d109f99c9488b854268a82908bef622fc..f4c63d2f022291ec748b1602c0a07fc46354c9bb 100644
--- a/mojo/public/cpp/bindings/lib/interface_ptr_state.h
+++ b/mojo/public/cpp/bindings/lib/interface_ptr_state.h
@@ -28,186 +28,14 @@
 #include "mojo/public/cpp/bindings/lib/control_message_handler.h"
 #include "mojo/public/cpp/bindings/lib/control_message_proxy.h"
 #include "mojo/public/cpp/bindings/lib/multiplex_router.h"
-#include "mojo/public/cpp/bindings/lib/router.h"
 #include "mojo/public/cpp/bindings/message_header_validator.h"
 #include "mojo/public/cpp/bindings/scoped_interface_endpoint_handle.h"
 
 namespace mojo {
 namespace internal {
 
-template <typename Interface, bool use_multiplex_router>
-class InterfacePtrState;
-
-// Uses a single-threaded, dedicated router. If |Interface| doesn't have any
-// methods to pass associated interface pointers or requests, there won't be
-// multiple interfaces running on the underlying message pipe. In that case, we
-// can use this specialization to reduce cost.
-template <typename Interface>
-class InterfacePtrState<Interface, false> {
- public:
-  InterfacePtrState() : proxy_(nullptr), router_(nullptr), version_(0u) {}
-
-  ~InterfacePtrState() {
-    // Destruction order matters here. We delete |proxy_| first, even though
-    // |router_| may have a reference to it, so that destructors for any request
-    // callbacks still pending can interact with the InterfacePtr.
-    delete proxy_;
-    delete router_;
-  }
-
-  Interface* instance() {
-    ConfigureProxyIfNecessary();
-
-    // This will be null if the object is not bound.
-    return proxy_;
-  }
-
-  uint32_t version() const { return version_; }
-
-  void QueryVersion(const base::Callback<void(uint32_t)>& callback) {
-    ConfigureProxyIfNecessary();
-
-    // It is safe to capture |this| because the callback won't be run after this
-    // object goes away.
-    router_->control_message_proxy()->QueryVersion(base::Bind(
-        &InterfacePtrState::OnQueryVersion, base::Unretained(this), callback));
-  }
-
-  void RequireVersion(uint32_t version) {
-    ConfigureProxyIfNecessary();
-
-    if (version <= version_)
-      return;
-
-    version_ = version;
-    router_->control_message_proxy()->RequireVersion(version);
-  }
-
-  void FlushForTesting() {
-    ConfigureProxyIfNecessary();
-    router_->control_message_proxy()->FlushForTesting();
-  }
-
-  void SendDisconnectReason(uint32_t custom_reason,
-                            const std::string& description) {
-    ConfigureProxyIfNecessary();
-    router_->control_message_proxy()->SendDisconnectReason(custom_reason,
-                                                           description);
-  }
-
-  void Swap(InterfacePtrState* other) {
-    using std::swap;
-    swap(other->proxy_, proxy_);
-    swap(other->router_, router_);
-    handle_.swap(other->handle_);
-    runner_.swap(other->runner_);
-    swap(other->version_, version_);
-  }
-
-  void Bind(InterfacePtrInfo<Interface> info,
-            scoped_refptr<base::SingleThreadTaskRunner> runner) {
-    DCHECK(!proxy_);
-    DCHECK(!router_);
-    DCHECK(!handle_.is_valid());
-    DCHECK_EQ(0u, version_);
-    DCHECK(info.is_valid());
-
-    handle_ = info.PassHandle();
-    version_ = info.version();
-    runner_ = std::move(runner);
-  }
-
-  bool HasAssociatedInterfaces() const { return false; }
-
-  // After this method is called, the object is in an invalid state and
-  // shouldn't be reused.
-  InterfacePtrInfo<Interface> PassInterface() {
-    return InterfacePtrInfo<Interface>(
-        router_ ? router_->PassMessagePipe() : std::move(handle_), version_);
-  }
-
-  bool is_bound() const { return handle_.is_valid() || router_; }
-
-  bool encountered_error() const {
-    return router_ ? router_->encountered_error() : false;
-  }
-
-  void set_connection_error_handler(const base::Closure& error_handler) {
-    ConfigureProxyIfNecessary();
-
-    DCHECK(router_);
-    router_->set_connection_error_handler(error_handler);
-  }
-
-  void set_connection_error_with_reason_handler(
-      const ConnectionErrorWithReasonCallback& error_handler) {
-    ConfigureProxyIfNecessary();
-
-    DCHECK(router_);
-    router_->set_connection_error_with_reason_handler(error_handler);
-  }
-
-  // Returns true if bound and awaiting a response to a message.
-  bool has_pending_callbacks() const {
-    return router_ && router_->has_pending_responders();
-  }
-
-  AssociatedGroup* associated_group() { return nullptr; }
-
-  void EnableTestingMode() {
-    ConfigureProxyIfNecessary();
-    router_->EnableTestingMode();
-  }
-
- private:
-  using Proxy = typename Interface::Proxy_;
-
-  void ConfigureProxyIfNecessary() {
-    // The proxy has been configured.
-    if (proxy_) {
-      DCHECK(router_);
-      return;
-    }
-    // The object hasn't been bound.
-    if (!handle_.is_valid())
-      return;
-
-    FilterChain filters;
-    filters.Append<MessageHeaderValidator>(Interface::Name_);
-    filters.Append<typename Interface::ResponseValidator_>();
-
-    // The version is only queried from the client so the value passed here
-    // will not be used.
-    router_ = new Router(std::move(handle_), std::move(filters), false,
-                         std::move(runner_), 0u);
-
-    proxy_ = new Proxy(router_);
-  }
-
-  void OnQueryVersion(const base::Callback<void(uint32_t)>& callback,
-                      uint32_t version) {
-    version_ = version;
-    callback.Run(version);
-  }
-
-  Proxy* proxy_;
-  Router* router_;
-
-  // |proxy_| and |router_| are not initialized until read/write with the
-  // message pipe handle is needed. |handle_| is valid between the Bind() call
-  // and the initialization of |proxy_| and |router_|.
-  ScopedMessagePipeHandle handle_;
-  scoped_refptr<base::SingleThreadTaskRunner> runner_;
-
-  uint32_t version_;
-
-  DISALLOW_COPY_AND_ASSIGN(InterfacePtrState);
-};
-
-// Uses a multiplexing router. If |Interface| has methods to pass associated
-// interface pointers or requests, this specialization should be used.
 template <typename Interface>
-class InterfacePtrState<Interface, true> {
+class InterfacePtrState {
  public:
   InterfacePtrState() : version_(0u) {}