Warn user in case extension delays network traffic too much.

chrome/browser/ui/webui/options/extension_settings_handler.cc

 // Copyright (c) 2011 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/options/extension_settings_handler.h"
 
 #include "base/auto_reset.h"
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 124 matching lines @@
                  base::Unretained(this)));
 }
 
 void ExtensionSettingsHandler::HandleRequestExtensionsData(
     const ListValue* args) {
   DictionaryValue results;
 
   // Add the extensions to the results structure.
   ListValue *extensions_list = new ListValue();
 
+  ExtensionService::ExtensionWarningsType warnings =
+      extension_service_->GetWarnings();
+
   const ExtensionList* extensions = extension_service_->extensions();
   for (ExtensionList::const_iterator extension = extensions->begin();
        extension != extensions->end(); ++extension) {
     if (ShouldShowExtension(*extension)) {
       extensions_list->Append(CreateExtensionDetailValue(
           extension_service_,
           *extension,
           GetActivePagesForExtension(*extension),
+          warnings,
           true, false));  // enabled, terminated
     }
   }
   extensions = extension_service_->disabled_extensions();
   for (ExtensionList::const_iterator extension = extensions->begin();
        extension != extensions->end(); ++extension) {
     if (ShouldShowExtension(*extension)) {
       extensions_list->Append(CreateExtensionDetailValue(
           extension_service_,
           *extension,
           GetActivePagesForExtension(*extension),
+          warnings,
           false, false));  // enabled, terminated
     }
   }
   extensions = extension_service_->terminated_extensions();
   std::vector<ExtensionPage> empty_pages;
   for (ExtensionList::const_iterator extension = extensions->begin();
        extension != extensions->end(); ++extension) {
     if (ShouldShowExtension(*extension)) {
       extensions_list->Append(CreateExtensionDetailValue(
           extension_service_,
           *extension,
           empty_pages,  // Terminated process has no active pages.
+          warnings,
           false, true));  // enabled, terminated
     }
   }
   results.Set("extensions", extensions_list);
 
   Profile* profile = Profile::FromWebUI(web_ui_);
   bool developer_mode =
       profile->GetPrefs()->GetBoolean(prefs::kExtensionsUIDeveloperMode);
   results.SetBoolean("developerMode", developer_mode);
 
@@ skipping 11 matching lines @@
 
   // Register for notifications that we need to reload the page.
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
       NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_PROCESS_CREATED,
       NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
       NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED,
       NotificationService::AllSources());
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_WARNING,
+      NotificationService::AllSources());
   registrar_.Add(this,
       content::NOTIFICATION_NAV_ENTRY_COMMITTED,
       NotificationService::AllSources());
   registrar_.Add(this,
       content::NOTIFICATION_RENDER_VIEW_HOST_CREATED,
       NotificationService::AllSources());
   registrar_.Add(this,
       content::NOTIFICATION_RENDER_VIEW_HOST_DELETED,
       NotificationService::AllSources());
   registrar_.Add(this,
@@ skipping 330 matching lines @@
   localized_strings->SetString("extensionSettingsLoadUnpackedButton",
       l10n_util::GetStringUTF16(IDS_EXTENSIONS_LOAD_UNPACKED_BUTTON));
   localized_strings->SetString("extensionSettingsPackButton",
       l10n_util::GetStringUTF16(IDS_EXTENSIONS_PACK_BUTTON));
   localized_strings->SetString("extensionSettingsUpdateButton",
       l10n_util::GetStringUTF16(IDS_EXTENSIONS_UPDATE_BUTTON));
   localized_strings->SetString("extensionSettingsCrashMessage",
       l10n_util::GetStringUTF16(IDS_EXTENSIONS_CRASHED_EXTENSION));
   localized_strings->SetString("extensionSettingsInDevelopment",
       l10n_util::GetStringUTF16(IDS_EXTENSIONS_IN_DEVELOPMENT));
+  localized_strings->SetString("extensionSettingsWarningsTitle",
+      l10n_util::GetStringUTF16(IDS_EXTENSION_WARNINGS_TITLE));
 }
 
 void ExtensionSettingsHandler::Initialize() {
 }
 
 WebUIMessageHandler* ExtensionSettingsHandler::Attach(WebUI* web_ui) {
   // Call through to superclass.
   WebUIMessageHandler* handler = OptionsPageUIHandler::Attach(web_ui);
 
   extension_service_ = Profile::FromWebUI(web_ui_)
@@ skipping 26 matching lines @@
       MaybeUpdateAfterNotification();
       break;
     case chrome::NOTIFICATION_BACKGROUND_CONTENTS_DELETED:
       deleting_rvh_ = Details<BackgroundContents>(details)->render_view_host();
       MaybeUpdateAfterNotification();
       break;
     case chrome::NOTIFICATION_EXTENSION_LOADED:
     case chrome::NOTIFICATION_EXTENSION_PROCESS_CREATED:
     case chrome::NOTIFICATION_EXTENSION_UNLOADED:
     case chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED:
+    case chrome::NOTIFICATION_EXTENSION_WARNING:
     case content::NOTIFICATION_RENDER_VIEW_HOST_CREATED:
     case content::NOTIFICATION_NAV_ENTRY_COMMITTED:
     case chrome::NOTIFICATION_BACKGROUND_CONTENTS_NAVIGATED:
     case chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_VISIBILITY_CHANGED:
       MaybeUpdateAfterNotification();
       break;
     default:
       NOTREACHED();
   }
 }
 
 const Extension* ExtensionSettingsHandler::GetExtension(const ListValue* args) {
   std::string extension_id = UTF16ToUTF8(ExtractStringValue(args));
   CHECK(!extension_id.empty());
   return extension_service_->GetExtensionById(extension_id, true);
 }
 
 void ExtensionSettingsHandler::MaybeUpdateAfterNotification() {
   TabContents* contents = web_ui_->tab_contents();
   if (!ignore_notifications_ && contents && contents->render_view_host())
     HandleRequestExtensionsData(NULL);
   deleting_rvh_ = NULL;
 }
 
 // Static
