Chromium side of geofencing event dispatching.

content/browser/geofencing/geofencing_manager.h

 // 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.
 
 #ifndef CONTENT_BROWSER_GEOFENCING_GEOFENCING_MANAGER_H_
 #define CONTENT_BROWSER_GEOFENCING_GEOFENCING_MANAGER_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/callback_forward.h"
 #include "base/macros.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "content/browser/service_worker/service_worker_storage.h"
 #include "content/common/content_export.h"
 #include "content/common/geofencing_status.h"
+#include "content/common/service_worker/service_worker_status_code.h"
 
 template <typename T>
 struct DefaultSingletonTraits;
 class GURL;
 
 namespace blink {
 struct WebCircularGeofencingRegion;
 };
 
 namespace content {
 
 class BrowserContext;
 class GeofencingProvider;
+class ServiceWorkerContextWrapper;
+class ServiceWorkerRegistration;
 
 // This is the main API to the geofencing subsystem. The application will hold
 // a single instance of this class.
 // This class is responsible for keeping track of which geofences are currently
 // registered by websites/workers, persisting this list of registrations and
 // registering a subset of these active registrations with the underlying
 // platform specific |GeofencingProvider| instance.
 // This class lives on the IO thread, and all public methods of it should only
 // ever be called from that same thread.
 // FIXME: Does it make more sense for this to live on the UI thread instead of
@@ skipping 14 matching lines @@
   // always instantiated on the same thread. Ownership is NOT returned.
   static GeofencingManager* GetInstance();
 
   // Initiates registration of a new geofence. StatusCallback is called when
   // registration has completed or failed (which could possibly be before
   // RegisterRegion returns.
   // Attempting to register a region with the same ID as an already registered
   // (or in progress of being registered) region will fail.
   // TODO(mek): Behavior when using an already used ID might need to be revised
   //     depending on what the actual spec ends up saying about this.
   void RegisterRegion(BrowserContext* browser_context,

[michaeln, 2014/10/13 00:22:32]

What if this is an incognito profile?

                       int64 service_worker_registration_id,
                       const GURL& service_worker_origin,
                       const std::string& region_id,
                       const blink::WebCircularGeofencingRegion& region,
                       const StatusCallback& callback);
 
   // Unregister a region that was previously registered by a call to
   // RegisterRegion. Any attempt to unregister a region that has not been
   // registered, or for which the registration is still in progress
   // (RegisterRegion hasn't called its callback yet) will fail.
@@ skipping 10 matching lines @@
   // |regions| untouched.
   // This only returns regions for which the callback passed to RegisterRegion
   // has been called already (so it doesn't include still in progress
   // registrations).
   GeofencingStatus GetRegisteredRegions(
       BrowserContext* browser_context,
       int64 service_worker_registration_id,
       const GURL& service_worker_origin,
       std::map<std::string, blink::WebCircularGeofencingRegion>* regions);
 
+  // To be called by GeofencingProvider
+  void RegionEntered(int provider_id);
+  void RegionExited(int provider_id);
+
   void SetProviderForTests(scoped_ptr<GeofencingProvider> provider);
 
  protected:
   friend struct DefaultSingletonTraits<GeofencingManager>;
   friend class GeofencingManagerTest;
   GeofencingManager();
   virtual ~GeofencingManager();
 
  private:
   // Internal bookkeeping associated with each registered geofence.
@@ skipping 14 matching lines @@
 
   // Registers a new registration, returning a reference to the newly inserted
   // object. Assumes no registration with the same IDs currently exists.
   Registration& AddRegistration(
       const RegistrationKey& key,
       const blink::WebCircularGeofencingRegion& region);
 
   // Clears a registration.
   void ClearRegistration(const RegistrationKey& key);
 
+  // Finds a registration given the ID it is registered with by the provider.
+  Registration* FindRegistrationByProviderId(int provider_id);
+
+  void DispatchGeofencingEvent(blink::WebGeofencingEventType event_type,
+                               int provider_id);
+
   // List of all currently registered geofences.
   // TODO(mek): Better way of storing these that allows more efficient lookup
   //     and deletion.
   std::vector<Registration> registrations_;
 
   scoped_ptr<GeofencingProvider> provider_;
 
   DISALLOW_COPY_AND_ASSIGN(GeofencingManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_GEOFENCING_GEOFENCING_MANAGER_H_