Split ExtensionMessageFilter up into a UI thread part and an IO thread part.

extensions/browser/extension_message_filter.cc

Index: extensions/browser/extension_message_filter.cc
diff --git a/extensions/browser/extension_message_filter.cc b/extensions/browser/extension_message_filter.cc
index dfa57b5f49726c4ad1ac613812fd9260682e9f24..5122aafb20190c4f7c98729d3cbf1821f408fd19 100644
--- a/extensions/browser/extension_message_filter.cc
+++ b/extensions/browser/extension_message_filter.cc
@@ -4,18 +4,18 @@
 
 #include "extensions/browser/extension_message_filter.h"
 
+#include "base/memory/singleton.h"
 #include "components/crx_file/id_util.h"
+#include "components/keyed_service/content/browser_context_keyed_service_shutdown_notifier_factory.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
-#include "content/public/browser/render_view_host.h"
-#include "content/public/browser/resource_dispatcher_host.h"
 #include "extensions/browser/blob_holder.h"
 #include "extensions/browser/event_router.h"
-#include "extensions/browser/extension_function_dispatcher.h"
 #include "extensions/browser/extension_system.h"
-#include "extensions/browser/info_map.h"
+#include "extensions/browser/extension_system_provider.h"
+#include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/process_manager.h"
+#include "extensions/browser/process_manager_factory.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_messages.h"
 #include "ipc/ipc_message_macros.h"
