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 "content/browser/geofencing/geofencing_service.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 {
 
 struct GeofencingManager::Registration {
   Registration(int64 service_worker_registration_id,
                const GURL& service_worker_origin,
                const std::string& region_id,
                const blink::WebCircularGeofencingRegion& region,
                const StatusCallback& callback,
                int64 geofencing_registration_id);
-
   int64 service_worker_registration_id;
   GURL service_worker_origin;
   std::string region_id;
   blink::WebCircularGeofencingRegion region;
 
   // Registration ID as returned by the |GeofencingService|.
   int64 geofencing_registration_id;
 
   // Callback to call when registration is completed. This field is reset when
   // registration is complete.
   StatusCallback registration_callback;
 
   // Returns true if registration has been completed, and thus should be
   // included in calls to GetRegisteredRegions.
   bool is_active() const { return registration_callback.is_null(); }
 };
 
 GeofencingManager::Registration::Registration(
     int64 service_worker_registration_id,
     const GURL& service_worker_origin,
     const std::string& region_id,
     const blink::WebCircularGeofencingRegion& region,
     const GeofencingManager::StatusCallback& callback,
     int64 geofencing_registration_id)
     : service_worker_registration_id(service_worker_registration_id),
+      service_worker_origin(service_worker_origin),
       region_id(region_id),
       region(region),
       geofencing_registration_id(geofencing_registration_id),
       registration_callback(callback) {
 }
 
 GeofencingManager::GeofencingManager(
     const scoped_refptr<ServiceWorkerContextWrapper>& service_worker_context)
     : service_(nullptr), service_worker_context_(service_worker_context) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 160 matching lines @@
   DCHECK(registration);
   DCHECK(!registration->is_active());
   registration->registration_callback.Run(status);
   registration->registration_callback.Reset();
 
   // If the registration wasn't succesful, remove it from our storage.
   if (status != GEOFENCING_STATUS_OK)
     ClearRegistration(registration);
 }
 
+void GeofencingManager::RegionEntered(int64 geofencing_registration_id) {
+  DispatchGeofencingEvent(blink::WebGeofencingEventTypeEnter,
+                          geofencing_registration_id);
+}
+
+void GeofencingManager::RegionExited(int64 geofencing_registration_id) {
+  DispatchGeofencingEvent(blink::WebGeofencingEventTypeLeave,
+                          geofencing_registration_id);
+}
+
 GeofencingManager::Registration* GeofencingManager::FindRegistration(
     int64 service_worker_registration_id,
     const std::string& region_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   ServiceWorkerRegistrationsMap::iterator registrations_iterator =
       registrations_.find(service_worker_registration_id);
   if (registrations_iterator == registrations_.end())
     return nullptr;
   RegionIdRegistrationMap::iterator registration =
       registrations_iterator->second.find(region_id);
@@ skipping 39 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   registrations_by_id_.erase(registration->geofencing_registration_id);
   ServiceWorkerRegistrationsMap::iterator registrations_iterator =
       registrations_.find(registration->service_worker_registration_id);
   DCHECK(registrations_iterator != registrations_.end());
   registrations_iterator->second.erase(registration->region_id);
   if (registrations_iterator->second.empty())
     registrations_.erase(registrations_iterator);
 }
 
+void GeofencingManager::DispatchGeofencingEvent(
+    blink::WebGeofencingEventType event_type,
+    int64 geofencing_registration_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  Registration* registration = FindRegistrationById(geofencing_registration_id);
+  if (!registration ||
+      registration->service_worker_registration_id ==
+          kInvalidServiceWorkerRegistrationId) {
+    // TODO(mek): Log/track these failures.
+    return;
+  }
+
+  service_worker_context_->context()->storage()->FindRegistrationForId(
+      registration->service_worker_registration_id,
+      registration->service_worker_origin,
+      base::Bind(&GeofencingManager::DeliverGeofencingEvent,
+                 this,
+                 event_type,
+                 geofencing_registration_id));
+}
+
+void GeofencingManager::DeliverGeofencingEvent(
+    blink::WebGeofencingEventType event_type,
+    int64 geofencing_registration_id,
+    ServiceWorkerStatusCode service_worker_status,
+    const scoped_refptr<ServiceWorkerRegistration>&
+        service_worker_registration) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  Registration* registration = FindRegistrationById(geofencing_registration_id);
+  if (!registration) {
+    // Geofence got unregistered in the meantime, no longer need to deliver
+    // event.
+    return;
+  }
+
+  if (service_worker_status != SERVICE_WORKER_OK) {
+    // TODO(mek): SW no longer exists, somehow handle this.
+    return;
+  }
+
+  ServiceWorkerVersion* active_version =
+      service_worker_registration->active_version();
+  if (!active_version) {
+    // TODO(mek): No active version, potentially because one is still being
+    //     installed. Handle this somehow.
+    return;
+  }
+
+  // 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(&GeofencingManager::DeliverGeofencingEventEnd,
+                 this,
+                 service_worker_registration);
+  active_version->DispatchGeofencingEvent(dispatch_event_callback,
+                                          event_type,
+                                          registration->region_id,
+                                          registration->region);
+}
+
+void GeofencingManager::DeliverGeofencingEventEnd(
+    const scoped_refptr<ServiceWorkerRegistration>& service_worker_registration,
+    ServiceWorkerStatusCode service_worker_status) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  // TODO(mek): log/check result.
+}
+
 }  // namespace content