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_CURRENTLY_ON(BrowserThread::UI);
+  StoragePartition* partition = BrowserContext::GetStoragePartitionForSite(

[michaeln, 2014/10/14 02:20:40]

I don't see how this can be correct?

An app embeds a webview, the webview is isolated from the normal web. The
webview runs content that registers a sw at some origin.

The user browses the normal web and runs content that also registers a sw for
that origin.

This function is called and is given 'origin' as input. What gets returned?

[Marijn Kruisselbrink, 2014/10/14 19:16:55]

Ah yes, you're right of course. That also means that the push messaging code has
the same fundamental problem. There too it is assumed that the combination of
BrowserContext and origin is enough to determine the StoragePartition and
ServiceWorkerContextWrapper to deliver an event to.
I could do an ugly hack and replace every BrowserContext* reference in
GeofencingManager with a StoragePartition*, but maybe it's better to just first
improve/refactor GeofencingManager to add a per-storage-partition geofencing
context, so I think that's what I'll do.

[Marijn Kruisselbrink, 2014/10/15 23:55:15]

Okay, I did this refactoring of GeofencingManager in
https://codereview.chromium.org/645763003/, which now makes all this code local
to a specific StoragePartition. Additionally I rebased this CL on top of
https://codereview.chromium.org/623823002/ (which is rebased on top of the
GeofencingManager refactoring) in an attempt to keep the diffs as sane as
possible.

+      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_CURRENTLY_ON(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_CURRENTLY_ON(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_CURRENTLY_ON(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(

[michaeln, 2014/10/14 02:20:40]

need to be more defensive about active_version() being null, if a registration
occurs during installation there may be no active version

[Marijn Kruisselbrink, 2014/10/14 19:16:55]

Hmm, okay... So what I think should happen if a geofence is registered and
triggered during installation but before activation, it that the geofencing
event gets delivered as soon as the service worker got activated? Is there
currently something I can call on the ServiceWorkerRegistration that will do the
"call this when you have an active version" bit that I need for that?

[falken, 2014/10/15 01:59:34]

I haven't been closely following...

There's a few cases when there won't be an active version:
1) During installation before activation.
2) The browser started with a waiting SW. Currently it won't get activated until
you navigate to a page in its scope.
3) The registration is "dead" with no associated SWs in it (but I think you
wouldn't find the registration in this case).

Also if there's an active version, but also waiting and/or installing versions
in the pipeline, do you want to dispatch the event to those versions also?

You could use SWRegistration AddListener and watch for
OnVersionAttributesChanged events then dispatch the event as appropriate.

[Marijn Kruisselbrink, 2014/10/15 23:55:15]

I'm not sure, I think generally events are only delivered to the active version?
But yes, that all gets a bit confusing when an event is the result of code that
ran in the oninstall event of a new version. For now I've just added a TODO to
figure out how to deal with this in the future.
Okay, thanks.

[falken, 2014/10/16 05:18:18]

TODO sounds good. We sometimes dispatch events to non-active versions: 'install'
and 'activate' (these occur during registration), postMessage can also be done
on non-active versions.

+        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_CURRENTLY_ON(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_CURRENTLY_ON(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