[Extensions] Update Error Console UI

extensions/browser/error_map.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 "extensions/browser/error_map.h"
 
 #include "base/lazy_instance.h"
 #include "base/stl_util.h"
 
 namespace extensions {
@@ skipping 69 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // ErrorMap::ExtensionEntry
 class ErrorMap::ExtensionEntry {
  public:
   ExtensionEntry();
   ~ExtensionEntry();
 
   // Delete any errors in the entry that match the given ids and type, if
   // provided.
-  void DeleteErrors(const ErrorMap::Filter& filter);
+  // Returns true if any errors were deleted.
+  bool DeleteErrors(const ErrorMap::Filter& filter);
   // Delete all errors in the entry.
   void DeleteAllErrors();
 
   // Add the error to the list, and return a weak reference.
   const ExtensionError* AddError(scoped_ptr<ExtensionError> error);
 
   const ErrorList* list() const { return &list_; }
 
  private:
   // The list of all errors associated with the extension. The errors are
   // owned by the Entry (in turn owned by the ErrorMap) and are deleted upon
   // destruction.
   ErrorList list_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionEntry);
 };
 
 ErrorMap::ExtensionEntry::ExtensionEntry() {
 }
 
 ErrorMap::ExtensionEntry::~ExtensionEntry() {
   DeleteAllErrors();
 }
 
-void ErrorMap::ExtensionEntry::DeleteErrors(const Filter& filter) {
+bool ErrorMap::ExtensionEntry::DeleteErrors(const Filter& filter) {
+  bool deleted = false;
   for (ErrorList::iterator iter = list_.begin(); iter != list_.end();) {
     if (filter.Matches(*iter)) {
       delete *iter;
       iter = list_.erase(iter);
+      deleted = true;
     } else {
       ++iter;
     }
   }
+  return deleted;
 }
 
 void ErrorMap::ExtensionEntry::DeleteAllErrors() {
   STLDeleteContainerPointers(list_.begin(), list_.end());
   list_.clear();
 }
 
 const ExtensionError* ErrorMap::ExtensionEntry::AddError(
     scoped_ptr<ExtensionError> error) {
   for (ErrorList::iterator iter = list_.begin(); iter != list_.end(); ++iter) {
@@ skipping 41 matching lines @@
 
 const ExtensionError* ErrorMap::AddError(scoped_ptr<ExtensionError> error) {
   EntryMap::iterator iter = map_.find(error->extension_id());
   if (iter == map_.end()) {
     iter = map_.insert(std::pair<std::string, ExtensionEntry*>(
         error->extension_id(), new ExtensionEntry)).first;
   }
   return iter->second->AddError(error.Pass());
 }
 
-void ErrorMap::RemoveErrors(const Filter& filter) {
+void ErrorMap::RemoveErrors(const Filter& filter,
+                            std::set<std::string>* affected_ids) {
   if (!filter.restrict_to_extension_id.empty()) {
     EntryMap::iterator iter = map_.find(filter.restrict_to_extension_id);
-    if (iter != map_.end())
-      iter->second->DeleteErrors(filter);
+    if (iter != map_.end()) {
+      if (iter->second->DeleteErrors(filter) && affected_ids)
+        affected_ids->insert(filter.restrict_to_extension_id);
+    }
   } else {
-    for (auto& key_val : map_)
-      key_val.second->DeleteErrors(filter);
+    for (auto& key_val : map_) {
+      if (key_val.second->DeleteErrors(filter) && affected_ids)
+        affected_ids->insert(key_val.first);
+    }
   }
 }
 
 void ErrorMap::RemoveAllErrors() {
   for (EntryMap::iterator iter = map_.begin(); iter != map_.end(); ++iter)
     delete iter->second;
   map_.clear();
 }
 
 }  // namespace extensions