Remove EmptyRuleIterators with nullptrs.

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 <memory>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 44 matching lines @@
   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;
+  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 = entries_.rbegin(); entry != entries_.rend(); ++entry) {
-    if (!entry->second->enabled)
+  for (entry_it = entries_.rbegin(); entry_it != entries_.rend(); ++entry_it) {
+    auto* entry = entry_it->second;
+    if (!entry->enabled)
       continue;
 
+    std::unique_ptr<RuleIterator> rule_it;
     if (incognito) {
-      iterators.push_back(
-          entry->second->incognito_session_only_settings.GetRuleIterator(
-              type,
-              identifier,
-              NULL));
-      iterators.push_back(
-          entry->second->incognito_persistent_settings.GetRuleIterator(
-              type,
-              identifier,
-              NULL));
+      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(
+          type, identifier, nullptr);
+      if (rule_it)
+        iterators.push_back(std::move(rule_it));
     } else {
-      iterators.push_back(
-          entry->second->settings.GetRuleIterator(type, identifier, NULL));
+      rule_it = entry->settings.GetRuleIterator(type, identifier, nullptr);
+      if (rule_it)
+        iterators.push_back(std::move(rule_it));
     }
   }
   return std::unique_ptr<RuleIterator>(
       new ConcatenationIterator(std::move(iterators), auto_lock.release()));

[Bernhard Bauer, 2016/09/08 09:30:31]

You could shortcut here as well and just return nullptr if |iterators| is empty.

[Lei Zhang, 2016/09/08 21:04:29]

Done.

 }
 
 void ContentSettingsStore::SetExtensionContentSetting(
     const std::string& ext_id,
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType type,
     const content_settings::ResourceIdentifier& identifier,
     ContentSetting setting,
     ExtensionPrefsScope scope) {
@@ skipping 141 matching lines @@
     NotifyOfContentSettingChanged(ext_id, scope != kExtensionPrefsScopeRegular);
   }
 }
 
 base::ListValue* ContentSettingsStore::GetSettingsForExtension(
     const std::string& extension_id,
     ExtensionPrefsScope scope) const {
   base::AutoLock lock(lock_);
   const OriginIdentifierValueMap* map = GetValueMap(extension_id, scope);
   if (!map)
-    return NULL;
+    return nullptr;
+
   base::ListValue* settings = new base::ListValue();
-  OriginIdentifierValueMap::EntryMap::const_iterator it;
-  for (it = map->begin(); it != map->end(); ++it) {
-    std::unique_ptr<RuleIterator> rule_iterator(map->GetRuleIterator(
-        it->first.content_type, it->first.resource_identifier,
-        NULL));  // We already hold the lock.
+  for (const auto& it : *map) {
+    const auto& key = it.first;
+    std::unique_ptr<RuleIterator> rule_iterator(
+        map->GetRuleIterator(key.content_type, key.resource_identifier,
+                             nullptr));  // We already hold the lock.
+    if (!rule_iterator)
+      continue;
+
     while (rule_iterator->HasNext()) {
       const Rule& rule = rule_iterator->Next();
       std::unique_ptr<base::DictionaryValue> setting_dict(
           new base::DictionaryValue());
       setting_dict->SetString(keys::kPrimaryPatternKey,
                               rule.primary_pattern.ToString());
       setting_dict->SetString(keys::kSecondaryPatternKey,
                               rule.secondary_pattern.ToString());
       setting_dict->SetString(
           keys::kContentSettingsTypeKey,
-          helpers::ContentSettingsTypeToString(it->first.content_type));
+          helpers::ContentSettingsTypeToString(key.content_type));
       setting_dict->SetString(keys::kResourceIdentifierKey,
-                              it->first.resource_identifier);
+                              key.resource_identifier);
       ContentSetting content_setting = ValueToContentSetting(rule.value.get());
       DCHECK_NE(CONTENT_SETTING_DEFAULT, content_setting);
 
       std::string setting_string =
           content_settings::ContentSettingToString(content_setting);
       DCHECK(!setting_string.empty());
 
       setting_dict->SetString(keys::kContentSettingKey, setting_string);
       settings->Append(std::move(setting_dict));
     }
@@ skipping 88 matching lines @@
 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();
 }
 
 }  // namespace extensions