Remove stl_util's deletion function use from chrome/browser/extensions/api/content_settings.

chrome/browser/extensions/api/content_settings/content_settings_store.cc

 // Copyright (c) 2012 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 "chrome/browser/extensions/api/content_settings/content_settings_store.h"
 
+#include <algorithm>
 #include <memory>
 #include <set>
 #include <utility>
-#include <vector>
 
 #include "base/debug/alias.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
-#include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/content_settings/content_settings_api_constants.h"
 #include "chrome/browser/extensions/api/content_settings/content_settings_helpers.h"
 #include "components/content_settings/core/browser/content_settings_origin_identifier_value_map.h"
 #include "components/content_settings/core/browser/content_settings_rule.h"
 #include "components/content_settings/core/browser/content_settings_utils.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 using content_settings::ConcatenationIterator;
 using content_settings::Rule;
 using content_settings::RuleIterator;
 using content_settings::OriginIdentifierValueMap;
 using content_settings::ResourceIdentifier;
 using content_settings::ValueToContentSetting;
 
 namespace extensions {
 
 namespace helpers = content_settings_helpers;
 namespace keys = content_settings_api_constants;
 
 struct ContentSettingsStore::ExtensionEntry {
-  // Extension id
+  // Extension id.
   std::string id;
+  // Installation time.
+  base::Time install_time;
   // Whether extension is enabled in the profile.
   bool enabled;
   // Content settings.
   OriginIdentifierValueMap settings;
   // Persistent incognito content settings.
   OriginIdentifierValueMap incognito_persistent_settings;
   // Session-only incognito content settings.
   OriginIdentifierValueMap incognito_session_only_settings;
 };
 
 ContentSettingsStore::ContentSettingsStore() {
   DCHECK(OnCorrectThread());
 }
 
 ContentSettingsStore::~ContentSettingsStore() {
-  base::STLDeleteValues(&entries_);
 }
 
 std::unique_ptr<RuleIterator> ContentSettingsStore::GetRuleIterator(
     ContentSettingsType type,
     const content_settings::ResourceIdentifier& identifier,
     bool incognito) const {
   std::vector<std::unique_ptr<RuleIterator>> iterators;
-  // Iterate the extensions based on install time (last installed extensions
-  // first).
-  ExtensionEntryMap::const_reverse_iterator entry_it;
 
   // The individual |RuleIterators| shouldn't lock; pass |lock_| to the
   // |ConcatenationIterator| in a locked state.
   std::unique_ptr<base::AutoLock> auto_lock(new base::AutoLock(lock_));
 
-  for (entry_it = entries_.rbegin(); entry_it != entries_.rend(); ++entry_it) {
-    auto* entry = entry_it->second;
+  // Iterate the extensions based on install time (most-recently installed
+  // items first).
+  for (const auto& entry : entries_) {
     if (!entry->enabled)
       continue;
 
     std::unique_ptr<RuleIterator> rule_it;
     if (incognito) {
       rule_it = entry->incognito_session_only_settings.GetRuleIterator(
           type, identifier, nullptr);
       if (rule_it)
         iterators.push_back(std::move(rule_it));
       rule_it = entry->incognito_persistent_settings.GetRuleIterator(
@@ skipping 37 matching lines @@
   // be masked by another extension.)
   NotifyOfContentSettingChanged(ext_id,
                                 scope != kExtensionPrefsScopeRegular);
 }
 
 void ContentSettingsStore::RegisterExtension(
     const std::string& ext_id,
     const base::Time& install_time,
     bool is_enabled) {
   base::AutoLock lock(lock_);
-  ExtensionEntryMap::iterator i = FindEntry(ext_id);
-  ExtensionEntry* entry;
+  auto i = FindIterator(ext_id);
+  ExtensionEntry* entry = nullptr;
   if (i != entries_.end()) {
-    entry = i->second;
+    entry = i->get();
   } else {
     entry = new ExtensionEntry;
-    entries_.insert(std::make_pair(install_time, entry));
+    entry->install_time = install_time;
+
+    // Insert in reverse-chronological order to maintain the invariant.
+    auto unique_entry = base::WrapUnique(entry);
+    auto location =
+        std::upper_bound(entries_.begin(), entries_.end(), unique_entry,
+                         [](const std::unique_ptr<ExtensionEntry>& a,
+                            const std::unique_ptr<ExtensionEntry>& b) {
+                           return a->install_time > b->install_time;
+                         });
+    entries_.insert(location, std::move(unique_entry));
   }
 
   entry->id = ext_id;
   entry->enabled = is_enabled;
 }
 
 void ContentSettingsStore::UnregisterExtension(
     const std::string& ext_id) {
   bool notify = false;
   bool notify_incognito = false;
   {
     base::AutoLock lock(lock_);
-    ExtensionEntryMap::iterator i = FindEntry(ext_id);
+    auto i = FindIterator(ext_id);
     if (i == entries_.end())
       return;
-    notify = !i->second->settings.empty();
-    notify_incognito = !i->second->incognito_persistent_settings.empty() ||
-                       !i->second->incognito_session_only_settings.empty();
+    notify = !(*i)->settings.empty();
+    notify_incognito = !(*i)->incognito_persistent_settings.empty() ||
+                       !(*i)->incognito_session_only_settings.empty();
 
-    delete i->second;
     entries_.erase(i);
   }
   if (notify)
     NotifyOfContentSettingChanged(ext_id, false);
   if (notify_incognito)
     NotifyOfContentSettingChanged(ext_id, true);
 }
 
 void ContentSettingsStore::SetExtensionState(
     const std::string& ext_id, bool is_enabled) {
   bool notify = false;
   bool notify_incognito = false;
   {
     base::AutoLock lock(lock_);
-    ExtensionEntryMap::const_iterator i = FindEntry(ext_id);
-    if (i == entries_.end())
+    ExtensionEntry* entry = FindEntry(ext_id);
+    if (!entry)
       return;
-    notify = !i->second->settings.empty();
-    notify_incognito = !i->second->incognito_persistent_settings.empty() ||
-                       !i->second->incognito_session_only_settings.empty();
 
-    i->second->enabled = is_enabled;
+    notify = !entry->settings.empty();
+    notify_incognito = !entry->incognito_persistent_settings.empty() ||
+                       !entry->incognito_session_only_settings.empty();
+
+    entry->enabled = is_enabled;
   }
   if (notify)
     NotifyOfContentSettingChanged(ext_id, false);
   if (notify_incognito)
     NotifyOfContentSettingChanged(ext_id, true);
 }
 
 OriginIdentifierValueMap* ContentSettingsStore::GetValueMap(
     const std::string& ext_id,
     ExtensionPrefsScope scope) {
-  ExtensionEntryMap::const_iterator i = FindEntry(ext_id);
-  if (i != entries_.end()) {
-    switch (scope) {
-      case kExtensionPrefsScopeRegular:
-        return &(i->second->settings);
-      case kExtensionPrefsScopeRegularOnly:
-        // TODO(bauerb): Implement regular-only content settings.
-        NOTREACHED();
-        return NULL;
-      case kExtensionPrefsScopeIncognitoPersistent:
-        return &(i->second->incognito_persistent_settings);
-      case kExtensionPrefsScopeIncognitoSessionOnly:
-        return &(i->second->incognito_session_only_settings);
-    }
-  }
-  return NULL;
+  const OriginIdentifierValueMap* result =
+      static_cast<const ContentSettingsStore*>(this)->GetValueMap(ext_id,
+                                                                  scope);
+  return const_cast<OriginIdentifierValueMap*>(result);
 }
 
 const OriginIdentifierValueMap* ContentSettingsStore::GetValueMap(
     const std::string& ext_id,
     ExtensionPrefsScope scope) const {
-  ExtensionEntryMap::const_iterator i = FindEntry(ext_id);
-  if (i == entries_.end())
-    return NULL;
+  ExtensionEntry* entry = FindEntry(ext_id);
+  if (!entry)
+    return nullptr;
 
   switch (scope) {
     case kExtensionPrefsScopeRegular:
-      return &(i->second->settings);
+      return &(entry->settings);
     case kExtensionPrefsScopeRegularOnly:
       // TODO(bauerb): Implement regular-only content settings.
       NOTREACHED();
-      return NULL;
+      return nullptr;
     case kExtensionPrefsScopeIncognitoPersistent:
-      return &(i->second->incognito_persistent_settings);
+      return &(entry->incognito_persistent_settings);
     case kExtensionPrefsScopeIncognitoSessionOnly:
-      return &(i->second->incognito_session_only_settings);
+      return &(entry->incognito_session_only_settings);
   }
 
   NOTREACHED();
-  return NULL;
+  return nullptr;
 }
 
 void ContentSettingsStore::ClearContentSettingsForExtension(
     const std::string& ext_id,
     ExtensionPrefsScope scope) {
   bool notify = false;
   {
     base::AutoLock lock(lock_);
     OriginIdentifierValueMap* map = GetValueMap(ext_id, scope);
     if (!map) {
@@ skipping 128 matching lines @@
   for (auto& observer : observers_)
     observer.OnContentSettingChanged(extension_id, incognito);
 }
 
 bool ContentSettingsStore::OnCorrectThread() {
   // If there is no UI thread, we're most likely in a unit test.
   return !BrowserThread::IsThreadInitialized(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::UI);
 }
 
-ContentSettingsStore::ExtensionEntryMap::iterator
-ContentSettingsStore::FindEntry(const std::string& ext_id) {
-  ExtensionEntryMap::iterator i;
-  for (i = entries_.begin(); i != entries_.end(); ++i) {
-    if (i->second->id == ext_id)
-      return i;
-  }
-  return entries_.end();
+ContentSettingsStore::ExtensionEntry* ContentSettingsStore::FindEntry(
+    const std::string& ext_id) const {
+  auto iter =
+      std::find_if(entries_.begin(), entries_.end(),
+                   [ext_id](const std::unique_ptr<ExtensionEntry>& entry) {
+                     return entry->id == ext_id;
+                   });
+  return iter == entries_.end() ? nullptr : iter->get();
 }
 
-ContentSettingsStore::ExtensionEntryMap::const_iterator
-ContentSettingsStore::FindEntry(const std::string& ext_id) const {
-  ExtensionEntryMap::const_iterator i;
-  for (i = entries_.begin(); i != entries_.end(); ++i) {
-    if (i->second->id == ext_id)
-      return i;
-  }
-  return entries_.end();
+ContentSettingsStore::ExtensionEntries::iterator
+ContentSettingsStore::FindIterator(const std::string& ext_id) {
+  return std::find_if(entries_.begin(), entries_.end(),
+                      [ext_id](const std::unique_ptr<ExtensionEntry>& entry) {
+                        return entry->id == ext_id;
+                      });
 }
 
 }  // namespace extensions