Browser side of ServiceWorker requestSyncEvents() function

content/browser/service_worker/service_worker_version.cc

 // Copyright 2013 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 "content/browser/service_worker/service_worker_version.h"
 
 #include "base/stl_util.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
@@ skipping 148 matching lines @@
 
 }  // namespace
 
 ServiceWorkerVersion::ServiceWorkerVersion(
     ServiceWorkerRegistration* registration,
     EmbeddedWorkerRegistry* worker_registry,
     int64 version_id)
     : version_id_(version_id),
       status_(NEW),
       is_shutdown_(false),
+      requested_sync_events_(false),
       registration_(registration),
       weak_factory_(this) {
   if (worker_registry) {
     embedded_worker_ = worker_registry->CreateWorker();
     embedded_worker_->AddObserver(this);
   }
 }
 
 ServiceWorkerVersion::~ServiceWorkerVersion() { DCHECK(is_shutdown_); }
 
@@ skipping 157 matching lines @@
     const ServiceWorkerFetchRequest& request,
     const FetchCallback& callback) {
   DCHECK_EQ(ACTIVE, status()) << status();
   SendMessageAndRegisterCallback(
       ServiceWorkerMsg_FetchEvent(request),
       base::Bind(&HandleFetchResponse, callback));
 }
 
 void ServiceWorkerVersion::DispatchSyncEvent(const StatusCallback& callback) {
   DCHECK_EQ(ACTIVE, status()) << status();
+  // Don't send the event to ServiceWorkers that aren't interested.
+  if (!requested_sync_events_) {
+    callback.Run(SERVICE_WORKER_ERROR_ABORT);
+    return;
+  }
+
   SendMessageAndRegisterCallback(
       ServiceWorkerMsg_SyncEvent(),
       base::Bind(&HandleSyncEventFinished, callback));
 }
 
 void ServiceWorkerVersion::AddProcessToWorker(int process_id) {
   DCHECK(!is_shutdown_);
   embedded_worker_->AddProcessReference(process_id);
 }
 
@@ skipping 21 matching lines @@
   // callbacks for events).
   // TODO(kinuko): Consider if we want to add queue+resend mechanism here.
   IDMap<MessageCallback, IDMapOwnPointer>::iterator iter(&message_callbacks_);
   while (!iter.IsAtEnd()) {
     iter.GetCurrentValue()->Run(SERVICE_WORKER_ERROR_ABORT, IPC::Message());
     iter.Advance();
   }
   message_callbacks_.Clear();
 }
 
-void ServiceWorkerVersion::OnMessageReceived(
-    int request_id, const IPC::Message& message) {
+void ServiceWorkerVersion::RequestSyncEvents(bool requested) {
+  requested_sync_events_ = requested;
+}
+
+void ServiceWorkerVersion::OnMessageReceived(int request_id,
+                                             const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(ServiceWorkerVersion, message)
+    IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_RequestSyncEvents,
+                        RequestSyncEvents)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+
+  if (handled)
+    return;
+
   MessageCallback* callback = message_callbacks_.Lookup(request_id);
   if (callback) {
     callback->Run(SERVICE_WORKER_OK, message);
     message_callbacks_.Remove(request_id);
     return;
   }
-  NOTREACHED() << "Got unexpected message: " << request_id
-               << " " << message.type();
+  NOTREACHED() << "Got unexpected message: " << request_id << " "
+               << message.type();
 }
 
 }  // namespace content