Move AcceptWithResponder() out of the MessageReceiver interface.

BUG=None
TEST=None

Review URL: https://codereview.chromium.org/299833008

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@272831 0039d316-1c4b-4281-b951-d872f2087c98

mojo/public/cpp/bindings/lib/connector.cc

@@ -86,13 +86,6 @@ bool Connector::Accept(Message* message) {
   return true;
 }
 
-bool Connector::AcceptWithResponder(Message* message,
-                                    MessageReceiver* responder) {
-  // TODO(darin): Implement this!
-  assert(false);
-  return false;
-}
-
 // static
 void Connector::CallOnHandleReady(void* closure, MojoResult result) {
   Connector* self = static_cast<Connector*>(closure);

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

@@ -63,8 +63,6 @@ class Connector : public MessageReceiver {
 
   // MessageReceiver implementation:
   virtual bool Accept(Message* message) MOJO_OVERRIDE;
-  virtual bool AcceptWithResponder(Message* message, MessageReceiver* responder)
-      MOJO_OVERRIDE;
 
  private:
   static void CallOnHandleReady(void* closure, MojoResult result);

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

@@ -62,7 +62,7 @@ class InterfacePtrState {
  private:
   class ProxyWithStub : public Interface::Proxy_ {
    public:
-    explicit ProxyWithStub(MessageReceiver* receiver)
+    explicit ProxyWithStub(MessageReceiverWithResponder* receiver)
         : Interface::Proxy_(receiver) {
     }
     typename Interface::Client::Stub_ stub;

mojo/public/cpp/bindings/lib/message_filter.cc

@@ -4,8 +4,6 @@
 
 #include "mojo/public/cpp/bindings/message_filter.h"
 
-#include <assert.h>
-
 namespace mojo {
 
 MessageFilter::MessageFilter(MessageReceiver* sink) : sink_(sink) {
@@ -14,12 +12,6 @@ MessageFilter::MessageFilter(MessageReceiver* sink) : sink_(sink) {
 MessageFilter::~MessageFilter() {
 }
 
-bool MessageFilter::AcceptWithResponder(Message* message,
-                                        MessageReceiver* responder) {
-  assert(false);  // Not reached!
-  return false;
-}
-
 PassThroughFilter::PassThroughFilter(MessageReceiver* sink)
     : MessageFilter(sink) {
 }

mojo/public/cpp/bindings/lib/router.cc

@@ -30,12 +30,6 @@ class ResponderThunk : public MessageReceiver {
     return result;
   }
 
-  virtual bool AcceptWithResponder(Message* message,
-                                   MessageReceiver* responder) MOJO_OVERRIDE {
-    assert(false);  // not reached!
-    return false;
-  }
-
  private:
   SharedData<Router*> router_;
 };
@@ -53,13 +47,6 @@ bool Router::HandleIncomingMessageThunk::Accept(Message* message) {
   return router_->HandleIncomingMessage(message);
 }
 
-bool Router::HandleIncomingMessageThunk::AcceptWithResponder(
-    Message* message,
-    MessageReceiver* responder) {
-  assert(false);  // not reached!
-  return false;
-}
-
 // ----------------------------------------------------------------------------
 
 Router::Router(ScopedMessagePipeHandle message_pipe,

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

@@ -14,7 +14,7 @@
 namespace mojo {
 namespace internal {
 
-class Router : public MessageReceiver {
+class Router : public MessageReceiverWithResponder {
  public:
   Router(ScopedMessagePipeHandle message_pipe,
          FilterChain filters,
@@ -23,7 +23,7 @@ class Router : public MessageReceiver {
 
   // Sets the receiver to handle messages read from the message pipe that do
   // not have the kMessageIsResponse flag set.
-  void set_incoming_receiver(MessageReceiver* receiver) {
+  void set_incoming_receiver(MessageReceiverWithResponder* receiver) {
     incoming_receiver_ = receiver;
   }
 
@@ -67,8 +67,7 @@ class Router : public MessageReceiver {
 
     // MessageReceiver implementation:
     virtual bool Accept(Message* message) MOJO_OVERRIDE;
-    virtual bool AcceptWithResponder(Message* message,
-                                     MessageReceiver* responder) MOJO_OVERRIDE;
+
    private:
     Router* router_;
   };
@@ -79,7 +78,7 @@ class Router : public MessageReceiver {
   FilterChain filters_;
   Connector connector_;
   SharedData<Router*> weak_self_;
-  MessageReceiver* incoming_receiver_;
+  MessageReceiverWithResponder* incoming_receiver_;
   ResponderMap responders_;
   uint64_t next_request_id_;
 };

mojo/public/cpp/bindings/message.h

@@ -84,6 +84,11 @@ class MessageReceiver {
   // was accepted and false otherwise, indicating that the message was invalid
   // or malformed.
   virtual bool Accept(Message* message) MOJO_WARN_UNUSED_RESULT = 0;
+};
+
+class MessageReceiverWithResponder : public MessageReceiver {
+ public:
+  virtual ~MessageReceiverWithResponder() {}
 
   // A variant on Accept that registers a MessageReceiver (known as the
   // responder) to handle the response message generated from the given

mojo/public/cpp/bindings/message_filter.h

@@ -24,11 +24,6 @@ class MessageFilter : public MessageReceiver {
 
  protected:
   MessageReceiver* sink_;
-
- private:
-  // MessageReceiver method that shouldn't be reached.
-  virtual bool AcceptWithResponder(Message* message,
-                                   MessageReceiver* responder) MOJO_OVERRIDE;
 };
 
 // A trivial filter that simply forwards every message it receives to |sink_|.

mojo/public/cpp/bindings/no_interface.h

@@ -34,7 +34,7 @@ class NoInterfaceProxy : public NoInterface {
   explicit NoInterfaceProxy(MessageReceiver* receiver) {}
 };
 
-class NoInterfaceStub : public MessageReceiver {
+class NoInterfaceStub : public MessageReceiverWithResponder {
  public:
   NoInterfaceStub() {}
   void set_sink(NoInterface* sink) {}

mojo/public/cpp/bindings/tests/connector_unittest.cc

@@ -27,11 +27,6 @@ class MessageAccumulator : public MessageReceiver {
     return true;
   }
 
-  virtual bool AcceptWithResponder(Message* message, MessageReceiver* responder)
-      MOJO_OVERRIDE {
-    return false;
-  }
-
   bool IsEmpty() const {
     return queue_.IsEmpty();
   }

mojo/public/cpp/bindings/tests/router_unittest.cc

@@ -42,16 +42,11 @@ class MessageAccumulator : public MessageReceiver {
     return true;
   }
 
-  virtual bool AcceptWithResponder(Message* message, MessageReceiver* responder)
-      MOJO_OVERRIDE {
-    return false;
-  }
-
  private:
   internal::MessageQueue* queue_;
 };
 
-class ResponseGenerator : public MessageReceiver {
+class ResponseGenerator : public MessageReceiverWithResponder {
  public:
   ResponseGenerator() {
   }

mojo/public/cpp/bindings/tests/sample_service_unittest.cc

@@ -287,12 +287,12 @@ class ServiceImpl : public Service {
 
 class ServiceProxyImpl : public ServiceProxy {
  public:
-  explicit ServiceProxyImpl(mojo::MessageReceiver* receiver)
+  explicit ServiceProxyImpl(mojo::MessageReceiverWithResponder* receiver)
       : ServiceProxy(receiver) {
   }
 };
 
-class SimpleMessageReceiver : public mojo::MessageReceiver {
+class SimpleMessageReceiver : public mojo::MessageReceiverWithResponder {
  public:
   virtual bool Accept(mojo::Message* message) MOJO_OVERRIDE {
     // Imagine some IPC happened here.

mojo/public/cpp/bindings/tests/validation_unittest.cc

@@ -96,11 +96,6 @@ class DummyMessageReceiver : public MessageReceiver {
   virtual bool Accept(Message* message) MOJO_OVERRIDE {
     return true;  // Any message is OK.
   }
-  virtual bool AcceptWithResponder(Message* message,
-                                   MessageReceiver* responder) MOJO_OVERRIDE {
-    assert(false);
-    return false;
-  }
 };
 
 std::string DumpMessageHeader(Message* message) {

mojo/public/tools/bindings/generators/cpp_templates/interface_definition.tmpl

@@ -77,12 +77,6 @@ class {{class_name}}_{{method.name}}_ForwardToCallback
       : callback_(callback) {
   }
   virtual bool Accept(mojo::Message* message) MOJO_OVERRIDE;
-  virtual bool AcceptWithResponder(
-      mojo::Message* message,
-      mojo::MessageReceiver* responder) MOJO_OVERRIDE {
-    assert(false);
-    return false;
-  }
  private:
   {{interface_macros.declare_callback(method)}} callback_;
   MOJO_DISALLOW_COPY_AND_ASSIGN({{class_name}}_{{method.name}}_ForwardToCallback);
@@ -102,7 +96,7 @@ bool {{class_name}}_{{method.name}}_ForwardToCallback::Accept(
 {%-   endif %}
 {%- endfor %}
 
-{{proxy_name}}::{{proxy_name}}(mojo::MessageReceiver* receiver)
+{{proxy_name}}::{{proxy_name}}(mojo::MessageReceiverWithResponder* receiver)
     : receiver_(receiver) {
 }
 

mojo/public/tools/bindings/generators/cpp_templates/interface_proxy_declaration.tmpl

 {%- import "interface_macros.tmpl" as interface_macros %}
 class {{interface.name}}Proxy : public {{interface.name}} {
  public:
-  explicit {{interface.name}}Proxy(mojo::MessageReceiver* receiver);
+  explicit {{interface.name}}Proxy(mojo::MessageReceiverWithResponder* receiver);
 
 {%- for method in interface.methods %}
   virtual void {{method.name}}(
@@ -10,5 +10,5 @@ class {{interface.name}}Proxy : public {{interface.name}} {
 {%- endfor %}
 
  private:
-  mojo::MessageReceiver* receiver_;
+  mojo::MessageReceiverWithResponder* receiver_;
 };

mojo/public/tools/bindings/generators/cpp_templates/interface_stub_declaration.tmpl

-class {{interface.name}}Stub : public mojo::MessageReceiver {
+class {{interface.name}}Stub : public mojo::MessageReceiverWithResponder {
  public:
   {{interface.name}}Stub();
   void set_sink({{interface.name}}* sink) { sink_ = sink; }