Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(97)

Side by Side Diff: storage/browser/quota/storage_monitor.cc

Issue 2389583002: Remove stl_util's deletion functions from storage/. (Closed)
Patch Set: nits Created 4 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « storage/browser/quota/storage_monitor.h ('k') | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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
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
OLDNEW
« no previous file with comments | « storage/browser/quota/storage_monitor.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698