This dispatches the "activate" event to service workers after they're…

… installed, and will indicate that the service worker failed if it rejects a promise.

BUG=356021

Review URL: https://codereview.chromium.org/212593010

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@260820 0039d316-1c4b-4281-b951-d872f2087c98

content/browser/service_worker/embedded_worker_registry.cc

@@ -78,7 +78,8 @@ void EmbeddedWorkerRegistry::OnSendMessageToBrowser(
   }
   // Perform security check to filter out any unexpected (and non-test)
   // messages. This must list up all message types that can go through here.
-  if (message.type() == ServiceWorkerHostMsg_InstallEventFinished::ID ||
+  if (message.type() == ServiceWorkerHostMsg_ActivateEventFinished::ID ||
+      message.type() == ServiceWorkerHostMsg_InstallEventFinished::ID ||
       message.type() == ServiceWorkerHostMsg_FetchEventFinished::ID ||
       IPC_MESSAGE_CLASS(message) == TestMsgStart) {
     found->second->OnMessageReceived(request_id, message);

content/browser/service_worker/embedded_worker_registry.h

@@ -54,6 +54,8 @@ class CONTENT_EXPORT EmbeddedWorkerRegistry
   // ServiceWorkerDispatcherHost.
   void OnWorkerStarted(int process_id, int thread_id, int embedded_worker_id);
   void OnWorkerStopped(int process_id, int embedded_worker_id);
+  // FIXME(dominicc): Rename this. The name leads to confusion that
+  // this sends a message to the browser itself.
   void OnSendMessageToBrowser(int embedded_worker_id,
                               int request_id,
                               const IPC::Message& message);

content/browser/service_worker/embedded_worker_test_helper.cc

@@ -78,6 +78,7 @@ bool EmbeddedWorkerTestHelper::OnSendMessageToWorker(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(EmbeddedWorkerTestHelper, message)
+    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ActivateEvent, OnActivateEventStub)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_InstallEvent, OnInstallEventStub)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_FetchEvent, OnFetchEventStub)
     IPC_MESSAGE_UNHANDLED(handled = false)
@@ -87,6 +88,15 @@ bool EmbeddedWorkerTestHelper::OnSendMessageToWorker(
   return handled;
 }
 
+void EmbeddedWorkerTestHelper::OnActivateEvent(int embedded_worker_id,
+                                               int request_id) {
+  SimulateSendMessageToBrowser(
+      embedded_worker_id,
+      request_id,
+      ServiceWorkerHostMsg_ActivateEventFinished(
+          blink::WebServiceWorkerEventResultCompleted));
+}
+
 void EmbeddedWorkerTestHelper::OnInstallEvent(int embedded_worker_id,
                                               int request_id,
                                               int active_version_id) {
@@ -179,6 +189,15 @@ void EmbeddedWorkerTestHelper::OnSendMessageToWorkerStub(
           message));
 }
 
+void EmbeddedWorkerTestHelper::OnActivateEventStub() {
+  base::MessageLoopProxy::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&EmbeddedWorkerTestHelper::OnActivateEvent,
+                 weak_factory_.GetWeakPtr(),
+                 current_embedded_worker_id_,
+                 current_request_id_));
+}
+
 void EmbeddedWorkerTestHelper::OnInstallEventStub(int active_version_id) {
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,

content/browser/service_worker/embedded_worker_test_helper.h

@@ -32,10 +32,8 @@ struct ServiceWorkerFetchRequest;
 // for StartWorker and StopWorker requests. The default implementation
 // also returns success for event messages (e.g. InstallEvent, FetchEvent).
 //
-// Alternatively consumers can subclass this helper and override
-// OnStartWorker(), OnStopWorker(), OnSendMessageToWorker(),
-// OnInstallEvent(), OnFetchEvent() etc to add their own
-// logic/verification code.
+// Alternatively consumers can subclass this helper and override On*()
+// methods to add their own logic/verification code.
 //
 // See embedded_worker_instance_unittest.cc for example usages.
 //
@@ -67,9 +65,9 @@ class EmbeddedWorkerTestHelper : public IPC::Sender,
   // Called when StartWorker, StopWorker and SendMessageToWorker message
   // is sent to the embedded worker. Override if necessary. By default
   // they verify given parameters and:
-  // - call SimulateWorkerStarted for OnStartWorker
-  // - call SimulateWorkerStoped for OnStopWorker
-  // - call OnFooEvent handlers for known events for OnSendMessageToWorker
+  // - OnStartWorker calls SimulateWorkerStarted
+  // - OnStopWorker calls SimulateWorkerStoped
+  // - OnSendMessageToWorker calls the message's respective On*Event handler
   virtual void OnStartWorker(int embedded_worker_id,
                              int64 service_worker_version_id,
                              const GURL& script_url);
@@ -79,10 +77,11 @@ class EmbeddedWorkerTestHelper : public IPC::Sender,
                                      int request_id,
                                      const IPC::Message& message);
 
