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
|
// Copyright (c) 2011 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_GEOLOCATION_NETWORK_LOCATION_PROVIDER_H_
#define CONTENT_BROWSER_GEOLOCATION_NETWORK_LOCATION_PROVIDER_H_
#pragma once
#include <list>
#include <string>
#include "base/basictypes.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/string16.h"
#include "base/threading/thread.h"
#include "content/browser/geolocation/device_data_provider.h"
#include "content/browser/geolocation/location_provider.h"
#include "content/browser/geolocation/network_location_request.h"
#include "content/common/content_export.h"
#include "content/common/geoposition.h"
class URLFetcherProtectEntry;
class NetworkLocationProvider
: public LocationProviderBase,
public RadioDataProvider::ListenerInterface,
public WifiDataProvider::ListenerInterface,
public NetworkLocationRequest::ListenerInterface {
public:
// Cache of recently resolved locations. Public for tests.
class CONTENT_EXPORT PositionCache {
public:
// The maximum size of the cache of positions for previously requested
// device data.
static const size_t kMaximumSize;
PositionCache();
~PositionCache();
// Caches the current position response for the current set of cell ID and
// WiFi data. In the case of the cache exceeding kMaximumSize this will
// evict old entries in FIFO orderer of being added.
// Returns true on success, false otherwise.
bool CachePosition(const WifiData& wifi_data,
const Geoposition& position);
// Searches for a cached position response for the current set of device
// data. Returns NULL if the position is not in the cache, or the cached
// position if available. Ownership remains with the cache.
const Geoposition* FindPosition(const WifiData& wifi_data);
private:
// Makes the key for the map of cached positions, using a set of
// device data. Returns true if a good key was generated, false otherwise.
static bool MakeKey(const WifiData& wifi_data,
string16* key);
// The cache of positions. This is stored as a map keyed on a string that
// represents a set of device data, and a list to provide
// least-recently-added eviction.
typedef std::map<string16, Geoposition> CacheMap;
CacheMap cache_;
typedef std::list<CacheMap::iterator> CacheAgeList;
CacheAgeList cache_age_list_; // Oldest first.
};
NetworkLocationProvider(AccessTokenStore* access_token_store,
net::URLRequestContextGetter* context,
const GURL& url,
const string16& access_token);
virtual ~NetworkLocationProvider();
// LocationProviderBase implementation
virtual bool StartProvider(bool high_accuracy);
virtual void StopProvider();
virtual void GetPosition(Geoposition *position);
virtual void UpdatePosition();
virtual void OnPermissionGranted(const GURL& requesting_frame);
private:
// Satisfies a position request from cache or network.
void RequestPosition();
// Internal helper used by DeviceDataUpdateAvailable
void OnDeviceDataUpdated();
bool IsStarted() const;
// DeviceDataProvider::ListenerInterface implementation.
virtual void DeviceDataUpdateAvailable(RadioDataProvider* provider);
virtual void DeviceDataUpdateAvailable(WifiDataProvider* provider);
// NetworkLocationRequest::ListenerInterface implementation.
virtual void LocationResponseAvailable(const Geoposition& position,
bool server_error,
const string16& access_token,
const RadioData& radio_data,
const WifiData& wifi_data);
scoped_refptr<AccessTokenStore> access_token_store_;
// The device data providers, acquired via global factories.
RadioDataProvider* radio_data_provider_;
WifiDataProvider* wifi_data_provider_;
// The radio and wifi data, flags to indicate if each data set is complete.
RadioData radio_data_;
WifiData wifi_data_;
bool is_radio_data_complete_;
bool is_wifi_data_complete_;
// The timestamp for the latest device data update.
base::Time device_data_updated_timestamp_;
// Cached value loaded from the token store or set by a previous server
// response, and sent in each subsequent network request.
string16 access_token_;
// The current best position estimate.
Geoposition position_;
bool is_new_data_available_;
std::string most_recent_authorized_host_;
// The network location request object, and the url it uses.
scoped_ptr<NetworkLocationRequest> request_;
ScopedRunnableMethodFactory<NetworkLocationProvider> delayed_start_task_;
// The cache of positions.
scoped_ptr<PositionCache> position_cache_;
DISALLOW_COPY_AND_ASSIGN(NetworkLocationProvider);
};
#endif // CONTENT_BROWSER_GEOLOCATION_NETWORK_LOCATION_PROVIDER_H_
|