+string16 ExtensionSettingsHandler::GetLocalizedWarning(
+    const ExtensionServiceWarning& warning) {
+  switch (warning.warning_type()) {
+  case ExtensionServiceWarning::kInvalid:
+  case ExtensionServiceWarning::kMaxWarningType:
+    NOTREACHED();
+    return string16();
+  case ExtensionServiceWarning::kNetworkDelay:
+    return l10n_util::GetStringFUTF16(
+        IDS_EXTENSION_WARNINGS_NETWORK_DELAY,
+        l10n_util::GetStringUTF16(IDS_PRODUCT_NAME));
+  }
+  return string16();
+}
+
+// Static
 DictionaryValue* ExtensionSettingsHandler::CreateExtensionDetailValue(
     ExtensionService* service, const Extension* extension,
-    const std::vector<ExtensionPage>& pages, bool enabled, bool terminated) {
+    const std::vector<ExtensionPage>& pages,
+    const ExtensionService::ExtensionWarningsType& warnings,
+    bool enabled, bool terminated) {
   DictionaryValue* extension_data = new DictionaryValue();
   GURL icon =
       ExtensionIconSource::GetIconURL(extension,
                                       Extension::EXTENSION_ICON_MEDIUM,
                                       ExtensionIconSet::MATCH_BIGGER,
                                       !enabled, NULL);
   extension_data->SetString("id", extension->id());
   extension_data->SetString("name", extension->name());
   extension_data->SetString("description", extension->description());
   if (extension->location() == Extension::LOAD)
@@ skipping 43 matching lines @@
     view_value->SetInteger("renderViewId", iter->render_view_id);
     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());
   extension_data->SetString("homepageUrl", extension->GetHomepageURL().spec());
 
+  // Add warnings.
+  ListValue* warnings_list = new ListValue;
+  for (ExtensionService::ExtensionWarningsType::const_iterator iter =
+           warnings.begin();
+       iter != warnings.end();
+       ++iter) {
+    if (iter->second.AffectsExtension(extension->id())) {
+      warnings_list->Append(
+          Value::CreateStringValue(GetLocalizedWarning(iter->second)));
+    }
+  }
+  extension_data->Set("warnings", warnings_list);
+
   return extension_data;
 }
 
 std::vector<ExtensionPage> ExtensionSettingsHandler::GetActivePagesForExtension(
     const Extension* extension) {
   std::vector<ExtensionPage> result;
 
   // Get the extension process's active views.
   ExtensionProcessManager* process_manager =
       extension_service_->profile()->GetExtensionProcessManager();
@@ skipping 42 matching lines @@
         continue;
     } else if (!extension->web_extent().MatchesURL(url)) {
       continue;
     }
 
     result->push_back(
         ExtensionPage(url, process->id(), host->routing_id(),
                       process->browser_context()->IsOffTheRecord()));
   }
 }