Basic implementation of GeofencingManager class.

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/scoped_ptr.h"
+#include "content/common/content_export.h"
+#include "content/common/geofencing_status.h"
+
+template <typename T>
+struct DefaultSingletonTraits;
+class GURL;
+
+namespace blink {
+struct WebCircularGeofencingRegion;
+};
+
+namespace content {
+
+class BrowserContext;
+class GeofencingProvider;
+
+// 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.
+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
+  // always instantiated on the same thread. Ownership is NOT returned.
+  static GeofencingManager* GetInstance();

[Michael van Ouwerkerk, 2014/10/08 16:59:01]

Why is this class a singleton though? It seems vaguely derived from the
Geolocation system but there it is also a thread, and the reason for that is
that it does horrible things like making blocking dbus calls that can take 3
seconds.

[Marijn Kruisselbrink, 2014/10/08 17:17:09]

I'm not entirely convinced that making this a singleton is indeed the right
choice, although it does make some things easier. There are a couple of things
with geofencing that will require one central place through which all
registrations go though, since for example android limits all of chrome to have
at most 100 registrations. So my idea was that this class takes all the
registrations from all browser contexts/service workers, and does something
clever to decide which geofences to actually register with the underlying
system.
So I'm not ruling out refactoring this at a later point, but for now this seems
to be the clearest way to implement what I'm trying to accomplish.

+
+  // 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,
+                      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.
+  // TODO(mek): Maybe better behavior would be to allow unregistering still
+  //     in-progress registrations.
+  void UnregisterRegion(BrowserContext* browser_context,
+                        int64 service_worker_registration_id,
+                        const GURL& service_worker_origin,
+                        const std::string& region_id,
+                        const StatusCallback& callback);
+
+  // Returns all currently registered regions. In case of failure (no geofencing
+  // provider available for example) return an error status, while leaving
+  // |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);
+
+  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.
+  struct RegistrationKey;
+  struct Registration;
+  class RegistrationMatches;
+
+  // Called by GeofencingProvider when the platform specific provider completes
+  // registration of a geofence.
+  void RegisterRegionCompleted(const StatusCallback& callback,
+                               const RegistrationKey& key,
+                               GeofencingStatus status,
+                               int registration_id);
+
+  // Looks up a particular geofence registration. Returns nullptr if no
+  // registration with the given IDs exists.
+  Registration* FindRegistration(const RegistrationKey& key);
+
+  // 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);
+
+  // 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_