Chrome side of passing on the service worker registration with geofencing API calls.

content/child/geofencing/geofencing_dispatcher.cc

 // 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.
 
 #include "content/child/geofencing/geofencing_dispatcher.h"
 
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/thread_task_runner_handle.h"
+#include "content/child/service_worker/web_service_worker_registration_impl.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/child/worker_thread_task_runner.h"
 #include "content/common/geofencing_messages.h"
+#include "content/common/service_worker/service_worker_types.h"
 #include "third_party/WebKit/public/platform/WebCircularGeofencingRegion.h"
 #include "third_party/WebKit/public/platform/WebGeofencingError.h"
 #include "third_party/WebKit/public/platform/WebGeofencingRegistration.h"
 
 using blink::WebGeofencingError;
 
 namespace content {
 
 namespace {
 
@@ skipping 32 matching lines @@
     IPC_MESSAGE_HANDLER(GeofencingMsg_GetRegisteredRegionsComplete,
                         OnGetRegisteredRegionsComplete)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled) << "Unhandled message:" << msg.type();
 }
 
 void GeofencingDispatcher::RegisterRegion(
     const blink::WebString& region_id,
     const blink::WebCircularGeofencingRegion& region,
+    blink::WebServiceWorkerRegistration* service_worker_registration,
     blink::WebGeofencingCallbacks* callbacks) {
   DCHECK(callbacks);
   int request_id = region_registration_requests_.Add(callbacks);
-  Send(new GeofencingHostMsg_RegisterRegion(
-      CurrentWorkerId(), request_id, region_id.utf8(), region));
+  // TODO(mek): Reject requests without a service worker registration without

[palmer, 2014/10/16 01:22:34]

Nit: Wording: "without...without..." sounds a bit odd. Maybe "Immediately reject
requests lacking a service worker registration, without bouncing...".

[Marijn Kruisselbrink, 2014/10/16 17:00:19]

Done.

+  //     bouncing through browser process.
+  int64 serviceworker_registration_id = kInvalidServiceWorkerRegistrationId;
+  if (service_worker_registration) {
+    serviceworker_registration_id =
+        static_cast<WebServiceWorkerRegistrationImpl*>(
+            service_worker_registration)->registration_id();
+  }
+  Send(new GeofencingHostMsg_RegisterRegion(CurrentWorkerId(),
+                                            request_id,
+                                            region_id.utf8(),
+                                            region,
+                                            serviceworker_registration_id));
 }
 
 void GeofencingDispatcher::UnregisterRegion(
     const blink::WebString& region_id,
+    blink::WebServiceWorkerRegistration* service_worker_registration,
     blink::WebGeofencingCallbacks* callbacks) {
   DCHECK(callbacks);
   int request_id = region_unregistration_requests_.Add(callbacks);
-  Send(new GeofencingHostMsg_UnregisterRegion(
-      CurrentWorkerId(), request_id, region_id.utf8()));
+  // TODO(mek): Reject requests without a service worker registration without
+  //     bouncing through browser process.
+  int64 serviceworker_registration_id = kInvalidServiceWorkerRegistrationId;
+  if (service_worker_registration) {
+    serviceworker_registration_id =
+        static_cast<WebServiceWorkerRegistrationImpl*>(
+            service_worker_registration)->registration_id();
+  }
+  Send(new GeofencingHostMsg_UnregisterRegion(CurrentWorkerId(),
+                                              request_id,
+                                              region_id.utf8(),
+                                              serviceworker_registration_id));
 }
 
 void GeofencingDispatcher::GetRegisteredRegions(
+    blink::WebServiceWorkerRegistration* service_worker_registration,
     blink::WebGeofencingRegionsCallbacks* callbacks) {
   DCHECK(callbacks);
   int request_id = get_registered_regions_requests_.Add(callbacks);
-  Send(new GeofencingHostMsg_GetRegisteredRegions(CurrentWorkerId(),
-                                                  request_id));
+  // TODO(mek): Reject requests without a service worker registration without
+  //     bouncing through browser process.
+  int64 serviceworker_registration_id = kInvalidServiceWorkerRegistrationId;
+  if (service_worker_registration) {
+    serviceworker_registration_id =
+        static_cast<WebServiceWorkerRegistrationImpl*>(
+            service_worker_registration)->registration_id();
+  }
+  Send(new GeofencingHostMsg_GetRegisteredRegions(
+      CurrentWorkerId(), request_id, serviceworker_registration_id));
 }
 
 GeofencingDispatcher* GeofencingDispatcher::GetOrCreateThreadSpecificInstance(
     ThreadSafeSender* thread_safe_sender) {
   if (g_dispatcher_tls.Pointer()->Get() == kHasBeenDeleted) {
     NOTREACHED() << "Re-instantiating TLS GeofencingDispatcher.";
     g_dispatcher_tls.Pointer()->Set(NULL);
   }
   if (g_dispatcher_tls.Pointer()->Get())
     return g_dispatcher_tls.Pointer()->Get();
@@ skipping 77 matching lines @@
         blink::WebString::fromUTF8(GeofencingStatusToString(status))));
   }
   get_registered_regions_requests_.Remove(request_id);
 }
 
 void GeofencingDispatcher::OnWorkerRunLoopStopped() {
   delete this;
 }
 
 }  // namespace content