[extension SW] Support lazy events from extension service workers.

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/macros.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"
@@ skipping 72 matching lines @@
 }
 
 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_AddLazyServiceWorkerListener::ID:
+    case ExtensionHostMsg_RemoveLazyServiceWorkerListener::ID:
     case ExtensionHostMsg_AddFilteredListener::ID:
     case ExtensionHostMsg_RemoveFilteredListener::ID:
     case ExtensionHostMsg_ShouldSuspendAck::ID:
     case ExtensionHostMsg_SuspendAck::ID:
     case ExtensionHostMsg_TransferBlobsAck::ID:
     case ExtensionHostMsg_WakeEventPage::ID:
       *thread = BrowserThread::UI;
       break;
     default:
       break;
@@ skipping 12 matching lines @@
   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_AddLazyServiceWorkerListener,
+                        OnExtensionAddLazyServiceWorkerListener);
+    IPC_MESSAGE_HANDLER(ExtensionHostMsg_RemoveLazyServiceWorkerListener,
+                        OnExtensionRemoveLazyServiceWorkerListener);
     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_WakeEventPage,
                         OnExtensionWakeEventPage)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void ExtensionMessageFilter::OnExtensionAddListener(
     const std::string& extension_id,
-    const GURL& listener_url,
+    const GURL& listener_or_worker_scope_url,
     const std::string& event_name,
     int worker_thread_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!browser_context_)
     return;
 
   RenderProcessHost* process = RenderProcessHost::FromID(render_process_id_);
   if (!process)
     return;
 
   EventRouter* event_router = GetEventRouter();
   if (crx_file::id_util::IdIsValid(extension_id)) {
-    if (worker_thread_id != kNonWorkerThreadId) {
+    const bool is_service_worker_context =
+        worker_thread_id != kNonWorkerThreadId;
+    if (is_service_worker_context) {
+      DCHECK(listener_or_worker_scope_url.is_valid());
       event_router->AddServiceWorkerEventListener(
-          event_name, process, extension_id, worker_thread_id);
+          event_name, process, extension_id, listener_or_worker_scope_url,
+          worker_thread_id);
     } else {
       event_router->AddEventListener(event_name, process, extension_id);
     }
-  } else if (listener_url.is_valid()) {
-    event_router->AddEventListenerForURL(event_name, process, listener_url);
+  } else if (listener_or_worker_scope_url.is_valid()) {
+    event_router->AddEventListenerForURL(event_name, process,
+                                         listener_or_worker_scope_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 GURL& listener_or_worker_scope_url,
     const std::string& event_name,
     int worker_thread_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!browser_context_)
     return;
 
   RenderProcessHost* process = RenderProcessHost::FromID(render_process_id_);
   if (!process)
     return;
 
   if (crx_file::id_util::IdIsValid(extension_id)) {
-    if (worker_thread_id != kNonWorkerThreadId) {
+    const bool is_service_worker_context =
+        worker_thread_id != kNonWorkerThreadId;
+    if (is_service_worker_context) {
+      DCHECK(listener_or_worker_scope_url.is_valid());
       GetEventRouter()->RemoveServiceWorkerEventListener(
-          event_name, process, extension_id, worker_thread_id);
+          event_name, process, extension_id, listener_or_worker_scope_url,
+          worker_thread_id);
     } else {
       GetEventRouter()->RemoveEventListener(event_name, process, extension_id);
     }
-  } else if (listener_url.is_valid()) {
+  } else if (listener_or_worker_scope_url.is_valid()) {
     GetEventRouter()->RemoveEventListenerForURL(event_name, process,
-                                                listener_url);
+                                                listener_or_worker_scope_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) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (!browser_context_)
+    return;
+  GetEventRouter()->AddLazyEventListener(event_name, extension_id);
+}
+
+void ExtensionMessageFilter::OnExtensionAddLazyServiceWorkerListener(
+    const std::string& extension_id,
     const std::string& event_name,
-    int worker_thread_id) {
+    const GURL& service_worker_scope) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!browser_context_)
     return;
 
-  if (worker_thread_id == kNonWorkerThreadId) {
-    GetEventRouter()->AddLazyEventListener(event_name, extension_id);
-  } else {
-    GetEventRouter()->AddLazyServiceWorkerEventListener(
-        event_name, extension_id, worker_thread_id);
-  }
+  GetEventRouter()->AddLazyServiceWorkerEventListener(event_name, extension_id,
+                                                      service_worker_scope);
 }
 
 void ExtensionMessageFilter::OnExtensionRemoveLazyListener(
     const std::string& extension_id,
-    const std::string& event_name,
-    int worker_thread_id) {
+    const std::string& event_name) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!browser_context_)
     return;
 
-  if (worker_thread_id == kNonWorkerThreadId) {
-    GetEventRouter()->RemoveLazyEventListener(event_name, extension_id);
-  } else {
-    GetEventRouter()->RemoveLazyServiceWorkerEventListener(
-        event_name, extension_id, worker_thread_id);
-  }
+  GetEventRouter()->RemoveLazyEventListener(event_name, extension_id);
+}
+
+void ExtensionMessageFilter::OnExtensionRemoveLazyServiceWorkerListener(
+    const std::string& extension_id,
+    const std::string& event_name,
+    const GURL& worker_scope_url) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (!browser_context_)
+    return;
+
+  GetEventRouter()->RemoveLazyServiceWorkerEventListener(
+      event_name, extension_id, worker_scope_url);
 }
 
 void ExtensionMessageFilter::OnExtensionAddFilteredListener(
     const std::string& extension_id,
     const std::string& event_name,
     const base::DictionaryValue& filter,
     bool lazy) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!browser_context_)
     return;
@@ skipping 99 matching lines @@
   // The extension has no background page, so there is nothing to wake.
   SendWakeEventPageResponse(request_id, false);
 }
 
 void ExtensionMessageFilter::SendWakeEventPageResponse(int request_id,
                                                        bool success) {
   Send(new ExtensionMsg_WakeEventPageResponse(request_id, success));
 }
 
 }  // namespace extensions