OLD | NEW |
| (Empty) |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "content/browser/geolocation/network_location_provider.h" | |
6 | |
7 #include "base/bind.h" | |
8 #include "base/location.h" | |
9 #include "base/single_thread_task_runner.h" | |
10 #include "base/strings/utf_string_conversions.h" | |
11 #include "base/threading/thread_task_runner_handle.h" | |
12 #include "base/time/time.h" | |
13 #include "content/public/browser/access_token_store.h" | |
14 | |
15 namespace content { | |
16 namespace { | |
17 // The maximum period of time we'll wait for a complete set of wifi data | |
18 // before sending the request. | |
19 const int kDataCompleteWaitSeconds = 2; | |
20 } // namespace | |
21 | |
22 // static | |
23 const size_t NetworkLocationProvider::PositionCache::kMaximumSize = 10; | |
24 | |
25 NetworkLocationProvider::PositionCache::PositionCache() {} | |
26 | |
27 NetworkLocationProvider::PositionCache::~PositionCache() {} | |
28 | |
29 bool NetworkLocationProvider::PositionCache::CachePosition( | |
30 const WifiData& wifi_data, | |
31 const Geoposition& position) { | |
32 // Check that we can generate a valid key for the wifi data. | |
33 base::string16 key; | |
34 if (!MakeKey(wifi_data, &key)) { | |
35 return false; | |
36 } | |
37 // If the cache is full, remove the oldest entry. | |
38 if (cache_.size() == kMaximumSize) { | |
39 DCHECK(cache_age_list_.size() == kMaximumSize); | |
40 CacheAgeList::iterator oldest_entry = cache_age_list_.begin(); | |
41 DCHECK(oldest_entry != cache_age_list_.end()); | |
42 cache_.erase(*oldest_entry); | |
43 cache_age_list_.erase(oldest_entry); | |
44 } | |
45 DCHECK_LT(cache_.size(), kMaximumSize); | |
46 // Insert the position into the cache. | |
47 std::pair<CacheMap::iterator, bool> result = | |
48 cache_.insert(std::make_pair(key, position)); | |
49 if (!result.second) { | |
50 NOTREACHED(); // We never try to add the same key twice. | |
51 CHECK_EQ(cache_.size(), cache_age_list_.size()); | |
52 return false; | |
53 } | |
54 cache_age_list_.push_back(result.first); | |
55 DCHECK_EQ(cache_.size(), cache_age_list_.size()); | |
56 return true; | |
57 } | |
58 | |
59 // Searches for a cached position response for the current WiFi data. Returns | |
60 // the cached position if available, nullptr otherwise. | |
61 const Geoposition* NetworkLocationProvider::PositionCache::FindPosition( | |
62 const WifiData& wifi_data) { | |
63 base::string16 key; | |
64 if (!MakeKey(wifi_data, &key)) { | |
65 return nullptr; | |
66 } | |
67 CacheMap::const_iterator iter = cache_.find(key); | |
68 return iter == cache_.end() ? nullptr : &iter->second; | |
69 } | |
70 | |
71 // Makes the key for the map of cached positions, using the available data. | |
72 // Returns true if a good key was generated, false otherwise. | |
73 // | |
74 // static | |
75 bool NetworkLocationProvider::PositionCache::MakeKey( | |
76 const WifiData& wifi_data, | |
77 base::string16* key) { | |
78 // Currently we use only WiFi data and base the key only on the MAC addresses. | |
79 DCHECK(key); | |
80 key->clear(); | |
81 const size_t kCharsPerMacAddress = 6 * 3 + 1; // e.g. "11:22:33:44:55:66|" | |
82 key->reserve(wifi_data.access_point_data.size() * kCharsPerMacAddress); | |
83 const base::string16 separator(base::ASCIIToUTF16("|")); | |
84 for (const auto& access_point_data : wifi_data.access_point_data) { | |
85 *key += separator; | |
86 *key += access_point_data.mac_address; | |
87 *key += separator; | |
88 } | |
89 // If the key is the empty string, return false, as we don't want to cache a | |
90 // position for such data. | |
91 return !key->empty(); | |
92 } | |
93 | |
94 // NetworkLocationProvider factory function | |
95 LocationProviderBase* NewNetworkLocationProvider( | |
96 const scoped_refptr<AccessTokenStore>& access_token_store, | |
97 const scoped_refptr<net::URLRequestContextGetter>& context, | |
98 const GURL& url, | |
99 const base::string16& access_token) { | |
100 return new NetworkLocationProvider( | |
101 access_token_store, context, url, access_token); | |
102 } | |
103 | |
104 // NetworkLocationProvider | |
105 NetworkLocationProvider::NetworkLocationProvider( | |
106 const scoped_refptr<AccessTokenStore>& access_token_store, | |
107 const scoped_refptr<net::URLRequestContextGetter>& url_context_getter, | |
108 const GURL& url, | |
109 const base::string16& access_token) | |
110 : access_token_store_(access_token_store), | |
111 wifi_data_provider_manager_(nullptr), | |
112 wifi_data_update_callback_( | |
113 base::Bind(&NetworkLocationProvider::OnWifiDataUpdate, | |
114 base::Unretained(this))), | |
115 is_wifi_data_complete_(false), | |
116 access_token_(access_token), | |
117 is_permission_granted_(false), | |
118 is_new_data_available_(false), | |
119 position_cache_(new PositionCache), | |
120 weak_factory_(this) { | |
121 request_.reset(new NetworkLocationRequest( | |
122 url_context_getter, | |
123 url, | |
124 base::Bind(&NetworkLocationProvider::OnLocationResponse, | |
125 base::Unretained(this)))); | |
126 } | |
127 | |
128 NetworkLocationProvider::~NetworkLocationProvider() { | |
129 StopProvider(); | |
130 } | |
131 | |
132 // LocationProvider implementation | |
133 void NetworkLocationProvider::GetPosition(Geoposition* position) { | |
134 DCHECK(position); | |
135 *position = position_; | |
136 } | |
137 | |
138 void NetworkLocationProvider::RequestRefresh() { | |
139 // TODO(joth): When called via the public (base class) interface, this should | |
140 // poke each data provider to get them to expedite their next scan. | |
141 // Whilst in the delayed start, only send request if all data is ready. | |
142 // TODO(mcasas): consider not using HasWeakPtrs() https://crbug.com/629158. | |
143 if (!weak_factory_.HasWeakPtrs() || is_wifi_data_complete_) { | |
144 RequestPosition(); | |
145 } | |
146 } | |
147 | |
148 void NetworkLocationProvider::OnPermissionGranted() { | |
149 const bool was_permission_granted = is_permission_granted_; | |
150 is_permission_granted_ = true; | |
151 if (!was_permission_granted && IsStarted()) { | |
152 RequestRefresh(); | |
153 } | |
154 } | |
155 | |
156 void NetworkLocationProvider::OnWifiDataUpdate() { | |
157 DCHECK(wifi_data_provider_manager_); | |
158 is_wifi_data_complete_ = wifi_data_provider_manager_->GetData(&wifi_data_); | |
159 OnWifiDataUpdated(); | |
160 } | |
161 | |
162 void NetworkLocationProvider::OnLocationResponse( | |
163 const Geoposition& position, | |
164 bool server_error, | |
165 const base::string16& access_token, | |
166 const WifiData& wifi_data) { | |
167 DCHECK(CalledOnValidThread()); | |
168 // Record the position and update our cache. | |
169 position_ = position; | |
170 if (position.Validate()) { | |
171 position_cache_->CachePosition(wifi_data, position); | |
172 } | |
173 | |
174 // Record access_token if it's set. | |
175 if (!access_token.empty() && access_token_ != access_token) { | |
176 access_token_ = access_token; | |
177 access_token_store_->SaveAccessToken(request_->url(), access_token); | |
178 } | |
179 | |
180 // Let listeners know that we now have a position available. | |
181 NotifyCallback(position_); | |
182 } | |
183 | |
184 bool NetworkLocationProvider::StartProvider(bool high_accuracy) { | |
185 DCHECK(CalledOnValidThread()); | |
186 if (IsStarted()) | |
187 return true; | |
188 DCHECK(!wifi_data_provider_manager_); | |
189 if (!request_->url().is_valid()) { | |
190 LOG(WARNING) << "StartProvider() : Failed, Bad URL: " | |
191 << request_->url().possibly_invalid_spec(); | |
192 return false; | |
193 } | |
194 | |
195 // Registers a callback with the data provider. The first call to Register | |
196 // will create a singleton data provider and it will be deleted when the last | |
197 // callback is removed with Unregister. | |
198 wifi_data_provider_manager_ = | |
199 WifiDataProviderManager::Register(&wifi_data_update_callback_); | |
200 | |
201 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
202 FROM_HERE, base::Bind(&NetworkLocationProvider::RequestPosition, | |
203 weak_factory_.GetWeakPtr()), | |
204 base::TimeDelta::FromSeconds(kDataCompleteWaitSeconds)); | |
205 // Get the wifi data. | |
206 is_wifi_data_complete_ = wifi_data_provider_manager_->GetData(&wifi_data_); | |
207 if (is_wifi_data_complete_) | |
208 OnWifiDataUpdated(); | |
209 return true; | |
210 } | |
211 | |
212 void NetworkLocationProvider::OnWifiDataUpdated() { | |
213 DCHECK(CalledOnValidThread()); | |
214 wifi_timestamp_ = base::Time::Now(); | |
215 | |
216 is_new_data_available_ = is_wifi_data_complete_; | |
217 RequestRefresh(); | |
218 } | |
219 | |
220 void NetworkLocationProvider::StopProvider() { | |
221 DCHECK(CalledOnValidThread()); | |
222 if (IsStarted()) { | |
223 wifi_data_provider_manager_->Unregister(&wifi_data_update_callback_); | |
224 } | |
225 wifi_data_provider_manager_ = nullptr; | |
226 weak_factory_.InvalidateWeakPtrs(); | |
227 } | |
228 | |
229 // Other methods | |
230 void NetworkLocationProvider::RequestPosition() { | |
231 DCHECK(CalledOnValidThread()); | |
232 if (!is_new_data_available_) | |
233 return; | |
234 | |
235 const Geoposition* cached_position = | |
236 position_cache_->FindPosition(wifi_data_); | |
237 DCHECK(!wifi_timestamp_.is_null()) | |
238 << "Timestamp must be set before looking up position"; | |
239 if (cached_position) { | |
240 DCHECK(cached_position->Validate()); | |
241 // Record the position and update its timestamp. | |
242 position_ = *cached_position; | |
243 // The timestamp of a position fix is determined by the timestamp | |
244 // of the source data update. (The value of position_.timestamp from | |
245 // the cache could be from weeks ago!) | |
246 position_.timestamp = wifi_timestamp_; | |
247 is_new_data_available_ = false; | |
248 // Let listeners know that we now have a position available. | |
249 NotifyCallback(position_); | |
250 return; | |
251 } | |
252 // Don't send network requests until authorized. http://crbug.com/39171 | |
253 if (!is_permission_granted_) | |
254 return; | |
255 | |
256 weak_factory_.InvalidateWeakPtrs(); | |
257 is_new_data_available_ = false; | |
258 | |
259 // TODO(joth): Rather than cancel pending requests, we should create a new | |
260 // NetworkLocationRequest for each and hold a set of pending requests. | |
261 if (request_->is_request_pending()) { | |
262 DVLOG(1) << "NetworkLocationProvider - pre-empting pending network request " | |
263 "with new data. Wifi APs: " | |
264 << wifi_data_.access_point_data.size(); | |
265 } | |
266 request_->MakeRequest(access_token_, wifi_data_, wifi_timestamp_); | |
267 } | |
268 | |
269 bool NetworkLocationProvider::IsStarted() const { | |
270 return wifi_data_provider_manager_ != nullptr; | |
271 } | |
272 | |
273 } // namespace content | |
OLD | NEW |