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

extensions/browser/extension_message_filter.cc

 // Copyright 2014 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 "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"
 
 using content::BrowserThread;
 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::UI);
 }
 
-ExtensionMessageFilter::~ExtensionMessageFilter() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+void ExtensionMessageFilter::ShutdownOnUIThread() {
+  extension_system_ = nullptr;
+  process_manager_ = nullptr;
+  shutdown_notifier_.reset();
 }
 
 void ExtensionMessageFilter::OverrideThreadForMessage(
     const IPC::Message& message,
     BrowserThread::ID* thread) {
   switch (message.type()) {
     case ExtensionHostMsg_AddListener::ID:
     case ExtensionHostMsg_RemoveListener::ID:
     case ExtensionHostMsg_AddLazyListener::ID:
     case ExtensionHostMsg_RemoveLazyListener::ID:
     case ExtensionHostMsg_AddFilteredListener::ID:
     case ExtensionHostMsg_RemoveFilteredListener::ID:
     case ExtensionHostMsg_ShouldSuspendAck::ID:
     case ExtensionHostMsg_SuspendAck::ID:
     case ExtensionHostMsg_TransferBlobsAck::ID:
       *thread = BrowserThread::UI;
       break;
     default:
       break;
   }
 }
 
 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) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ExtensionMessageFilter, message)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_AddListener,
                         OnExtensionAddListener)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_RemoveListener,
                         OnExtensionRemoveListener)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_AddLazyListener,
                         OnExtensionAddLazyListener)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_RemoveLazyListener,
                         OnExtensionRemoveLazyListener)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_AddFilteredListener,
                         OnExtensionAddFilteredListener)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_RemoveFilteredListener,
                         OnExtensionRemoveFilteredListener)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_ShouldSuspendAck,
                         OnExtensionShouldSuspendAck)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_SuspendAck,
                         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;
 }
 
 void ExtensionMessageFilter::OnExtensionAddListener(
     const std::string& extension_id,
     const GURL& listener_url,
     const std::string& event_name) {
   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;
 
   if (crx_file::id_util::IdIsValid(extension_id)) {
     router->AddEventListener(event_name, process, extension_id);
   } else if (listener_url.is_valid()) {
     router->AddEventListenerForURL(event_name, process, listener_url);
   } else {
     NOTREACHED() << "Tried to add an event listener without a valid "
                  << "extension ID nor listener URL";
   }
 }
 
 void ExtensionMessageFilter::OnExtensionRemoveListener(
     const std::string& extension_id,
     const GURL& listener_url,
     const std::string& event_name) {
   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;
 
   if (crx_file::id_util::IdIsValid(extension_id)) {
     router->RemoveEventListener(event_name, process, extension_id);
   } else if (listener_url.is_valid()) {
     router->RemoveEventListenerForURL(event_name, process, listener_url);
   } else {
     NOTREACHED() << "Tried to remove an event listener without a valid "
                  << "extension ID nor listener URL";
   }
 }
 
 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);
 }
 
 void ExtensionMessageFilter::OnExtensionAddFilteredListener(
     const std::string& extension_id,
     const std::string& event_name,
     const base::DictionaryValue& filter,
     bool lazy) {
   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);
 }
 
 void ExtensionMessageFilter::OnExtensionRemoveFilteredListener(
     const std::string& extension_id,
     const std::string& event_name,
     const base::DictionaryValue& filter,
     bool lazy) {
   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(
     const std::vector<std::string>& blob_uuids) {
   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);
-}
-
 }  // namespace extensions