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
 //     the IO thread?
 // TODO(mek): Implement some kind of persistence of registrations.
 // TODO(mek): Limit the number of geofences that are registered with the
 //    underlying GeofencingProvider.
+// TODO(mek): Unregister a geofence when the ServiceWorkerRegistration it
+//    belongs to goes away.
+// TODO(mek): If not included in the above, make sure a BrowserContext going
+//    away is also dealt with appropriately.
 class CONTENT_EXPORT GeofencingManager {
  public:
   typedef base::Callback<void(GeofencingStatus)> StatusCallback;
   typedef base::Callback<void(
       GeofencingStatus,
       const std::map<std::string, blink::WebCircularGeofencingRegion>&)>
       RegistrationsCallback;
 
   // Gets a pointer to the singleton instance of the geofencing manager. This
   // must only be called on the IO thread so that the GeofencingManager is
@@ skipping 31 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_