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

extensions/renderer/dispatcher.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/renderer/dispatcher.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 219 matching lines @@
     } else {
       DCHECK_EQ(binding::EventListenersChanged::NO_LISTENERS, changed);
       render_thread->Send(new ExtensionHostMsg_RemoveFilteredListener(
           extension_id, event_name, *filter, lazy));
     }
   } else {
     if (changed == binding::EventListenersChanged::HAS_LISTENERS) {
       render_thread->Send(new ExtensionHostMsg_AddListener(
           extension_id, context->url(), event_name, worker_thread_id));
       if (lazy) {
-        render_thread->Send(new ExtensionHostMsg_AddLazyListener(
-            extension_id, event_name, worker_thread_id));
+        render_thread->Send(
+            new ExtensionHostMsg_AddLazyListener(extension_id, event_name));
       }
     } else {
       DCHECK_EQ(binding::EventListenersChanged::NO_LISTENERS, changed);
       render_thread->Send(new ExtensionHostMsg_RemoveListener(
           extension_id, context->url(), event_name, worker_thread_id));
       if (lazy && was_manual) {
-        render_thread->Send(new ExtensionHostMsg_RemoveLazyListener(
-            extension_id, event_name, worker_thread_id));
+        render_thread->Send(
+            new ExtensionHostMsg_RemoveLazyListener(extension_id, event_name));
       }
     }
   }
 }
 
 base::LazyInstance<WorkerScriptContextSet>::DestructorAtExit
     g_worker_script_context_set = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
@@ skipping 167 matching lines @@
           "Extensions.DidCreateScriptContext_LockScreenExtension", elapsed);
       break;
   }
 
   VLOG(1) << "Num tracked contexts: " << script_context_set_->size();
 }
 
 void Dispatcher::DidInitializeServiceWorkerContextOnWorkerThread(
     v8::Local<v8::Context> v8_context,
     int64_t service_worker_version_id,
-    const GURL& url) {
+    const GURL& service_worker_scope,
+    const GURL& script_url) {
   const base::TimeTicks start_time = base::TimeTicks::Now();
 
-  if (!url.SchemeIs(kExtensionScheme)) {
+  if (!script_url.SchemeIs(kExtensionScheme)) {
     // Early-out if this isn't a chrome-extension:// scheme, because looking up
     // the extension registry is unnecessary if it's not. Checking this will
     // also skip over hosted apps, which is the desired behavior - hosted app
     // service workers are not our concern.
     return;
   }
 
   const Extension* extension =
-      RendererExtensionRegistry::Get()->GetExtensionOrAppByURL(url);
+      RendererExtensionRegistry::Get()->GetExtensionOrAppByURL(script_url);
 
   if (!extension) {
     // TODO(kalman): This is no good. Instead we need to either:
     //
     // - Hold onto the v8::Context and create the ScriptContext and install
     //   our bindings when this extension is loaded.
-    // - Deal with there being an extension ID (url.host()) but no
+    // - Deal with there being an extension ID (script_url.host()) but no
     //   extension associated with it, then document that getBackgroundClient
     //   may fail if the extension hasn't loaded yet.
     //
     // The former is safer, but is unfriendly to caching (e.g. session restore).
     // It seems to contradict the service worker idiom.
     //
     // The latter is friendly to caching, but running extension code without an
     // installed extension makes me nervous, and means that we won't be able to
     // expose arbitrary (i.e. capability-checked) extension APIs to service
     // workers. We will probably need to relax some assertions - we just need
     // to find them.
     //
     // Perhaps this could be solved with our own event on the service worker
     // saying that an extension is ready, and documenting that extension APIs
     // won't work before that event has fired?
     return;
   }
 
   ScriptContext* context = new ScriptContext(
       v8_context, nullptr, extension, Feature::SERVICE_WORKER_CONTEXT,
       extension, Feature::SERVICE_WORKER_CONTEXT);
-  context->set_url(url);
+  context->set_url(script_url);
+  context->set_service_worker_scope(service_worker_scope);
 
   if (ExtensionsClient::Get()->ExtensionAPIEnabledInExtensionServiceWorkers()) {
     WorkerThreadDispatcher::Get()->AddWorkerData(service_worker_version_id,
                                                  context, &source_map_);
 
     // TODO(lazyboy): Make sure accessing |source_map_| in worker thread is
     // safe.
     context->set_module_system(
         base::MakeUnique<ModuleSystem>(context, &source_map_));
 
@@ skipping 69 matching lines @@
   bindings_system_->WillReleaseScriptContext(context);
 
   script_context_set_->Remove(context);
   VLOG(1) << "Num tracked contexts: " << script_context_set_->size();
 }
 
 // static
 void Dispatcher::WillDestroyServiceWorkerContextOnWorkerThread(
     v8::Local<v8::Context> v8_context,
     int64_t service_worker_version_id,
-    const GURL& url) {
-  if (url.SchemeIs(kExtensionScheme)) {
+    const GURL& service_worker_scope,
+    const GURL& script_url) {
+  if (script_url.SchemeIs(kExtensionScheme)) {
     // See comment in DidInitializeServiceWorkerContextOnWorkerThread.
-    g_worker_script_context_set.Get().Remove(v8_context, url);
+    g_worker_script_context_set.Get().Remove(v8_context, script_url);
     // TODO(devlin): We're not calling
     // ExtensionBindingsSystem::WillReleaseScriptContext() here. This should be
     // fine, since the entire bindings system is being destroyed when we
     // remove the worker data, but we might want to notify the system anyway.
   }
   if (ExtensionsClient::Get()->ExtensionAPIEnabledInExtensionServiceWorkers())
     WorkerThreadDispatcher::Get()->RemoveWorkerData(service_worker_version_id);
 }
 
 void Dispatcher::DidCreateDocumentElement(blink::WebLocalFrame* frame) {
@@ skipping 907 matching lines @@
   // The "guestViewDeny" module must always be loaded last. It registers
   // error-providing custom elements for the GuestView types that are not
   // available, and thus all of those types must have been checked and loaded
   // (or not loaded) beforehand.
   if (context_type == Feature::BLESSED_EXTENSION_CONTEXT) {
     module_system->Require("guestViewDeny");
   }
 }
 
 }  // namespace extensions