1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
// 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();
// 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_
|
