[Extensions] Update Error Console UI

extensions/browser/error_map_unittest.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/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "components/crx_file/id_util.h"
@@ skipping 33 matching lines @@
   }
 
   // There should only be one entry in the map, since errors are stored in lists
   // keyed by extension id.
   EXPECT_EQ(1u, errors_.size());
 
   EXPECT_EQ(kNumTotalErrors, errors_.GetErrorsForExtension(kId).size());
 
   // Remove the incognito errors; three errors should remain, and all should
   // be from non-incognito contexts.
-  errors_.RemoveErrors(ErrorMap::Filter::IncognitoErrors());
+  std::set<std::string> affected_ids;
+  errors_.RemoveErrors(ErrorMap::Filter::IncognitoErrors(), &affected_ids);
   const ErrorList& list = errors_.GetErrorsForExtension(kId);
   EXPECT_EQ(kNumNonIncognitoErrors, list.size());
   for (size_t i = 0; i < list.size(); ++i)
     EXPECT_FALSE(list[i]->from_incognito());
+  EXPECT_EQ(1u, affected_ids.size());
+  EXPECT_TRUE(affected_ids.count(kId));
 
   // Add another error for a different extension id.
   const std::string kSecondId = crx_file::id_util::GenerateId("id2");
   EXPECT_TRUE(errors_.AddError(CreateNewRuntimeError(kSecondId, "foo")));
 
   // There should be two entries now, one for each id, and there should be one
   // error for the second extension.
   EXPECT_EQ(2u, errors_.size());
   EXPECT_EQ(1u, errors_.GetErrorsForExtension(kSecondId).size());
 
   // Remove all errors for the second id.
-  errors_.RemoveErrors(ErrorMap::Filter::ErrorsForExtension(kSecondId));
+  affected_ids.clear();
+  errors_.RemoveErrors(ErrorMap::Filter::ErrorsForExtension(kSecondId),
+                       &affected_ids);
   EXPECT_EQ(0u, errors_.GetErrorsForExtension(kSecondId).size());
   // First extension should be unaffected.
   EXPECT_EQ(kNumNonIncognitoErrors, errors_.GetErrorsForExtension(kId).size());
+  EXPECT_EQ(1u, affected_ids.size());
+  EXPECT_TRUE(affected_ids.count(kSecondId));
 
   errors_.AddError(CreateNewManifestError(kId, "manifest error"));
   EXPECT_EQ(kNumNonIncognitoErrors + 1,
             errors_.GetErrorsForExtension(kId).size());
   errors_.RemoveErrors(ErrorMap::Filter::ErrorsForExtensionWithType(
-      kId, ExtensionError::MANIFEST_ERROR));
+      kId, ExtensionError::MANIFEST_ERROR), nullptr);
   EXPECT_EQ(kNumNonIncognitoErrors, errors_.GetErrorsForExtension(kId).size());
 
   const ExtensionError* added_error =
       errors_.AddError(CreateNewManifestError(kId, "manifest error2"));
   EXPECT_EQ(kNumNonIncognitoErrors + 1,
             errors_.GetErrorsForExtension(kId).size());
   std::set<int> ids;
   ids.insert(added_error->id());
-  errors_.RemoveErrors(ErrorMap::Filter::ErrorsForExtensionWithIds(kId, ids));
+  errors_.RemoveErrors(ErrorMap::Filter::ErrorsForExtensionWithIds(kId, ids),
+                       nullptr);
   EXPECT_EQ(kNumNonIncognitoErrors, errors_.GetErrorsForExtension(kId).size());
 
   // Remove remaining errors.
   errors_.RemoveAllErrors();
   EXPECT_EQ(0u, errors_.size());
   EXPECT_EQ(0u, errors_.GetErrorsForExtension(kId).size());
 }
 
 // Test that if we add enough errors, only the most recent
 // kMaxErrorsPerExtension are kept.
@@ skipping 52 matching lines @@
   const ErrorList& list = errors_.GetErrorsForExtension(kId);
   ASSERT_EQ(kNumErrors, list.size());
 
   // The duplicate error should be the last reported (pointer comparison)...
   ASSERT_EQ(weak_error, list.back());
   // ... and should have two reported occurrences.
   ASSERT_EQ(2u, list.back()->occurrences());
 }
 
 }  // namespace extensions