[Extensions] Update Error Console UI

chrome/browser/extensions/api/developer_private/developer_private_api.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/developer_private/developer_private_api.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
@@ skipping 135 matching lines @@
 
   return render_view_host->GetSiteInstance()->GetSiteURL().host();
 }
 
 void BroadcastItemStateChanged(content::BrowserContext* browser_context,
                                developer::EventType event_type,
                                const std::string& item_id) {
   developer::EventData event_data;
   event_data.event_type = event_type;
   event_data.item_id = item_id;
+  event_data.info =
+      ExtensionInfoGenerator(browser_context).CreateExtensionInfo(item_id);
 
   scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(event_data.ToValue().release());
   scoped_ptr<Event> event(new Event(
       developer_private::OnItemStateChanged::kEventName, args.Pass()));
   EventRouter::Get(browser_context)->BroadcastEvent(event.Pass());
 }
 
 std::string ReadFileToString(const base::FilePath& path) {
   std::string data;
@@ skipping 145 matching lines @@
     extensions::UninstallReason reason) {
   DCHECK(profile_->IsSameProfile(Profile::FromBrowserContext(browser_context)));
   BroadcastItemStateChanged(
       browser_context, developer::EVENT_TYPE_UNINSTALLED, extension->id());
 }
 
 void DeveloperPrivateEventRouter::OnErrorAdded(const ExtensionError* error) {
   // We don't want to handle errors thrown by extensions subscribed to these
   // events (currently only the Apps Developer Tool), because doing so risks
   // entering a loop.
-  if (extension_ids_.find(error->extension_id()) != extension_ids_.end())
+  if (extension_ids_.count(error->extension_id()))
     return;
 
   BroadcastItemStateChanged(
       profile_, developer::EVENT_TYPE_ERROR_ADDED, error->extension_id());
 }
 
+void DeveloperPrivateEventRouter::OnErrorsRemoved(
+    const std::set<std::string>& extension_ids) {
+  for (const std::string& id : extension_ids) {
+    if (!extension_ids_.count(id)) {

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

extension_ids vs extension_ids_ is pretty dubious

maybe |removed| or |removed_ids| instead?

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

Fair, done.

+      BroadcastItemStateChanged(
+          profile_, developer::EVENT_TYPE_ERRORS_REMOVED, id);
+    }
+  }
+}
+
 void DeveloperPrivateAPI::SetLastUnpackedDirectory(const base::FilePath& path) {
   last_unpacked_directory_ = path;
 }
 
 void DeveloperPrivateAPI::RegisterNotifications() {
   EventRouter::Get(profile_)->RegisterObserver(
       this, developer_private::OnItemStateChanged::kEventName);
 }
 
 DeveloperPrivateAPI::~DeveloperPrivateAPI() {}
@@ skipping 71 matching lines @@
 DeveloperPrivateGetExtensionInfoFunction::
 ~DeveloperPrivateGetExtensionInfoFunction() {
 }
 
 ExtensionFunction::ResponseAction
 DeveloperPrivateGetExtensionInfoFunction::Run() {
   scoped_ptr<developer::GetExtensionInfo::Params> params(
       developer::GetExtensionInfo::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  ExtensionRegistry* registry = ExtensionRegistry::Get(browser_context());
-  developer::ExtensionState state = developer::EXTENSION_STATE_ENABLED;
-  const Extension* extension =
-      registry->enabled_extensions().GetByID(params->id);
-  if (!extension &&
-      (extension = registry->disabled_extensions().GetByID(params->id)) !=
-          nullptr) {
-    state = developer::EXTENSION_STATE_DISABLED;
-  } else if (!extension &&
-             (extension =
-                  registry->terminated_extensions().GetByID(params->id)) !=
-                  nullptr) {
-    state = developer::EXTENSION_STATE_TERMINATED;
-  }
+  scoped_ptr<developer::ExtensionInfo> info =
+      ExtensionInfoGenerator(browser_context()).CreateExtensionInfo(params->id);
 
-  if (!extension)
+  if (!info)
     return RespondNow(Error(kNoSuchExtensionError));
 
-  return RespondNow(OneArgument(ExtensionInfoGenerator(browser_context()).
-      CreateExtensionInfo(*extension, state)->ToValue().release()));
+  return RespondNow(OneArgument(info->ToValue().release()));
 }
 
 DeveloperPrivateGetItemsInfoFunction::DeveloperPrivateGetItemsInfoFunction() {}
 DeveloperPrivateGetItemsInfoFunction::~DeveloperPrivateGetItemsInfoFunction() {}
 
 ExtensionFunction::ResponseAction DeveloperPrivateGetItemsInfoFunction::Run() {
   scoped_ptr<developer::GetItemsInfo::Params> params(
       developer::GetItemsInfo::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
@@ skipping 785 matching lines @@
   }
   error_console->RemoveErrors(ErrorMap::Filter(
       properties.extension_id, type, error_ids, false));
 
   return RespondNow(NoArguments());
 }
 
 }  // namespace api
 
 }  // namespace extensions