[Background Sync] Use Mojo IPC to fire background sync events

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/command_line.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 21 matching lines @@
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/page_navigator.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
+#include "content/public/common/service_registry.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 
 namespace content {
 
 using StatusCallback = ServiceWorkerVersion::StatusCallback;
 using ServiceWorkerClients = std::vector<ServiceWorkerClientInfo>;
 using GetClientsCallback =
     base::Callback<void(scoped_ptr<ServiceWorkerClients>)>;
 
@@ skipping 695 matching lines @@
     // Schedule calling this method after starting the worker.
     StartWorker(base::Bind(&RunTaskAfterStartWorker,
                            weak_factory_.GetWeakPtr(), callback,
                            base::Bind(&self::DispatchSyncEvent,
                                       weak_factory_.GetWeakPtr(),
                                       callback)));
     return;
   }
 
   int request_id = AddRequest(callback, &sync_callbacks_, REQUEST_SYNC);
-  ServiceWorkerStatusCode status = embedded_worker_->SendMessage(
-      ServiceWorkerMsg_SyncEvent(request_id));
-  if (status != SERVICE_WORKER_OK) {
-    sync_callbacks_.Remove(request_id);
-    RunSoon(base::Bind(callback, status));
-  }
+  mojo_event_dispatcher_.DispatchSyncEvent(
+      embedded_worker_->process_id(), embedded_worker_->thread_id(),

[michaeln, 2015/06/24 00:12:01]

This won't quite work because ServiceWorkerVersion instances outlive individual
running script instances. A ServiceWorkerVersion can serially start many script
instances in possibly different processes over its lifetime.

food4thought

In the serviceworker codebase, the ServiceWorkerDispatcherHost's is paired with
a particular renderer processes lifetime. Arranging for a mojo_event_dispatcher_
instance to be owned and scoped by ServiceWorkerDispatcherHost might make sense.
The ServiceWorkerContextCore class serves as a registry of sorts. It's a
centrally located class that is reachable by most things and maintains ptrs to
instances of significant other things (see the Add/Remove/GetProviderHost and
Add/Remove/GetLiveXXX methods). Maybe we can Add/Remove/GetSyncEventDispatcher
ptrs as well. Have the dispatcherhost add/rmv the instance it creates for it's
process, and have versions get it by process id as needed.

[iclelland, 2015/06/25 15:17:34]

I've uploaded a new patchset that does just this -- see if it makes sense, and
actually does what you're suggesting here.

+      base::Bind(&self::OnSyncEventFinished, weak_factory_.GetWeakPtr(),
+                 request_id));
 }
 
 void ServiceWorkerVersion::DispatchNotificationClickEvent(
     const StatusCallback& callback,
     int64_t persistent_notification_id,
     const PlatformNotificationData& notification_data) {
   DCHECK_EQ(ACTIVATED, status()) << status();
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
     StartWorker(base::Bind(
@@ skipping 394 matching lines @@
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ServiceWorkerVersion, message)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_GetClients,
                         OnGetClients)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_ActivateEventFinished,
                         OnActivateEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_InstallEventFinished,
                         OnInstallEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_FetchEventFinished,
                         OnFetchEventFinished)
-    IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_SyncEventFinished,
-                        OnSyncEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_NotificationClickEventFinished,
                         OnNotificationClickEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_PushEventFinished,
                         OnPushEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_GeofencingEventFinished,
                         OnGeofencingEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_CrossOriginConnectEventFinished,
                         OnCrossOriginConnectEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_OpenWindow,
                         OnOpenWindow)
@@ skipping 151 matching lines @@
 
   // TODO(kinuko): Record other event statuses too.
   const bool handled = (result == SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE);
   metrics_->RecordEventStatus(handled);
 
   scoped_refptr<ServiceWorkerVersion> protect(this);
   callback->Run(SERVICE_WORKER_OK, result, response);
   RemoveCallbackAndStopIfRedundant(&fetch_callbacks_, request_id);
 }
 
-void ServiceWorkerVersion::OnSyncEventFinished(
-    int request_id,
-    blink::WebServiceWorkerEventResult result) {
+void ServiceWorkerVersion::OnSyncEventFinished(int request_id,
+                                               ServiceWorkerStatusCode status) {
   TRACE_EVENT1("ServiceWorker",
                "ServiceWorkerVersion::OnSyncEventFinished",
                "Request id", request_id);
   StatusCallback* callback = sync_callbacks_.Lookup(request_id);
   if (!callback) {
     NOTREACHED() << "Got unexpected message: " << request_id;
     return;
   }
 
-  ServiceWorkerStatusCode status = SERVICE_WORKER_OK;
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableServiceWorkerSync)) {
     // Avoid potential race condition where flag is disabled after a sync event
     // was dispatched
     status = SERVICE_WORKER_ERROR_ABORT;
-  } else if (result == blink::WebServiceWorkerEventResultRejected) {
-    status = SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED;
   }
 
   scoped_refptr<ServiceWorkerVersion> protect(this);
   callback->Run(status);
   RemoveCallbackAndStopIfRedundant(&sync_callbacks_, request_id);
 }
 
 void ServiceWorkerVersion::OnNotificationClickEventFinished(
     int request_id) {
   TRACE_EVENT1("ServiceWorker",
@@ skipping 670 matching lines @@
         return SERVICE_WORKER_ERROR_ABORT;
       default:
         return SERVICE_WORKER_ERROR_NETWORK;
     }
   }
 
   return default_code;
 }
 
 }  // namespace content