Introduce content::ChildMessageFilter.

content/child/child_message_filter.h

Index: content/child/child_message_filter.h
diff --git a/content/child/child_message_filter.h b/content/child/child_message_filter.h
new file mode 100644
index 0000000000000000000000000000000000000000..a554329933fdb9df32d9bde0a870e5a4ec2e57ba
--- /dev/null
+++ b/content/child/child_message_filter.h
@@ -0,0 +1,62 @@
+// 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 CONTENT_CHILD_CHILD_MESSAGE_FILTER_H_
+#define CONTENT_CHILD_CHILD_MESSAGE_FILTER_H_
+
+#include "ipc/ipc_channel_proxy.h"
+
+namespace content {
+
+class ThreadSafeSender;
+
+// Convenience base class for implementing IPC MessageFilters that run on the
+// child thread and can dispatch messages to arbitrary task runners.
+class ChildMessageFilter : public IPC::ChannelProxy::MessageFilter,

[jam, 2013/09/26 18:09:37]

While it's nice to reuse the method definitions from this interface, I think
there are two issues with this:
1) a child class can incorrectly override the single parameter OnMessageReceived
version, which is confusing and would also interfere with the base class'
operation
2) someone could attach this class to a ChannelProxy, instead of the internal
class. i.e. in this cl :)

this is why for BMF I duplicated the methods that are needed from it here, with
the exception of the single parameter OnMessageReceived.

[scherkus (not reviewing), 2013/09/26 19:33:48]

Yeah I realized this after I sent this out ... it's very non-obvious that you
need to implement the MessageFilter::OnMessageReceived() method and because it
has an impl C++ won't enforce subclasses to implement it and you can end up with
a message filter that doesn't filter any messages :)

I'll take a look at the BMF CL

[scherkus (not reviewing), 2013/11/07 21:24:23]

Updated to no longer implement IPC::ChannelProxy::MessageFilter.

+                           public IPC::Sender {
+ public:
+  ChildMessageFilter();
+
+  // IPC::Sender implementation.
+  //
+  // Can be called on any thread.
+  virtual bool Send(IPC::Message* message) OVERRIDE;
+
+  // Override to have OnMessageReceived() run on a TaskRunner of your choosing.
+  // Returns NULL by default, which runs OnMessageReceived() on the child
+  // thread.
+  virtual base::TaskRunner* OverrideTaskRunnerForMessage(
+      const IPC::Message& message);
+
+ protected:
+  friend class base::RefCountedThreadSafe<ChildMessageFilter>;
+  virtual ~ChildMessageFilter();
+
+ private:
+  class Internal : public IPC::ChannelProxy::MessageFilter {

[jam, 2013/09/26 18:09:37]

nit: you could just hide this whole class in the cc file, no reason to expose it
here

[scherkus (not reviewing), 2013/11/07 21:24:23]

Done.

+   public:
+    explicit Internal(ChildMessageFilter* filter);
+
+    // IPC::ChannelProxy::MessageFilter overrides.
+    virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
+
+   protected:
+    friend class base::RefCountedThreadSafe<Internal>;
+    virtual ~Internal();
+
+   private:
+    ChildMessageFilter* filter_;  // Avoid circular references.
+
+    DISALLOW_COPY_AND_ASSIGN(Internal);
+  };
+
+  scoped_refptr<Internal> internal_;
+  scoped_refptr<ThreadSafeSender> thread_safe_sender_;
+
+  DISALLOW_COPY_AND_ASSIGN(ChildMessageFilter);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_CHILD_CHILD_MESSAGE_FILTER_H_