Improve error messaging of webRequest API in case of conflicts

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 "base/auto_reset.h"
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/string_util.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/debugger/devtools_window.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_disabled_ui.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
-#include "chrome/browser/extensions/extension_warning_set.h"
 #include "chrome/browser/extensions/lazy_background_task_queue.h"
 #include "chrome/browser/extensions/shell_window_registry.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/extensions/updater/extension_updater.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/managed_mode.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/background_contents.h"
 #include "chrome/browser/ui/browser_finder.h"
@@ skipping 22 matching lines @@
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 
 using content::RenderViewHost;
 using content::WebContents;
 using extensions::Extension;
 using extensions::ExtensionUpdater;
+using extensions::ExtensionWarning;
 using extensions::ManagementPolicy;
 
 ///////////////////////////////////////////////////////////////////////////////
 //
 // ExtensionSettingsHandler
 //
 ///////////////////////////////////////////////////////////////////////////////
 
 ExtensionSettingsHandler::ExtensionSettingsHandler()
     : extension_service_(NULL),
       management_policy_(NULL),
       ignore_notifications_(false),
       deleting_rvh_(NULL),
       registered_for_notifications_(false) {
 }
 
 ExtensionSettingsHandler::~ExtensionSettingsHandler() {
   // 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_)
     load_extension_dialog_->ListenerDestroyed();
 
   registrar_.RemoveAll();
+
+  if (registered_for_notifications_) {
+    Profile* profile = Profile::FromWebUI(web_ui());
+    extensions::ExtensionWarningSet* warnings =
+        extensions::ExtensionSystem::Get(profile)->warning_set();
+    warnings->RemoveObserver(this);
+  }
 }
 
 ExtensionSettingsHandler::ExtensionSettingsHandler(ExtensionService* service,
                                                    ManagementPolicy* policy)
     : extension_service_(service),
       management_policy_(policy),
       ignore_notifications_(false),
       deleting_rvh_(NULL),
       registered_for_notifications_(false) {
 }
 
 // static
 void ExtensionSettingsHandler::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kExtensionsUIDeveloperMode,
                              false,
                              PrefService::SYNCABLE_PREF);
 }
 
 DictionaryValue* ExtensionSettingsHandler::CreateExtensionDetailValue(
     const Extension* extension,
     const std::vector<ExtensionPage>& pages,
-    const ExtensionWarningSet* warnings_set) {
+    const extensions::ExtensionWarningSet* warnings_set) {
   DictionaryValue* extension_data = new DictionaryValue();
   bool enabled = extension_service_->IsExtensionEnabled(extension->id());
   extension->GetBasicInfo(enabled, extension_data);
 
   extension_data->SetBoolean("userModifiable",
       management_policy_->UserMayModifySettings(extension, NULL));
 
   GURL icon =
       ExtensionIconSource::GetIconURL(extension,
                                       extension_misc::EXTENSION_ICON_MEDIUM,
@@ skipping 48 matching lines @@
     view_value->SetInteger("renderProcessId", iter->render_process_id);
     view_value->SetBoolean("incognito", iter->incognito);
     views->Append(view_value);
   }
   extension_data->Set("views", views);
   extension_data->SetBoolean("hasPopupAction",
       extension->browser_action() || extension->page_action());
 
   // Add warnings.
   if (warnings_set) {
-    std::set<ExtensionWarningSet::WarningType> warnings;
-    warnings_set->GetWarningsAffectingExtension(extension->id(), &warnings);
+    std::vector<std::string> warnings;
+    warnings_set->GetWarningMessagesForExtension(extension->id(), &warnings);
 
     if (!warnings.empty()) {
       ListValue* warnings_list = new ListValue;
-      for (std::set<ExtensionWarningSet::WarningType>::const_iterator iter =
-               warnings.begin();
-           iter != warnings.end();
-           ++iter) {
-        string16 warning_string(
-            ExtensionWarningSet::GetLocalizedWarning(*iter));
-        warnings_list->Append(Value::CreateStringValue(warning_string));
+      for (std::vector<std::string>::const_iterator iter = warnings.begin();
+           iter != warnings.end(); ++iter) {
+        warnings_list->Append(Value::CreateStringValue(*iter));
       }
       extension_data->Set("warnings", warnings_list);
     }
   }
 
   // Add install warnings (these are not the same as warnings!).
   if (extension->location() == Extension::LOAD) {
     const Extension::InstallWarningVector& install_warnings =
         extension->install_warnings();
     if (!install_warnings.empty()) {
@@ skipping 203 matching lines @@
     case chrome::NOTIFICATION_BACKGROUND_CONTENTS_NAVIGATED:
     case chrome::NOTIFICATION_EXTENSION_HOST_CREATED:
       source_profile = content::Source<Profile>(source).ptr();
       if (!profile->IsSameProfile(source_profile))
           return;
       MaybeUpdateAfterNotification();
       break;
     case chrome::NOTIFICATION_EXTENSION_LOADED:
     case chrome::NOTIFICATION_EXTENSION_UNLOADED:
     case chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED:
-    case chrome::NOTIFICATION_EXTENSION_WARNING_CHANGED:
     case chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_VISIBILITY_CHANGED:
     case chrome::NOTIFICATION_PREF_CHANGED:
       MaybeUpdateAfterNotification();
       break;
     default:
       NOTREACHED();
   }
 }
 
 void ExtensionSettingsHandler::ExtensionUninstallAccepted() {
@@ skipping 21 matching lines @@
   // There will be no EXTENSION_UNLOADED notification for terminated
   // extensions as they were already unloaded.
   if (was_terminated)
     HandleRequestExtensionsData(NULL);
 }
 
 void ExtensionSettingsHandler::ExtensionUninstallCanceled() {
   extension_id_prompting_ = "";
 }
 
+void ExtensionSettingsHandler::ExtensionWarningsChanged() {
+  MaybeUpdateAfterNotification();
+}
+
 void ExtensionSettingsHandler::ReloadUnpackedExtensions() {
   const ExtensionSet* extensions = extension_service_->extensions();
   std::vector<const Extension*> unpacked_extensions;
   for (ExtensionSet::const_iterator extension = extensions->begin();
        extension != extensions->end(); ++extension) {
     if ((*extension)->location() == Extension::LOAD)
       unpacked_extensions.push_back(*extension);
   }
 
   for (std::vector<const Extension*>::iterator iter =
        unpacked_extensions.begin(); iter != unpacked_extensions.end(); ++iter) {
     extension_service_->ReloadExtension((*iter)->id());
   }
 }
 
 void ExtensionSettingsHandler::HandleRequestExtensionsData(
     const ListValue* args) {
   DictionaryValue results;
 
+  Profile* profile = Profile::FromWebUI(web_ui());
+
   // Add the extensions to the results structure.
   ListValue *extensions_list = new ListValue();
 
-  ExtensionWarningSet* warnings = extension_service_->extension_warnings();
+  extensions::ExtensionWarningSet* warnings =
+      extensions::ExtensionSystem::Get(profile)->warning_set();
 
   const ExtensionSet* extensions = extension_service_->extensions();
   for (ExtensionSet::const_iterator extension = extensions->begin();
        extension != extensions->end(); ++extension) {
     if ((*extension)->ShouldDisplayInExtensionSettings()) {
       extensions_list->Append(CreateExtensionDetailValue(
           *extension,
           GetInspectablePagesForExtension(*extension, true),
           warnings));
     }
@@ skipping 19 matching lines @@
           warnings));
     }
   }
   results.Set("extensions", extensions_list);
 
   if (ManagedMode::IsInManagedMode()) {
     results.SetBoolean("managedMode", true);
     results.SetBoolean("developerMode", false);
   } else {
     results.SetBoolean("managedMode", false);
-  Profile* profile = Profile::FromWebUI(web_ui());
-  bool developer_mode =
-      profile->GetPrefs()->GetBoolean(prefs::kExtensionsUIDeveloperMode);
-  results.SetBoolean("developerMode", developer_mode);
+
+    bool developer_mode =
+        profile->GetPrefs()->GetBoolean(prefs::kExtensionsUIDeveloperMode);
+    results.SetBoolean("developerMode", developer_mode);
   }
 
   bool load_unpacked_disabled =
       extension_service_->extension_prefs()->ExtensionsBlacklistedByDefault();
   results.SetBoolean("loadUnpackedDisabled", load_unpacked_disabled);
 
   web_ui()->CallJavascriptFunction("ExtensionSettings.returnExtensionsData",
                                    results);
   content::WebContentsObserver::Observe(web_ui()->GetWebContents());
 
