[Extensions] Update Error Console UI

chrome/browser/extensions/error_console/error_console.cc

 // Copyright 2013 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/error_console/error_console.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 28 matching lines @@
 
 // This is the default mask for which errors to report. That is, if an extension
 // does not have specific preference set, this will be used instead.
 const int kDefaultMask = 0;
 
 const char kAppsDeveloperToolsExtensionId[] =
     "ohmmkhmmmpcnpikjeljgnaoabkaalbgc";
 
 }  // namespace
 
+void ErrorConsole::Observer::OnErrorAdded(const ExtensionError* error) {
+}
+
+void ErrorConsole::Observer::OnErrorsRemoved(
+    const std::set<std::string>& extension_ids) {
+}
+
 void ErrorConsole::Observer::OnErrorConsoleDestroyed() {
 }

[Dan Beam, 2015/04/22 21:02:37]

why not just {} in the .h?  is this preferred for some reason?

[Devlin, 2015/04/22 23:17:31]

I think there was some rule that it was preferred to have virtual functions
declared in the .cc, but we are pretty lax, especially when that rule would mean
adding a new file.  So I pretty much go with whatever the convention in that
file is (and here, it was to put them in the .cc).  I have no preference,
though, so happy to move them if you like.

 
 ErrorConsole::ErrorConsole(Profile* profile)
      : enabled_(false),
        default_mask_(kDefaultMask),
        profile_(profile),
        prefs_(NULL),
        registry_observer_(this) {
   pref_registrar_.Init(profile_->GetPrefs());
   pref_registrar_.Add(prefs::kExtensionsUIDeveloperMode,
                       base::Bind(&ErrorConsole::OnPrefChanged,
@@ skipping 73 matching lines @@
 
   int mask = GetMaskForExtension(error->extension_id());
   if (!(mask & (1 << error->type())))
     return;
 
   const ExtensionError* weak_error = errors_.AddError(error.Pass());
   FOR_EACH_OBSERVER(Observer, observers_, OnErrorAdded(weak_error));
 }
 
 void ErrorConsole::RemoveErrors(const ErrorMap::Filter& filter) {
-  errors_.RemoveErrors(filter);
+  std::set<std::string> affected_ids;
+  errors_.RemoveErrors(filter, &affected_ids);
+  FOR_EACH_OBSERVER(Observer, observers_, OnErrorsRemoved(affected_ids));
 }
 
 const ErrorList& ErrorConsole::GetErrorsForExtension(
     const std::string& extension_id) const {
   return errors_.GetErrorsForExtension(extension_id);
 }
 
 void ErrorConsole::AddObserver(Observer* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   observers_.AddObserver(observer);
@@ skipping 69 matching lines @@
 
 void ErrorConsole::OnExtensionInstalled(
     content::BrowserContext* browser_context,
     const Extension* extension,
     bool is_update) {
   // We don't want to have manifest errors from previous installs. We want
   // to keep runtime errors, though, because extensions are reloaded on a
   // refresh of chrome:extensions, and we don't want to wipe our history
   // whenever that happens.
   errors_.RemoveErrors(ErrorMap::Filter::ErrorsForExtensionWithType(
-      extension->id(), ExtensionError::MANIFEST_ERROR));
+      extension->id(), ExtensionError::MANIFEST_ERROR), nullptr);
   AddManifestErrorsForExtension(extension);
 }
 
 void ErrorConsole::OnExtensionUninstalled(
     content::BrowserContext* browser_context,
     const Extension* extension,
     extensions::UninstallReason reason) {
-  errors_.RemoveErrors(ErrorMap::Filter::ErrorsForExtension(extension->id()));
+  errors_.RemoveErrors(ErrorMap::Filter::ErrorsForExtension(extension->id()),
+                       nullptr);
 }
 
 void ErrorConsole::AddManifestErrorsForExtension(const Extension* extension) {
   const std::vector<InstallWarning>& warnings =
       extension->install_warnings();
   for (std::vector<InstallWarning>::const_iterator iter = warnings.begin();
        iter != warnings.end(); ++iter) {
     ReportError(scoped_ptr<ExtensionError>(new ManifestError(
         extension->id(),
         base::UTF8ToUTF16(iter->message),
         base::UTF8ToUTF16(iter->key),
         base::UTF8ToUTF16(iter->specific))));
   }
 }
 
 void ErrorConsole::Observe(int type,
                            const content::NotificationSource& source,
                            const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_PROFILE_DESTROYED, type);
   Profile* profile = content::Source<Profile>(source).ptr();
   // If incognito profile which we are associated with is destroyed, also
   // destroy all incognito errors.
   if (profile->IsOffTheRecord() && profile_->IsSameProfile(profile))
-    errors_.RemoveErrors(ErrorMap::Filter::IncognitoErrors());
+    errors_.RemoveErrors(ErrorMap::Filter::IncognitoErrors(), nullptr);
 }
 
 int ErrorConsole::GetMaskForExtension(const std::string& extension_id) const {
   // Registered preferences take priority over everything else.
   int pref = 0;
   if (prefs_->ReadPrefAsInteger(extension_id, kStoreExtensionErrorsPref, &pref))
     return pref;
 
   // If the extension is unpacked, we report all error types by default.
   const Extension* extension =
       ExtensionRegistry::Get(profile_)->GetExtensionById(
           extension_id, ExtensionRegistry::EVERYTHING);
   if (extension && extension->location() == Manifest::UNPACKED)
     return (1 << ExtensionError::NUM_ERROR_TYPES) - 1;
 
   // Otherwise, use the default mask.
   return default_mask_;
 }
 
 }  // namespace extensions