Remove stl_util's deletion functions from storage/.

storage/browser/quota/storage_monitor.cc

 // 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.
 
 #include "storage/browser/quota/storage_monitor.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 
-#include "base/stl_util.h"
+#include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
 #include "net/base/url_util.h"
 #include "storage/browser/quota/quota_manager.h"
 #include "storage/common/quota/quota_status_code.h"
 
 namespace storage {
 
 // StorageObserverList:
 
 StorageObserverList::ObserverState::ObserverState()
@@ skipping 218 matching lines @@
 }
 
 
 // StorageTypeObservers:
 
 StorageTypeObservers::StorageTypeObservers(QuotaManager* quota_manager)
     : quota_manager_(quota_manager) {
 }
 
 StorageTypeObservers::~StorageTypeObservers() {
-  base::STLDeleteValues(&host_observers_map_);
 }
 
 void StorageTypeObservers::AddObserver(
     StorageObserver* observer, const StorageObserver::MonitorParams& params) {
   std::string host = net::GetHostOrSpecFromURL(params.filter.origin);
   if (host.empty())
     return;
 
-  HostStorageObservers* host_observers = NULL;
-  HostObserversMap::iterator it = host_observers_map_.find(host);
-  if (it == host_observers_map_.end()) {
-    host_observers = new HostStorageObservers(quota_manager_);
-    host_observers_map_[host] = host_observers;
-  } else {
-    host_observers = it->second;
-  }
+  auto& host_observers = host_observers_map_[host];
+  if (!host_observers)

[danakj, 2016/10/03 22:51:49]

Ditto can you comment that there's never a null value in the map?

[Avi (use Gerrit), 2016/10/04 15:56:22]

Again, I don't get it. When we have a key->value map, the values are never null.
Why would I need to comment it?

This is a shortcut; if the operator [] put in a new value, it'll be null, and I
use that to know to insert a new unique_ptr. This code looks to me to be obvious
and not needed of commentary; do you see what I'm doing as unclear? :(

+    host_observers = base::MakeUnique<HostStorageObservers>(quota_manager_);
 
   host_observers->AddObserver(observer, params);
 }
 
 void StorageTypeObservers::RemoveObserver(StorageObserver* observer) {
-  for (HostObserversMap::iterator it = host_observers_map_.begin();
-       it != host_observers_map_.end(); ) {
+  for (auto it = host_observers_map_.begin();
+       it != host_observers_map_.end();) {
     it->second->RemoveObserver(observer);
     if (!it->second->ContainsObservers()) {
-      delete it->second;
-      host_observers_map_.erase(it++);
+      it = host_observers_map_.erase(it);
     } else {
       ++it;
     }
   }
 }
 
 void StorageTypeObservers::RemoveObserverForFilter(
     StorageObserver* observer, const StorageObserver::Filter& filter) {
   std::string host = net::GetHostOrSpecFromURL(filter.origin);
-  HostObserversMap::iterator it = host_observers_map_.find(host);
+  auto it = host_observers_map_.find(host);
   if (it == host_observers_map_.end())
     return;
 
   it->second->RemoveObserver(observer);
-  if (!it->second->ContainsObservers()) {
-    delete it->second;
+  if (!it->second->ContainsObservers())
     host_observers_map_.erase(it);
-  }
 }
 
 const HostStorageObservers* StorageTypeObservers::GetHostObservers(
     const std::string& host) const {
-  HostObserversMap::const_iterator it = host_observers_map_.find(host);
+  auto it = host_observers_map_.find(host);
   if (it != host_observers_map_.end())
-    return it->second;
+    return it->second.get();
 
   return NULL;
 }
 
 void StorageTypeObservers::NotifyUsageChange(
     const StorageObserver::Filter& filter,
     int64_t delta) {
   std::string host = net::GetHostOrSpecFromURL(filter.origin);
-  HostObserversMap::iterator it = host_observers_map_.find(host);
+  auto it = host_observers_map_.find(host);
   if (it == host_observers_map_.end())
     return;
 
   it->second->NotifyUsageChange(filter, delta);
 }
 
 
 // StorageMonitor:
 
 StorageMonitor::StorageMonitor(QuotaManager* quota_manager)
     : quota_manager_(quota_manager) {
 }
 
 StorageMonitor::~StorageMonitor() {
-  base::STLDeleteValues(&storage_type_observers_map_);
 }
 
 void StorageMonitor::AddObserver(
     StorageObserver* observer, const StorageObserver::MonitorParams& params) {
   DCHECK(observer);
 
   // Check preconditions.
   if (params.filter.storage_type == kStorageTypeUnknown ||
       params.filter.storage_type == kStorageTypeQuotaNotManaged ||
       params.filter.origin.is_empty()) {
     NOTREACHED();
     return;
   }
 
-  StorageTypeObservers* type_observers = NULL;
-  StorageTypeObserversMap::iterator it =
-      storage_type_observers_map_.find(params.filter.storage_type);
-  if (it == storage_type_observers_map_.end()) {
-    type_observers = new StorageTypeObservers(quota_manager_);
-    storage_type_observers_map_[params.filter.storage_type] = type_observers;
-  } else {
-    type_observers = it->second;
-  }
+  auto& type_observers =
+      storage_type_observers_map_[params.filter.storage_type];
+  if (!type_observers)

[danakj, 2016/10/03 22:51:49]

dittos

[Avi (use Gerrit), 2016/10/04 15:56:22]

dittos

+    type_observers = base::MakeUnique<StorageTypeObservers>(quota_manager_);
 
   type_observers->AddObserver(observer, params);
 }
 
 void StorageMonitor::RemoveObserver(StorageObserver* observer) {
-  for (StorageTypeObserversMap::iterator it =
-           storage_type_observers_map_.begin();
+  for (auto it = storage_type_observers_map_.begin();
        it != storage_type_observers_map_.end(); ++it) {
     it->second->RemoveObserver(observer);
   }
 }
 
 void StorageMonitor::RemoveObserverForFilter(
     StorageObserver* observer, const StorageObserver::Filter& filter) {
-  StorageTypeObserversMap::iterator it =
-      storage_type_observers_map_.find(filter.storage_type);
+  auto it = storage_type_observers_map_.find(filter.storage_type);
   if (it == storage_type_observers_map_.end())
     return;
 
   it->second->RemoveObserverForFilter(observer, filter);
 }
 
 const StorageTypeObservers* StorageMonitor::GetStorageTypeObservers(
     StorageType storage_type) const {
-  StorageTypeObserversMap::const_iterator it =
-      storage_type_observers_map_.find(storage_type);
+  auto it = storage_type_observers_map_.find(storage_type);
   if (it != storage_type_observers_map_.end())
-    return it->second;
+    return it->second.get();
 
   return NULL;

[danakj, 2016/10/03 22:51:49]

nullptr while you're here?

[Avi (use Gerrit), 2016/10/04 15:56:22]

Done.

 }
 
 void StorageMonitor::NotifyUsageChange(const StorageObserver::Filter& filter,
                                        int64_t delta) {
   // Check preconditions.
   if (filter.storage_type == kStorageTypeUnknown ||
       filter.storage_type == kStorageTypeQuotaNotManaged ||
       filter.origin.is_empty()) {
     NOTREACHED();
     return;
   }
 
-  StorageTypeObserversMap::iterator it =
-      storage_type_observers_map_.find(filter.storage_type);
+  auto it = storage_type_observers_map_.find(filter.storage_type);
   if (it == storage_type_observers_map_.end())
     return;
 
   it->second->NotifyUsageChange(filter, delta);
 }
 
 }  // namespace storage