OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "storage/browser/quota/storage_monitor.h" | 5 #include "storage/browser/quota/storage_monitor.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 | 8 |
9 #include <algorithm> | 9 #include <algorithm> |
10 | 10 |
11 #include "base/stl_util.h" | 11 #include "base/memory/ptr_util.h" |
12 #include "base/trace_event/trace_event.h" | 12 #include "base/trace_event/trace_event.h" |
13 #include "net/base/url_util.h" | 13 #include "net/base/url_util.h" |
14 #include "storage/browser/quota/quota_manager.h" | 14 #include "storage/browser/quota/quota_manager.h" |
15 #include "storage/common/quota/quota_status_code.h" | 15 #include "storage/common/quota/quota_status_code.h" |
16 | 16 |
17 namespace storage { | 17 namespace storage { |
18 | 18 |
19 // StorageObserverList: | 19 // StorageObserverList: |
20 | 20 |
21 StorageObserverList::ObserverState::ObserverState() | 21 StorageObserverList::ObserverState::ObserverState() |
(...skipping 218 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
240 } | 240 } |
241 | 241 |
242 | 242 |
243 // StorageTypeObservers: | 243 // StorageTypeObservers: |
244 | 244 |
245 StorageTypeObservers::StorageTypeObservers(QuotaManager* quota_manager) | 245 StorageTypeObservers::StorageTypeObservers(QuotaManager* quota_manager) |
246 : quota_manager_(quota_manager) { | 246 : quota_manager_(quota_manager) { |
247 } | 247 } |
248 | 248 |
249 StorageTypeObservers::~StorageTypeObservers() { | 249 StorageTypeObservers::~StorageTypeObservers() { |
250 base::STLDeleteValues(&host_observers_map_); | |
251 } | 250 } |
252 | 251 |
253 void StorageTypeObservers::AddObserver( | 252 void StorageTypeObservers::AddObserver( |
254 StorageObserver* observer, const StorageObserver::MonitorParams& params) { | 253 StorageObserver* observer, const StorageObserver::MonitorParams& params) { |
255 std::string host = net::GetHostOrSpecFromURL(params.filter.origin); | 254 std::string host = net::GetHostOrSpecFromURL(params.filter.origin); |
256 if (host.empty()) | 255 if (host.empty()) |
257 return; | 256 return; |
258 | 257 |
259 HostStorageObservers* host_observers = NULL; | 258 auto& host_observers = host_observers_map_[host]; |
260 HostObserversMap::iterator it = host_observers_map_.find(host); | 259 if (!host_observers) { |
261 if (it == host_observers_map_.end()) { | 260 // Because there are no null entries in host_observers_map_, the [] inserted |
262 host_observers = new HostStorageObservers(quota_manager_); | 261 // a blank pointer, so let's populate it. |
263 host_observers_map_[host] = host_observers; | 262 host_observers = base::MakeUnique<HostStorageObservers>(quota_manager_); |
264 } else { | |
265 host_observers = it->second; | |
266 } | 263 } |
267 | 264 |
268 host_observers->AddObserver(observer, params); | 265 host_observers->AddObserver(observer, params); |
269 } | 266 } |
270 | 267 |
271 void StorageTypeObservers::RemoveObserver(StorageObserver* observer) { | 268 void StorageTypeObservers::RemoveObserver(StorageObserver* observer) { |
272 for (HostObserversMap::iterator it = host_observers_map_.begin(); | 269 for (auto it = host_observers_map_.begin(); |
273 it != host_observers_map_.end(); ) { | 270 it != host_observers_map_.end();) { |
274 it->second->RemoveObserver(observer); | 271 it->second->RemoveObserver(observer); |
275 if (!it->second->ContainsObservers()) { | 272 if (!it->second->ContainsObservers()) { |
276 delete it->second; | 273 it = host_observers_map_.erase(it); |
277 host_observers_map_.erase(it++); | |
278 } else { | 274 } else { |
279 ++it; | 275 ++it; |
280 } | 276 } |
281 } | 277 } |
282 } | 278 } |
283 | 279 |
284 void StorageTypeObservers::RemoveObserverForFilter( | 280 void StorageTypeObservers::RemoveObserverForFilter( |
285 StorageObserver* observer, const StorageObserver::Filter& filter) { | 281 StorageObserver* observer, const StorageObserver::Filter& filter) { |
286 std::string host = net::GetHostOrSpecFromURL(filter.origin); | 282 std::string host = net::GetHostOrSpecFromURL(filter.origin); |
287 HostObserversMap::iterator it = host_observers_map_.find(host); | 283 auto it = host_observers_map_.find(host); |
288 if (it == host_observers_map_.end()) | 284 if (it == host_observers_map_.end()) |
289 return; | 285 return; |
290 | 286 |
291 it->second->RemoveObserver(observer); | 287 it->second->RemoveObserver(observer); |
292 if (!it->second->ContainsObservers()) { | 288 if (!it->second->ContainsObservers()) |
293 delete it->second; | |
294 host_observers_map_.erase(it); | 289 host_observers_map_.erase(it); |
295 } | |
296 } | 290 } |
297 | 291 |
298 const HostStorageObservers* StorageTypeObservers::GetHostObservers( | 292 const HostStorageObservers* StorageTypeObservers::GetHostObservers( |
299 const std::string& host) const { | 293 const std::string& host) const { |
300 HostObserversMap::const_iterator it = host_observers_map_.find(host); | 294 auto it = host_observers_map_.find(host); |
301 if (it != host_observers_map_.end()) | 295 if (it != host_observers_map_.end()) |
302 return it->second; | 296 return it->second.get(); |
303 | 297 |
304 return NULL; | 298 return nullptr; |
305 } | 299 } |
306 | 300 |
307 void StorageTypeObservers::NotifyUsageChange( | 301 void StorageTypeObservers::NotifyUsageChange( |
308 const StorageObserver::Filter& filter, | 302 const StorageObserver::Filter& filter, |
309 int64_t delta) { | 303 int64_t delta) { |
310 std::string host = net::GetHostOrSpecFromURL(filter.origin); | 304 std::string host = net::GetHostOrSpecFromURL(filter.origin); |
311 HostObserversMap::iterator it = host_observers_map_.find(host); | 305 auto it = host_observers_map_.find(host); |
312 if (it == host_observers_map_.end()) | 306 if (it == host_observers_map_.end()) |
313 return; | 307 return; |
314 | 308 |
315 it->second->NotifyUsageChange(filter, delta); | 309 it->second->NotifyUsageChange(filter, delta); |
316 } | 310 } |
317 | 311 |
318 | 312 |
319 // StorageMonitor: | 313 // StorageMonitor: |
320 | 314 |
321 StorageMonitor::StorageMonitor(QuotaManager* quota_manager) | 315 StorageMonitor::StorageMonitor(QuotaManager* quota_manager) |
322 : quota_manager_(quota_manager) { | 316 : quota_manager_(quota_manager) { |
323 } | 317 } |
324 | 318 |
325 StorageMonitor::~StorageMonitor() { | 319 StorageMonitor::~StorageMonitor() { |
326 base::STLDeleteValues(&storage_type_observers_map_); | |
327 } | 320 } |
328 | 321 |
329 void StorageMonitor::AddObserver( | 322 void StorageMonitor::AddObserver( |
330 StorageObserver* observer, const StorageObserver::MonitorParams& params) { | 323 StorageObserver* observer, const StorageObserver::MonitorParams& params) { |
331 DCHECK(observer); | 324 DCHECK(observer); |
332 | 325 |
333 // Check preconditions. | 326 // Check preconditions. |
334 if (params.filter.storage_type == kStorageTypeUnknown || | 327 if (params.filter.storage_type == kStorageTypeUnknown || |
335 params.filter.storage_type == kStorageTypeQuotaNotManaged || | 328 params.filter.storage_type == kStorageTypeQuotaNotManaged || |
336 params.filter.origin.is_empty()) { | 329 params.filter.origin.is_empty()) { |
337 NOTREACHED(); | 330 NOTREACHED(); |
338 return; | 331 return; |
339 } | 332 } |
340 | 333 |
341 StorageTypeObservers* type_observers = NULL; | 334 auto& type_observers = |
342 StorageTypeObserversMap::iterator it = | 335 storage_type_observers_map_[params.filter.storage_type]; |
343 storage_type_observers_map_.find(params.filter.storage_type); | 336 if (!type_observers) |
344 if (it == storage_type_observers_map_.end()) { | 337 type_observers = base::MakeUnique<StorageTypeObservers>(quota_manager_); |
345 type_observers = new StorageTypeObservers(quota_manager_); | |
346 storage_type_observers_map_[params.filter.storage_type] = type_observers; | |
347 } else { | |
348 type_observers = it->second; | |
349 } | |
350 | 338 |
351 type_observers->AddObserver(observer, params); | 339 type_observers->AddObserver(observer, params); |
352 } | 340 } |
353 | 341 |
354 void StorageMonitor::RemoveObserver(StorageObserver* observer) { | 342 void StorageMonitor::RemoveObserver(StorageObserver* observer) { |
355 for (StorageTypeObserversMap::iterator it = | 343 for (auto it = storage_type_observers_map_.begin(); |
356 storage_type_observers_map_.begin(); | |
357 it != storage_type_observers_map_.end(); ++it) { | 344 it != storage_type_observers_map_.end(); ++it) { |
358 it->second->RemoveObserver(observer); | 345 it->second->RemoveObserver(observer); |
359 } | 346 } |
360 } | 347 } |
361 | 348 |
362 void StorageMonitor::RemoveObserverForFilter( | 349 void StorageMonitor::RemoveObserverForFilter( |
363 StorageObserver* observer, const StorageObserver::Filter& filter) { | 350 StorageObserver* observer, const StorageObserver::Filter& filter) { |
364 StorageTypeObserversMap::iterator it = | 351 auto it = storage_type_observers_map_.find(filter.storage_type); |
365 storage_type_observers_map_.find(filter.storage_type); | |
366 if (it == storage_type_observers_map_.end()) | 352 if (it == storage_type_observers_map_.end()) |
367 return; | 353 return; |
368 | 354 |
369 it->second->RemoveObserverForFilter(observer, filter); | 355 it->second->RemoveObserverForFilter(observer, filter); |
370 } | 356 } |
371 | 357 |
372 const StorageTypeObservers* StorageMonitor::GetStorageTypeObservers( | 358 const StorageTypeObservers* StorageMonitor::GetStorageTypeObservers( |
373 StorageType storage_type) const { | 359 StorageType storage_type) const { |
374 StorageTypeObserversMap::const_iterator it = | 360 auto it = storage_type_observers_map_.find(storage_type); |
375 storage_type_observers_map_.find(storage_type); | |
376 if (it != storage_type_observers_map_.end()) | 361 if (it != storage_type_observers_map_.end()) |
377 return it->second; | 362 return it->second.get(); |
378 | 363 |
379 return NULL; | 364 return nullptr; |
380 } | 365 } |
381 | 366 |
382 void StorageMonitor::NotifyUsageChange(const StorageObserver::Filter& filter, | 367 void StorageMonitor::NotifyUsageChange(const StorageObserver::Filter& filter, |
383 int64_t delta) { | 368 int64_t delta) { |
384 // Check preconditions. | 369 // Check preconditions. |
385 if (filter.storage_type == kStorageTypeUnknown || | 370 if (filter.storage_type == kStorageTypeUnknown || |
386 filter.storage_type == kStorageTypeQuotaNotManaged || | 371 filter.storage_type == kStorageTypeQuotaNotManaged || |
387 filter.origin.is_empty()) { | 372 filter.origin.is_empty()) { |
388 NOTREACHED(); | 373 NOTREACHED(); |
389 return; | 374 return; |
390 } | 375 } |
391 | 376 |
392 StorageTypeObserversMap::iterator it = | 377 auto it = storage_type_observers_map_.find(filter.storage_type); |
393 storage_type_observers_map_.find(filter.storage_type); | |
394 if (it == storage_type_observers_map_.end()) | 378 if (it == storage_type_observers_map_.end()) |
395 return; | 379 return; |
396 | 380 |
397 it->second->NotifyUsageChange(filter, delta); | 381 it->second->NotifyUsageChange(filter, delta); |
398 } | 382 } |
399 | 383 |
400 } // namespace storage | 384 } // namespace storage |
OLD | NEW |