-  // Called when InstallEvent, FetchEvent message is sent to the embedded
-  // worker. These are called via OnSendMessageToWorker()'s default
-  // implementation. By default they just return success via
+  // On*Event handlers. Called by the default implementation of
+  // OnSendMessageToWorker when events are sent to the embedded
+  // worker. By default they just return success via
   // SimulateSendMessageToBrowser.
+  virtual void OnActivateEvent(int embedded_worker_id, int request_id);
   virtual void OnInstallEvent(int embedded_worker_id,
                               int request_id,
                               int active_version_id);
@@ -107,6 +106,7 @@ class EmbeddedWorkerTestHelper : public IPC::Sender,
                                  int embedded_worker_id,
                                  int request_id,
                                  const IPC::Message& message);
+  void OnActivateEventStub();
   void OnInstallEventStub(int active_version_id);
   void OnFetchEventStub(const ServiceWorkerFetchRequest& request);
 

content/browser/service_worker/service_worker_browsertest.cc

@@ -259,6 +259,23 @@ class ServiceWorkerVersionBrowserTest : public ServiceWorkerBrowserTest {
     ASSERT_EQ(SERVICE_WORKER_OK, status);
   }
 
+  void ActivateTestHelper(
+      const std::string& worker_url,
+      ServiceWorkerStatusCode expected_status) {
+    RunOnIOThread(
+        base::Bind(&self::SetUpRegistrationOnIOThread, this, worker_url));
+    version_->SetStatus(ServiceWorkerVersion::INSTALLED);
+    ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
+    base::RunLoop run_loop;
+    BrowserThread::PostTask(
+        BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(
+            &self::ActivateOnIOThread, this, run_loop.QuitClosure(), &status));
+    run_loop.Run();
+    ASSERT_EQ(expected_status, status);
+  }
+
   void FetchTestHelper(const std::string& worker_url,
                        ServiceWorkerFetchEventResult* result,
                        ServiceWorkerResponse* response) {
@@ -306,6 +323,14 @@ class ServiceWorkerVersionBrowserTest : public ServiceWorkerBrowserTest {
         -1, CreateReceiver(BrowserThread::UI, done, result));
   }
 
+  void ActivateOnIOThread(const base::Closure& done,
+                          ServiceWorkerStatusCode* result) {
+    ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    version_->SetStatus(ServiceWorkerVersion::INSTALLED);
+    version_->DispatchActivateEvent(
+        CreateReceiver(BrowserThread::UI, done, result));
+  }
+
   void FetchOnIOThread(const base::Closure& done, FetchResult* result) {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     ServiceWorkerFetchRequest request(
@@ -399,6 +424,17 @@ IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest,
                     SERVICE_WORKER_OK);
 }
 
+IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest,
+                       Activate_NoEventListener) {
+  ActivateTestHelper("/service_worker/worker.js", SERVICE_WORKER_OK);
+  ASSERT_EQ(ServiceWorkerVersion::ACTIVE, version_->status());
+}
+
+IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, Activate_Rejected) {
+  ActivateTestHelper("/service_worker/worker_activate_rejected.js",
+                     SERVICE_WORKER_ERROR_ACTIVATE_WORKER_FAILED);
+}
+
 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest,
                        InstallWithWaitUntil_Rejected) {
   InstallTestHelper("/service_worker/worker_install_rejected.js",

content/browser/service_worker/service_worker_version.cc

@@ -306,20 +306,19 @@ void ServiceWorkerVersion::DispatchActivateEvent(
     const StatusCallback& callback) {
   DCHECK_EQ(INSTALLED, status()) << status();
   SetStatus(ACTIVATING);
-  // TODO(kinuko): Implement.
-  NOTIMPLEMENTED();
+  // TODO(dominicc): Also dispatch activate callbacks to the document,
+  // and activate end callbacks to the service worker and the document.
   HandleInstallPhaseEventFinishedParameters params(
       weak_factory_.GetWeakPtr(),
-      -1 /* dummy message_id */,
-      InstallPhaseEventFinishedMessageReader(),
+      ServiceWorkerHostMsg_ActivateEventFinished::ID,
+      base::Bind(&ServiceWorkerHostMsg_ActivateEventFinished::Read),
       callback,
       ACTIVE,
       INSTALLED,
       SERVICE_WORKER_ERROR_ACTIVATE_WORKER_FAILED);
-  RunSoon(base::Bind(&HandleInstallPhaseEventFinished,
-                     params,
-                     SERVICE_WORKER_OK,
-                     IPC::Message(-1, -1, IPC::Message::PRIORITY_NORMAL)));
+  SendMessageAndRegisterCallback(
+      ServiceWorkerMsg_ActivateEvent(),
+      base::Bind(&HandleInstallPhaseEventFinished, params));
 }
 
 void ServiceWorkerVersion::DispatchFetchEvent(

content/common/service_worker/service_worker_messages.h

@@ -90,6 +90,9 @@ IPC_MESSAGE_CONTROL2(ServiceWorkerHostMsg_RemoveScriptClient,
 IPC_MESSAGE_CONTROL1(ServiceWorkerHostMsg_InstallEventFinished,
                      blink::WebServiceWorkerEventResult)
 
+IPC_MESSAGE_CONTROL1(ServiceWorkerHostMsg_ActivateEventFinished,
+                     blink::WebServiceWorkerEventResult);
+
 // Informs the browser that fetch event handling has finished.
 // Sent via EmbeddedWorker.
 IPC_MESSAGE_CONTROL2(ServiceWorkerHostMsg_FetchEventFinished,
@@ -120,6 +123,8 @@ IPC_MESSAGE_CONTROL4(ServiceWorkerMsg_ServiceWorkerRegistrationError,
 // Sent via EmbeddedWorker to dispatch install event.
 IPC_MESSAGE_CONTROL1(ServiceWorkerMsg_InstallEvent, int /* active_version_id */)
 
+IPC_MESSAGE_CONTROL0(ServiceWorkerMsg_ActivateEvent)
+
 // Sent via EmbeddedWorker to dispatch fetch event.
 IPC_MESSAGE_CONTROL1(ServiceWorkerMsg_FetchEvent,
                      content::ServiceWorkerFetchRequest)

content/renderer/service_worker/embedded_worker_context_client.cc

@@ -153,6 +153,13 @@ void EmbeddedWorkerContextClient::workerContextDestroyed() {
                  embedded_worker_id_));
 }
 
+void EmbeddedWorkerContextClient::didHandleActivateEvent(
+    int request_id,
+    blink::WebServiceWorkerEventResult result) {
+  DCHECK(script_context_);
+  script_context_->DidHandleActivateEvent(request_id, result);
+}
+
 void EmbeddedWorkerContextClient::didHandleInstallEvent(
     int request_id,
     blink::WebServiceWorkerEventResult result) {

content/renderer/service_worker/embedded_worker_context_client.h

@@ -61,6 +61,8 @@ class EmbeddedWorkerContextClient
   virtual void workerContextFailedToStart();
   virtual void workerContextStarted(blink::WebServiceWorkerContextProxy* proxy);
   virtual void workerContextDestroyed();
+  virtual void didHandleActivateEvent(int request_id,
+                                      blink::WebServiceWorkerEventResult);
   virtual void didHandleInstallEvent(int request_id,
                                      blink::WebServiceWorkerEventResult result);
   virtual void didHandleFetchEvent(int request_id);

content/renderer/service_worker/service_worker_script_context.cc

@@ -30,15 +30,22 @@ void ServiceWorkerScriptContext::OnMessageReceived(
   current_request_id_ = request_id;
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ServiceWorkerScriptContext, message)
-    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_InstallEvent, OnInstallEvent)
+    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ActivateEvent, OnActivateEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_FetchEvent, OnFetchEvent)
+    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_InstallEvent, OnInstallEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_Message, OnPostMessage)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled);
   current_request_id_ = kInvalidServiceWorkerRequestId;
 }
 
+void ServiceWorkerScriptContext::DidHandleActivateEvent(
+    int request_id,
+    blink::WebServiceWorkerEventResult result) {
+  Send(request_id, ServiceWorkerHostMsg_ActivateEventFinished(result));
+}
+
 void ServiceWorkerScriptContext::DidHandleInstallEvent(
     int request_id,
     blink::WebServiceWorkerEventResult result) {
@@ -57,6 +64,10 @@ void ServiceWorkerScriptContext::Send(int request_id,
   embedded_context_->SendMessageToBrowser(request_id, message);
 }
 
+void ServiceWorkerScriptContext::OnActivateEvent() {
+  proxy_->dispatchActivateEvent(current_request_id_);
+}
+
 void ServiceWorkerScriptContext::OnInstallEvent(int active_version_id) {
   proxy_->dispatchInstallEvent(current_request_id_);
 }

content/renderer/service_worker/service_worker_script_context.h

@@ -38,6 +38,8 @@ class ServiceWorkerScriptContext {
 
   void OnMessageReceived(int request_id, const IPC::Message& message);
 
+  void DidHandleActivateEvent(int request_id,
+                              blink::WebServiceWorkerEventResult);
   void DidHandleInstallEvent(int request_id,
                              blink::WebServiceWorkerEventResult result);
   void DidHandleFetchEvent(int request_id,
@@ -48,6 +50,7 @@ class ServiceWorkerScriptContext {
   // Send message back to the browser.
   void Send(int request_id, const IPC::Message& message);
 
+  void OnActivateEvent();
   void OnInstallEvent(int active_version_id);
   void OnFetchEvent(const ServiceWorkerFetchRequest& request);
   void OnPostMessage(const base::string16& message,

content/test/data/service_worker/worker_activate_rejected.js

@@ -0,0 +1,9 @@
+// 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.
+
+this.onactivate = function(event) {
+    event.waitUntil(new Promise(function(resolve, reject) {
+        setTimeout(reject, 5);
+    }));
+};