Chromium side of geofencing event dispatching.

content/browser/geofencing/geofencing_manager.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/browser/geofencing/geofencing_manager.h"
 
 #include <algorithm>
 
 #include "base/callback.h"
 #include "base/memory/singleton.h"
 #include "content/browser/geofencing/geofencing_provider.h"
+#include "content/browser/service_worker/service_worker_context_wrapper.h"
+#include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/storage_partition.h"
 #include "third_party/WebKit/public/platform/WebCircularGeofencingRegion.h"
+#include "third_party/WebKit/public/platform/WebGeofencingEventType.h"
 #include "url/gurl.h"
 
 namespace content {
 
+namespace {
+
+scoped_refptr<ServiceWorkerContextWrapper> FindServiceWorkerContextOnUIThread(
+    BrowserContext* browser_context,
+    const GURL& service_worker_origin) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

[Michael van Ouwerkerk, 2014/10/08 16:42:00]

Nit: use DCHECK_CURRENTLY_ON here and below.

[Marijn Kruisselbrink, 2014/10/09 22:56:56]

Done.

+  StoragePartition* partition = BrowserContext::GetStoragePartitionForSite(
+      browser_context, service_worker_origin);
+  return static_cast<ServiceWorkerContextWrapper*>(
+      partition->GetServiceWorkerContext());
+}
+
+void FindServiceWorkerRegistration(
+    int64 service_worker_registration_id,
+    const GURL& service_worker_origin,
+    const ServiceWorkerStorage::FindRegistrationCallback& callback,
+    scoped_refptr<ServiceWorkerContextWrapper> service_worker_context) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  service_worker_context->context()->storage()->FindRegistrationForId(
+      service_worker_registration_id, service_worker_origin, callback);
+}
+
+void DeliverGeofencingEventEnd(
+    const scoped_refptr<ServiceWorkerRegistration>& service_worker_registration,
+    ServiceWorkerStatusCode service_worker_status) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  // TODO(mek): log/check result.
+}
+
+void DeliverGeofencingEvent(blink::WebGeofencingEventType event_type,
+                            const std::string& region_id,
+                            const blink::WebCircularGeofencingRegion& region,
+                            ServiceWorkerStatusCode service_worker_status,
+                            const scoped_refptr<ServiceWorkerRegistration>&
+                                service_worker_registration) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  if (service_worker_status == SERVICE_WORKER_OK) {
+    // Hold on to the service worker registration in the callback to keep it
+    // alive until the callback dies. Otherwise the registration could be
+    // released when this method returns - before the event is delivered to the
+    // service worker.
+    base::Callback<void(ServiceWorkerStatusCode)> dispatch_event_callback =
+        base::Bind(&DeliverGeofencingEventEnd, service_worker_registration);
+    service_worker_registration->active_version()->DispatchGeofencingEvent(
+        dispatch_event_callback, event_type, region_id, region);
+  } else {
+    // TODO(mek): no SW, cleanup/logging
+  }
+}
+
+}  // namespace
+
 struct GeofencingManager::RegistrationKey {
   RegistrationKey(BrowserContext* browser_context,
                   int64 service_worker_registration_id,
                   const GURL& service_worker_origin,
                   const std::string& region_id);
 
   BrowserContext* browser_context;
 
   int64 service_worker_registration_id;
   GURL service_worker_origin;
@@ skipping 165 matching lines @@
         registration.key.service_worker_registration_id ==
             service_worker_registration_id &&
         registration.key.service_worker_origin == service_worker_origin &&
         registration.is_active) {
       (*result)[registration.key.region_id] = registration.region;
     }
   }
   return GeofencingStatus::GEOFENCING_STATUS_OK;
 }
 
+void GeofencingManager::RegionEntered(int provider_id) {
+  DispatchGeofencingEvent(blink::WebGeofencingEventTypeEnter, provider_id);
+}
+
+void GeofencingManager::RegionExited(int provider_id) {
+  DispatchGeofencingEvent(blink::WebGeofencingEventTypeLeave, provider_id);
+}
+
 void GeofencingManager::RegisterRegionCompleted(const StatusCallback& callback,
                                                 const RegistrationKey& key,
                                                 GeofencingStatus status,
                                                 int registration_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (status != GEOFENCING_STATUS_OK) {
     ClearRegistration(key);
     callback.Run(status);
     return;
   }
@@ skipping 29 matching lines @@
 }
 
 void GeofencingManager::ClearRegistration(const RegistrationKey& key) {
   std::vector<Registration>::iterator it = std::find_if(
       registrations_.begin(), registrations_.end(), RegistrationMatches(key));
   if (it == registrations_.end())
     return;
   registrations_.erase(it);
 }
 
+GeofencingManager::Registration*
+GeofencingManager::FindRegistrationByProviderId(int provider_id) {
+  for (Registration& registration : registrations_) {
+    if (registration.registration_id == provider_id)
+      return &registration;
+  }
+  return nullptr;
+}
+
+void GeofencingManager::DispatchGeofencingEvent(
+    blink::WebGeofencingEventType event_type,
+    int provider_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  Registration* registration = FindRegistrationByProviderId(provider_id);
+  if (!registration || registration->key.service_worker_registration_id < 0)
+    return;
+
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&FindServiceWorkerContextOnUIThread,
+                 registration->key.browser_context,
+                 registration->key.service_worker_origin),
+      base::Bind(&FindServiceWorkerRegistration,
+                 registration->key.service_worker_registration_id,
+                 registration->key.service_worker_origin,
+                 base::Bind(&DeliverGeofencingEvent,
+                            event_type,
+                            registration->key.region_id,
+                            registration->region)));
+}
+
 }  // namespace content