@@ skipping 240 matching lines @@
   registered_for_notifications_  = true;
   Profile* profile = Profile::FromWebUI(web_ui());
 
   // Register for notifications that we need to reload the page.
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  content::Source<Profile>(profile));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  content::Source<Profile>(profile));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED,
                  content::Source<Profile>(profile));
-  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_WARNING_CHANGED,
-                 content::Source<Profile>(profile));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_CREATED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this,
                  content::NOTIFICATION_RENDER_VIEW_HOST_CREATED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this,
                  content::NOTIFICATION_RENDER_VIEW_HOST_DELETED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this,
                  chrome::NOTIFICATION_BACKGROUND_CONTENTS_NAVIGATED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this,
                  chrome::NOTIFICATION_BACKGROUND_CONTENTS_DELETED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(
       this,
       chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_VISIBILITY_CHANGED,
       content::Source<extensions::ExtensionPrefs>(
           profile->GetExtensionService()->extension_prefs()));
 
+  extensions::ExtensionWarningSet* warnings =
+       extensions::ExtensionSystem::Get(profile)->warning_set();
+  warnings->AddObserver(this);
+
   pref_registrar_.Init(profile->GetPrefs());
   pref_registrar_.Add(prefs::kExtensionInstallDenyList, this);
   local_state_pref_registrar_.Init(g_browser_process->local_state());
   local_state_pref_registrar_.Add(prefs::kInManagedMode, this);
 }
 
 std::vector<ExtensionPage>
 ExtensionSettingsHandler::GetInspectablePagesForExtension(
     const Extension* extension, bool extension_is_enabled) {
   std::vector<ExtensionPage> result;
@@ skipping 102 matching lines @@
     std::vector<std::string> requirement_errors) {
   if (requirement_errors.empty()) {
     extension_service_->EnableExtension(extension_id);
   } else {
     ExtensionErrorReporter::GetInstance()->ReportError(
         UTF8ToUTF16(JoinString(requirement_errors, ' ')),
         true /* be noisy */);
   }
   requirements_checker_.reset();
 }