[Background Sync] Sent sync registration details to worker

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 21 matching lines @@
 #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/background_sync.mojom.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"
 
@@ skipping 733 matching lines @@
   ServiceWorkerStatusCode status = embedded_worker_->SendMessage(
       ServiceWorkerMsg_FetchEvent(request_id, request));
   if (status != SERVICE_WORKER_OK) {
     fetch_requests_.Remove(request_id);
     RunSoon(base::Bind(&RunErrorFetchCallback,
                        fetch_callback,
                        SERVICE_WORKER_ERROR_FAILED));
   }
 }
 
-void ServiceWorkerVersion::DispatchSyncEvent(const StatusCallback& callback) {
+void ServiceWorkerVersion::DispatchSyncEvent(SyncRegistrationPtr registration,
+                                             const StatusCallback& callback) {
   DCHECK_EQ(ACTIVATED, status()) << status();
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
-    StartWorker(base::Bind(&RunTaskAfterStartWorker,
-                           weak_factory_.GetWeakPtr(), callback,
-                           base::Bind(&self::DispatchSyncEvent,
-                                      weak_factory_.GetWeakPtr(),
-                                      callback)));
+    StartWorker(base::Bind(
+        &RunTaskAfterStartWorker, weak_factory_.GetWeakPtr(), callback,
+        base::Bind(&self::DispatchSyncEvent, weak_factory_.GetWeakPtr(),
+                   base::Passed(registration.Pass()), callback)));
     return;
   }
 
   int request_id = AddRequest(callback, &sync_requests_, REQUEST_SYNC);
   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));
+      registration.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 1398 matching lines @@
                     base::string16());
   service_port_dispatcher_.reset();
 }
 
 void ServiceWorkerVersion::OnBackgroundSyncDispatcherConnectionError() {
   RunIDMapCallbacks(&sync_requests_, SERVICE_WORKER_ERROR_FAILED);
   background_sync_dispatcher_.reset();
 }
 
 }  // namespace content