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..2a67822685898ccc57bbb6af5f11fca7ac930f1c 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,12 +98,14 @@ 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) {
+  // If we have been shut down already, return.
+  if (!extension_system_)
+    return true;
+
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ExtensionMessageFilter, message)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_AddListener,
@@ -86,12 +126,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 +138,8 @@ void ExtensionMessageFilter::OnExtensionAddListener(
   RenderProcessHost* process = RenderProcessHost::FromID(render_process_id_);
   if (!process)
     return;
-  EventRouter* router = EventRouter::Get(browser_context_);
+
+  EventRouter* router = extension_system_->event_router();
   if (!router)
     return;
 
@@ -125,7 +160,8 @@ void ExtensionMessageFilter::OnExtensionRemoveListener(
   RenderProcessHost* process = RenderProcessHost::FromID(render_process_id_);
   if (!process)
     return;
-  EventRouter* router = EventRouter::Get(browser_context_);
+
+  EventRouter* router = extension_system_->event_router();
   if (!router)
     return;
 
@@ -141,17 +177,19 @@ void ExtensionMessageFilter::OnExtensionRemoveListener(
 
 void ExtensionMessageFilter::OnExtensionAddLazyListener(
     const std::string& extension_id, const std::string& event_name) {
-  EventRouter* router = EventRouter::Get(browser_context_);
+  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_);
+  EventRouter* router = extension_system_->event_router();
   if (!router)
     return;
+
   router->RemoveLazyEventListener(event_name, extension_id);
 }
 
@@ -163,9 +201,11 @@ void ExtensionMessageFilter::OnExtensionAddFilteredListener(
   RenderProcessHost* process = RenderProcessHost::FromID(render_process_id_);
   if (!process)
     return;
-  EventRouter* router = EventRouter::Get(browser_context_);
+
+  EventRouter* router = extension_system_->event_router();
   if (!router)
     return;
+
   router->AddFilteredEventListener(
       event_name, process, extension_id, filter, lazy);
 }
@@ -178,22 +218,23 @@ void ExtensionMessageFilter::OnExtensionRemoveFilteredListener(
   RenderProcessHost* process = RenderProcessHost::FromID(render_process_id_);
   if (!process)
     return;
-  EventRouter* router = EventRouter::Get(browser_context_);
+
+  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);
+  process_manager_->OnShouldSuspendAck(extension_id, sequence_id);
 }
 
 void ExtensionMessageFilter::OnExtensionSuspendAck(
      const std::string& extension_id) {
-  ProcessManager::Get(browser_context_)->OnSuspendAck(extension_id);
+  process_manager_->OnSuspendAck(extension_id);
 }
 
 void ExtensionMessageFilter::OnExtensionTransferBlobsAck(
@@ -201,30 +242,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