[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 <map>
 #include <string>
 
 #include "base/command_line.h"
@@ skipping 13 matching lines @@
 #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"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_metrics.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_utils.h"
 #include "content/browser/service_worker/stashed_port_manager.h"
 #include "content/browser/storage_partition_impl.h"
 #include "content/common/service_worker/service_worker_messages.h"
+#include "content/common/service_worker/service_worker_type_converters.h"
 #include "content/public/browser/browser_thread.h"
 #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 "mojo/common/common_type_converters.h"
 #include "mojo/common/url_type_converters.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 =
@@ skipping 741 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_requests_, REQUEST_SYNC);
-  ServiceWorkerStatusCode status = embedded_worker_->SendMessage(
-      ServiceWorkerMsg_SyncEvent(request_id));
-  if (status != SERVICE_WORKER_OK) {
-    sync_requests_.Remove(request_id);
-    RunSoon(base::Bind(callback, status));
+  if (!background_sync_dispatcher_) {
+    embedded_worker_->GetServiceRegistry()->ConnectToRemoteService(
+        mojo::GetProxy(&background_sync_dispatcher_));
+    background_sync_dispatcher_.set_connection_error_handler(base::Bind(
+        &ServiceWorkerVersion::OnBackgroundSyncDispatcherConnectionError,
+        weak_factory_.GetWeakPtr()));
   }
+
+  // TODO(iclelland): Replace this with the real event registration details
+  // crbug.com/482066
+  content::SyncRegistrationPtr null_event(content::SyncRegistration::New());
+
+  background_sync_dispatcher_->Sync(
+      null_event.Pass(), 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 378 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_OpenWindow,
                         OnOpenWindow)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_SetCachedMetadata,
                         OnSetCachedMetadata)
@@ skipping 163 matching lines @@
   ServiceWorkerMetrics::RecordFetchEventTime(
       result, base::TimeTicks::Now() - request->start_time);
 
   scoped_refptr<ServiceWorkerVersion> protect(this);
   request->callback.Run(SERVICE_WORKER_OK, result, response);
   RemoveCallbackAndStopIfRedundant(&fetch_requests_, request_id);
 }
 
 void ServiceWorkerVersion::OnSyncEventFinished(
     int request_id,
-    blink::WebServiceWorkerEventResult result) {
+    ServiceWorkerEventStatus status) {
   TRACE_EVENT1("ServiceWorker",
                "ServiceWorkerVersion::OnSyncEventFinished",
                "Request id", request_id);
   PendingRequest<StatusCallback>* request = sync_requests_.Lookup(request_id);
   if (!request) {
     NOTREACHED() << "Got unexpected message: " << request_id;
     return;
   }
 
-  ServiceWorkerStatusCode status = SERVICE_WORKER_OK;
-  if (result == blink::WebServiceWorkerEventResultRejected) {
-    status = SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED;
-  }
-
   scoped_refptr<ServiceWorkerVersion> protect(this);
-  request->callback.Run(status);
+  request->callback.Run(mojo::ConvertTo<ServiceWorkerStatusCode>(status));
   RemoveCallbackAndStopIfRedundant(&sync_requests_, request_id);
 }
 
 void ServiceWorkerVersion::OnNotificationClickEventFinished(
     int request_id) {
   TRACE_EVENT1("ServiceWorker",
                "ServiceWorkerVersion::OnNotificationClickEventFinished",
                "Request id", request_id);
   PendingRequest<StatusCallback>* request =
       notification_click_requests_.Lookup(request_id);
@@ skipping 782 matching lines @@
                     ServiceWorkerResponse());
   RunIDMapCallbacks(&sync_requests_, SERVICE_WORKER_ERROR_FAILED);
   RunIDMapCallbacks(&notification_click_requests_, SERVICE_WORKER_ERROR_FAILED);
   RunIDMapCallbacks(&push_requests_, SERVICE_WORKER_ERROR_FAILED);
   RunIDMapCallbacks(&geofencing_requests_, SERVICE_WORKER_ERROR_FAILED);
 
   // Close all mojo services. This will also fire and clear all callbacks
   // for messages that are still outstanding for those services.
   OnServicePortDispatcherConnectionError();
 
+  OnBackgroundSyncDispatcherConnectionError();
+
   streaming_url_request_jobs_.clear();
 
   FOR_EACH_OBSERVER(Listener, listeners_, OnRunningStateChanged(this));
 
   if (should_restart)
     StartWorkerInternal();
 }
 
 void ServiceWorkerVersion::OnServicePortDispatcherConnectionError() {
   RunIDMapCallbacks(&service_port_connect_requests_,
                     SERVICE_WORKER_ERROR_FAILED, false, base::string16(),
                     base::string16());
   service_port_dispatcher_.reset();
 }
 
+void ServiceWorkerVersion::OnBackgroundSyncDispatcherConnectionError() {
+  RunIDMapCallbacks(&sync_requests_, SERVICE_WORKER_ERROR_FAILED);
+  background_sync_dispatcher_.reset();
+}
+
 }  // namespace content