@@ -25,18 +25,56 @@ using content::RenderProcessHost;
 
 namespace extensions {
 
+namespace {
+
+class ShutdownNotifierFactory
+    : public BrowserContextKeyedServiceShutdownNotifierFactory {
+ public:
+  static ShutdownNotifierFactory* GetInstance() {
+    return Singleton<ShutdownNotifierFactory>::get();
+  }
+
+ private:
+  friend struct DefaultSingletonTraits<ShutdownNotifierFactory>;
+
+  ShutdownNotifierFactory()
+      : BrowserContextKeyedServiceShutdownNotifierFactory(
+            "ExtensionMessageFilter") {
+    DependsOn(ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
+    DependsOn(ProcessManagerFactory::GetInstance());
+  }
+  ~ShutdownNotifierFactory() override {}
+
+  DISALLOW_COPY_AND_ASSIGN(ShutdownNotifierFactory);
+};
+
+}  // namespace
+
 ExtensionMessageFilter::ExtensionMessageFilter(int render_process_id,
                                                content::BrowserContext* context)
     : BrowserMessageFilter(ExtensionMsgStart),
       render_process_id_(render_process_id),
-      browser_context_(context),
-      extension_info_map_(ExtensionSystem::Get(context)->info_map()),
-      weak_ptr_factory_(this) {
+      extension_system_(ExtensionSystem::Get(context)),
+      process_manager_(ProcessManager::Get(context)) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  shutdown_notifier_ =
+      ShutdownNotifierFactory::GetInstance()->Get(context)->Subscribe(
+          base::Bind(&ExtensionMessageFilter::ShutdownOnUIThread,
+                     base::Unretained(this)));
+}
+
+void ExtensionMessageFilter::EnsureShutdownNotifierFactoryBuilt() {
+  ShutdownNotifierFactory::GetInstance();
 }
 
 ExtensionMessageFilter::~ExtensionMessageFilter() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+}
+
+void ExtensionMessageFilter::ShutdownOnUIThread() {
+  extension_system_ = nullptr;
+  process_manager_ = nullptr;
+  shutdown_notifier_.reset();
 }
 
 void ExtensionMessageFilter::OverrideThreadForMessage(
@@ -60,9 +98,7 @@ void ExtensionMessageFilter::OverrideThreadForMessage(
 }
 
 void ExtensionMessageFilter::OnDestruct() const {
-  // Destroy the filter on the IO thread since that's where its weak pointers
-  // are being used.
-  BrowserThread::DeleteOnIOThread::Destruct(this);
+  BrowserThread::DeleteOnUIThread::Destruct(this);
 }
 
 bool ExtensionMessageFilter::OnMessageReceived(const IPC::Message& message) {
@@ -86,12 +122,6 @@ bool ExtensionMessageFilter::OnMessageReceived(const IPC::Message& message) {
                         OnExtensionSuspendAck)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_TransferBlobsAck,
                         OnExtensionTransferBlobsAck)
-    IPC_MESSAGE_HANDLER(ExtensionHostMsg_GenerateUniqueID,
-                        OnExtensionGenerateUniqueID)
-    IPC_MESSAGE_HANDLER(ExtensionHostMsg_ResumeRequests,
-                        OnExtensionResumeRequests);
-    IPC_MESSAGE_HANDLER(ExtensionHostMsg_RequestForIOThread,
-                        OnExtensionRequestForIOThread)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
@@ -104,7 +134,11 @@ void ExtensionMessageFilter::OnExtensionAddListener(
   RenderProcessHost* process = RenderProcessHost::FromID(render_process_id_);
   if (!process)
     return;
-  EventRouter* router = EventRouter::Get(browser_context_);
+
+  if (!extension_system_)
+    return;
+
+  EventRouter* router = extension_system_->event_router();
   if (!router)
     return;
 
@@ -125,7 +159,11 @@ void ExtensionMessageFilter::OnExtensionRemoveListener(
   RenderProcessHost* process = RenderProcessHost::FromID(render_process_id_);
   if (!process)
     return;
-  EventRouter* router = EventRouter::Get(browser_context_);
+
+  if (!extension_system_)

[not at google - send to devlin, 2015/02/10 18:37:41]

Is it possible to do all of these extension system checks in the
OnMessageReceived function?

[Bernhard Bauer, 2015/02/10 19:02:34]

Done. It does mean that we don't check anymore whether the message is handled at
all, but that should be fine, because other messages shouldn't get forwarded
here.

+    return;
+
+  EventRouter* router = extension_system_->event_router();
   if (!router)
     return;
 
@@ -141,17 +179,25 @@ void ExtensionMessageFilter::OnExtensionRemoveListener(
 
 void ExtensionMessageFilter::OnExtensionAddLazyListener(
     const std::string& extension_id, const std::string& event_name) {
-  EventRouter* router = EventRouter::Get(browser_context_);
+  if (!extension_system_)
+    return;
+
+  EventRouter* router = extension_system_->event_router();
   if (!router)
     return;
+
   router->AddLazyEventListener(event_name, extension_id);
 }
 
 void ExtensionMessageFilter::OnExtensionRemoveLazyListener(
     const std::string& extension_id, const std::string& event_name) {
-  EventRouter* router = EventRouter::Get(browser_context_);
+  if (!extension_system_)
+    return;
+
+  EventRouter* router = extension_system_->event_router();
   if (!router)
     return;
+
   router->RemoveLazyEventListener(event_name, extension_id);
 }
 
@@ -163,9 +209,14 @@ void ExtensionMessageFilter::OnExtensionAddFilteredListener(
   RenderProcessHost* process = RenderProcessHost::FromID(render_process_id_);
   if (!process)
     return;
-  EventRouter* router = EventRouter::Get(browser_context_);
+
+  if (!extension_system_)
+    return;
+
+  EventRouter* router = extension_system_->event_router();
   if (!router)
     return;
+
   router->AddFilteredEventListener(
       event_name, process, extension_id, filter, lazy);
 }
@@ -178,22 +229,32 @@ void ExtensionMessageFilter::OnExtensionRemoveFilteredListener(
   RenderProcessHost* process = RenderProcessHost::FromID(render_process_id_);

[not at google - send to devlin, 2015/02/10 18:37:15]

I wonder if this can actually fail given it's called from an IPC message
handler. Eh, whatever.

[Bernhard Bauer, 2015/02/10 19:02:34]

Process shuts down between the time the message is received on the IO thread and
the time it's handled on the UI thread? There is nothing that would cancel it in
that case.

   if (!process)
     return;
-  EventRouter* router = EventRouter::Get(browser_context_);
+
+  if (!extension_system_)
+    return;
+
+  EventRouter* router = extension_system_->event_router();
   if (!router)
     return;
+
   router->RemoveFilteredEventListener(
       event_name, process, extension_id, filter, lazy);
 }
 
 void ExtensionMessageFilter::OnExtensionShouldSuspendAck(
      const std::string& extension_id, int sequence_id) {
-  ProcessManager::Get(browser_context_)
-      ->OnShouldSuspendAck(extension_id, sequence_id);
+  if (!process_manager_)
+    return;
+
+  process_manager_->OnShouldSuspendAck(extension_id, sequence_id);

[not at google - send to devlin, 2015/02/10 18:37:14]

could you write these like

if (process_manager_)
  process_manager_->OnShouldSuspendAck(...);

though if you do the check ExtensionSystem thing in the message handler it
shouldn't be possible for there to be a ProcessManager but not an
ExtensionSystem.

[Bernhard Bauer, 2015/02/10 19:02:34]

Yeah... I removed the check completely, because if we end up here and 
|process_manager_| is in fact null, we'll crash anyway.

 }
 
 void ExtensionMessageFilter::OnExtensionSuspendAck(
      const std::string& extension_id) {
-  ProcessManager::Get(browser_context_)->OnSuspendAck(extension_id);
+  if (!process_manager_)
+    return;
+
+  process_manager_->OnSuspendAck(extension_id);
 }
 
 void ExtensionMessageFilter::OnExtensionTransferBlobsAck(
@@ -201,30 +262,8 @@ void ExtensionMessageFilter::OnExtensionTransferBlobsAck(
   RenderProcessHost* process = RenderProcessHost::FromID(render_process_id_);
   if (!process)
     return;
-  BlobHolder::FromRenderProcessHost(process)->DropBlobs(blob_uuids);
-}
 
-void ExtensionMessageFilter::OnExtensionGenerateUniqueID(int* unique_id) {
-  static int next_unique_id = 0;
-  *unique_id = ++next_unique_id;
-}
-
-void ExtensionMessageFilter::OnExtensionResumeRequests(int route_id) {
-  content::ResourceDispatcherHost::Get()->ResumeBlockedRequestsForRoute(
-      render_process_id_, route_id);
-}
-
-void ExtensionMessageFilter::OnExtensionRequestForIOThread(
-    int routing_id,
-    const ExtensionHostMsg_Request_Params& params) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  ExtensionFunctionDispatcher::DispatchOnIOThread(
-      extension_info_map_.get(),
-      browser_context_,
-      render_process_id_,
-      weak_ptr_factory_.GetWeakPtr(),
-      routing_id,
-      params);
+  BlobHolder::FromRenderProcessHost(process)->DropBlobs(blob_uuids);
 }
 
 }  // namespace extensions