Add UI for RuntimeErrors in the ErrorConsole

chrome/browser/ui/webui/extensions/extension_settings_handler.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/ui/webui/extensions/extension_settings_handler.h"
 
 #include "apps/app_load_service.h"
 #include "apps/app_restore_service.h"
 #include "apps/saved_files_service.h"
 #include "apps/shell_window.h"
@@ skipping 100 matching lines @@
 
 ExtensionSettingsHandler::ExtensionSettingsHandler()
     : extension_service_(NULL),
       management_policy_(NULL),
       ignore_notifications_(false),
       deleting_rvh_(NULL),
       registered_for_notifications_(false),
       rvh_created_callback_(
           base::Bind(&ExtensionSettingsHandler::RenderViewHostCreated,
                      base::Unretained(this))),
-      warning_service_observer_(this) {
+      warning_service_observer_(this),
+      error_console_observer_(this) {
 }
 
 ExtensionSettingsHandler::~ExtensionSettingsHandler() {
   content::RenderViewHost::RemoveCreatedCallback(rvh_created_callback_);
 
   // There may be pending file dialogs, we need to tell them that we've gone
   // away so they don't try and call back to us.
   if (load_extension_dialog_.get())
     load_extension_dialog_->ListenerDestroyed();
 }
 
 ExtensionSettingsHandler::ExtensionSettingsHandler(ExtensionService* service,
                                                    ManagementPolicy* policy)
     : extension_service_(service),
       management_policy_(policy),
       ignore_notifications_(false),
       deleting_rvh_(NULL),
       registered_for_notifications_(false),
-      warning_service_observer_(this) {
+      warning_service_observer_(this),
+      error_console_observer_(this) {
 }
 
 // static
 void ExtensionSettingsHandler::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterBooleanPref(
       prefs::kExtensionsUIDeveloperMode,
       false,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 }
@@ skipping 107 matching lines @@
 
   // If the ErrorConsole is enabled, get the errors for the extension and add
   // them to the list. Otherwise, use the install warnings (using both is
   // redundant).
   ErrorConsole* error_console =
       ErrorConsole::Get(extension_service_->profile());
   if (error_console->enabled()) {
     const ErrorConsole::ErrorList& errors =
         error_console->GetErrorsForExtension(extension->id());
     if (!errors.empty()) {
-      scoped_ptr<ListValue> list(new ListValue);
+      scoped_ptr<ListValue> manifest_errors(new ListValue);
+      scoped_ptr<ListValue> runtime_errors(new ListValue);
       for (ErrorConsole::ErrorList::const_iterator iter = errors.begin();
            iter != errors.end(); ++iter) {
-        list->Append((*iter)->ToValue().release());
+        if ((*iter)->type() == ExtensionError::MANIFEST_ERROR)
+          manifest_errors->Append((*iter)->ToValue().release());
+        else
+          runtime_errors->Append((*iter)->ToValue().release());
       }
-      extension_data->Set("manifestErrors", list.release());
+      if (!manifest_errors->empty())
+        extension_data->Set("manifestErrors", manifest_errors.release());
+      if (!runtime_errors->empty())
+        extension_data->Set("runtimeErrors", runtime_errors.release());
     }
   } else if (Manifest::IsUnpackedLocation(extension->location())) {
     const std::vector<InstallWarning>& install_warnings =
         extension->install_warnings();
     if (!install_warnings.empty()) {
       scoped_ptr<base::ListValue> list(new base::ListValue());
       for (std::vector<InstallWarning>::const_iterator it =
                install_warnings.begin(); it != install_warnings.end(); ++it) {
         base::DictionaryValue* item = new base::DictionaryValue();
         item->SetString("message", it->message);
@@ skipping 189 matching lines @@
                                             void* params) {
   last_unpacked_directory_ = base::FilePath(path);
   UnpackedInstaller::Create(extension_service_)->Load(path);
 }
 
 void ExtensionSettingsHandler::MultiFilesSelected(
     const std::vector<base::FilePath>& files, void* params) {
   NOTREACHED();
 }
 
+void ExtensionSettingsHandler::FileSelectionCanceled(void* params) {
+}
+
+void ExtensionSettingsHandler::OnErrorAdded(const ExtensionError* error) {
+  MaybeUpdateAfterNotification();
+}
+
 void ExtensionSettingsHandler::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   Profile* profile = Profile::FromWebUI(web_ui());
   Profile* source_profile = NULL;
   switch (type) {
     // We listen for notifications that will result in the page being
     // repopulated with data twice for the same event in certain cases.
     // For instance, EXTENSION_LOADED & EXTENSION_HOST_CREATED because
@@ skipping 506 matching lines @@
                  chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED,
                  content::NotificationService::AllBrowserContextsAndSources());
 
   content::RenderViewHost::AddCreatedCallback(rvh_created_callback_);
 
   content::WebContentsObserver::Observe(web_ui()->GetWebContents());
 
   warning_service_observer_.Add(
       ExtensionSystem::Get(profile)->warning_service());
 
+  error_console_observer_.Add(ErrorConsole::Get(profile));
+
   base::Closure callback = base::Bind(
       &ExtensionSettingsHandler::MaybeUpdateAfterNotification,
       base::Unretained(this));
 
   pref_registrar_.Init(profile->GetPrefs());
   pref_registrar_.Add(prefs::kExtensionInstallDenyList, callback);
 }
 
 std::vector<ExtensionPage>
 ExtensionSettingsHandler::GetInspectablePagesForExtension(
@@ skipping 132 matching lines @@
     extension_service_->EnableExtension(extension_id);
   } else {
     ExtensionErrorReporter::GetInstance()->ReportError(
         UTF8ToUTF16(JoinString(requirement_errors, ' ')),
         true /* be noisy */);
   }
   requirements_checker_.reset();
 }
 
 }  // namespace extensions