Added a ResourceMessageFilter for handling resource messages on another thread.

ppapi/host/resource_message_filter.cc

Index: ppapi/host/resource_message_filter.cc
diff --git a/ppapi/host/resource_message_filter.cc b/ppapi/host/resource_message_filter.cc
new file mode 100644
index 0000000000000000000000000000000000000000..0432b81e6cc95ec1ad8a04cbc750ecf6bf739222
--- /dev/null
+++ b/ppapi/host/resource_message_filter.cc
@@ -0,0 +1,82 @@
+// Copyright (c) 2012 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.
+
+#include "ppapi/host/resource_message_filter.h"
+
+#include "base/message_loop.h"
+#include "base/message_loop_proxy.h"
+#include "base/task_runner.h"
+#include "ipc/ipc_message.h"
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/host/host_message_context.h"
+#include "ppapi/host/ppapi_host.h"
+#include "ppapi/host/resource_host.h"
+
+namespace ppapi {
+namespace host {
+
+ResourceMessageFilter::ResourceMessageFilter()
+    : io_message_loop_proxy_(MessageLoop::current()->message_loop_proxy()),
+      resource_host_(NULL) {
+}
+
+ResourceMessageFilter::ResourceMessageFilter(
+    scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy)
+    : io_message_loop_proxy_(io_message_loop_proxy),
+      resource_host_(NULL) {
+}
+
+ResourceMessageFilter::~ResourceMessageFilter() {
+}
+
+void ResourceMessageFilter::OnFilterAdded(ResourceHost* resource_host) {
+  resource_host_ = resource_host;
+}
+
+void ResourceMessageFilter::OnFilterDestroyed() {
+  resource_host_ = NULL;
+}
+
+bool ResourceMessageFilter::HandleMessage(
+    const IPC::Message& msg,

[brettw, 2012/11/16 19:27:54]

Style nit: put after the ( and align the rest to there if it fits (I think most
of the functions in this file fit).

[raymes, 2012/11/16 19:42:50]

Done.

+    HostMessageContext* context) {
+  scoped_refptr<base::TaskRunner> runner = OverrideTaskRunnerForMessage(msg);
+  if (runner) {
+    // TODO(raymes): We need to make a copy so the context can be used on other
+    // threads. It would be better to have a thread-safe ref-counted context.
+    HostMessageContext context_copy = *context;
+    runner->PostTask(FROM_HERE, base::Bind(
+        &ResourceMessageFilter::DispatchMessage, this, msg, context_copy));
+    return true;
+  }
+
+  return false;
+}
+
+void ResourceMessageFilter::SendReply(
+    const ReplyMessageContext& context,
+    const IPC::Message& msg) {
+  if (!io_message_loop_proxy_->BelongsToCurrentThread()) {
+    io_message_loop_proxy_->PostTask(FROM_HERE,
+        base::Bind(&ResourceMessageFilter::SendReply, this, context, msg));
+    return;
+  }
+  if (resource_host_)
+    resource_host_->SendReply(context, msg);
+}
+
+scoped_refptr<base::TaskRunner>
+ResourceMessageFilter::OverrideTaskRunnerForMessage(
+    const IPC::Message& msg) {
+  return NULL;
+}
+
+void ResourceMessageFilter::DispatchMessage(
+    const IPC::Message& msg,
+    HostMessageContext context) {
+  RunMessageHandlerAndReply(msg, &context);
+}
+
+}  // namespace host
+}  // namespace ppapi