[Extensions] Update extensions UI to observe events and add test

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 <vector>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/browser/background/background_contents.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
-#include "chrome/browser/extensions/error_console/error_console.h"
 #include "chrome/browser/extensions/extension_management.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/extension_ui_util.h"
 #include "chrome/browser/extensions/install_verifier.h"
 #include "chrome/browser/extensions/updater/extension_updater.h"
 #include "chrome/browser/extensions/webstore_reinstaller.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 58 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 ExtensionSettingsHandler::ExtensionSettingsHandler()
     : extension_service_(NULL),
       ignore_notifications_(false),
       deleting_rvh_(NULL),
       deleting_rwh_id_(-1),
       deleting_rph_id_(-1),
       registered_for_notifications_(false),
       warning_service_observer_(this),
-      error_console_observer_(this),
       extension_prefs_observer_(this),
-      extension_registry_observer_(this),
-      extension_management_observer_(this),
-      should_do_verification_check_(false) {
+      extension_management_observer_(this) {
 }
 
 ExtensionSettingsHandler::~ExtensionSettingsHandler() {
 }
 
 // static
 void ExtensionSettingsHandler::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterBooleanPref(
       prefs::kExtensionsUIDeveloperMode,
@@ skipping 244 matching lines @@
       base::Bind(&ExtensionSettingsHandler::HandleAutoUpdateMessage,
                  AsWeakPtr()));
   web_ui()->RegisterMessageCallback("extensionSettingsDismissADTPromo",
       base::Bind(&ExtensionSettingsHandler::HandleDismissADTPromoMessage,
                  AsWeakPtr()));
   web_ui()->RegisterMessageCallback("extensionSettingsShowPath",
       base::Bind(&ExtensionSettingsHandler::HandleShowPath,
                  AsWeakPtr()));
 }
 
-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 33 matching lines @@
        base::MessageLoop::current()->PostTask(
            FROM_HERE,
            base::Bind(&ExtensionSettingsHandler::MaybeUpdateAfterNotification,
                       AsWeakPtr()));
        break;
     default:
       NOTREACHED();
   }
 }
 
-void ExtensionSettingsHandler::OnExtensionLoaded(
-    content::BrowserContext* browser_context,
-    const Extension* extension) {
-  MaybeUpdateAfterNotification();
-}
-
-void ExtensionSettingsHandler::OnExtensionUnloaded(
-    content::BrowserContext* browser_context,
-    const Extension* extension,
-    UnloadedExtensionInfo::Reason reason) {
-  MaybeUpdateAfterNotification();
-}
-
-void ExtensionSettingsHandler::OnExtensionUninstalled(
-    content::BrowserContext* browser_context,
-    const Extension* extension,
-    extensions::UninstallReason reason) {
-  MaybeUpdateAfterNotification();
-}
-
 void ExtensionSettingsHandler::OnExtensionDisableReasonsChanged(
     const std::string& extension_id, int disable_reasons) {
   MaybeUpdateAfterNotification();
 }
 
 void ExtensionSettingsHandler::OnExtensionManagementSettingsChanged() {
   MaybeUpdateAfterNotification();
 }
 
 void ExtensionSettingsHandler::ExtensionWarningsChanged() {
@@ skipping 33 matching lines @@
   bool developer_mode =
       !is_supervised &&
       profile->GetPrefs()->GetBoolean(prefs::kExtensionsUIDeveloperMode);
   results.SetBoolean("profileIsSupervised", is_supervised);
   results.SetBoolean("incognitoAvailable", incognito_available);
   results.SetBoolean("developerMode", developer_mode);
   results.SetBoolean("enableAppInfoDialog", CanShowAppInfoDialog());
 
   // Promote the Chrome Apps & Extensions Developer Tools if they are not
   // installed and the user has not previously dismissed the warning.
+  ExtensionRegistry* registry = ExtensionRegistry::Get(profile);
   bool promote_apps_dev_tools = false;
-  if (!ExtensionRegistry::Get(Profile::FromWebUI(web_ui()))->
-          GetExtensionById(kAppsDeveloperToolsExtensionId,
-                           ExtensionRegistry::EVERYTHING) &&
+  if (!registry->GetExtensionById(kAppsDeveloperToolsExtensionId,
+                                  ExtensionRegistry::EVERYTHING) &&
       !profile->GetPrefs()->GetBoolean(prefs::kExtensionsUIDismissedADTPromo)) {
     promote_apps_dev_tools = true;
   }
   results.SetBoolean("promoteAppsDevTools", promote_apps_dev_tools);
 
   const bool load_unpacked_disabled =
       ExtensionManagementFactory::GetForBrowserContext(profile)
           ->BlacklistedByDefault();
   results.SetBoolean("loadUnpackedDisabled", load_unpacked_disabled);
 
   web_ui()->CallJavascriptFunction(
       "extensions.ExtensionSettings.returnExtensionsData", results);
 
   MaybeRegisterForNotifications();
+
+  scoped_ptr<ExtensionSet> extensions =
+      registry->GenerateInstalledExtensionsSet(ExtensionRegistry::ENABLED |
+                                               ExtensionRegistry::DISABLED |
+                                               ExtensionRegistry::TERMINATED);
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile);
+  bool should_do_verification_check = false;
+  for (const scoped_refptr<const Extension>& extension : *extensions) {
+    if (ui_util::ShouldDisplayInExtensionSettings(extension.get(), profile) &&
+        ((prefs->GetDisableReasons(extension->id()) &
+             Extension::DISABLE_NOT_VERIFIED) != 0)) {

[Dan Beam, 2015/04/06 23:53:12]

nit: don't need the != 0

[Devlin, 2015/04/07 16:07:54]

Last I checked, we do need the != 0 for windows machines.  Dumb, yes, but true.

+      should_do_verification_check = true;
+      break;
+    }

[Dan Beam, 2015/04/06 23:53:12]

nit:

  if (ui_util::ShouldDisplayInExtensionSettings(extension.get(), profile)) {
    int disable_reasons = prefs->GetDisableReasons(extension->id());
    if (disable_reasons & Extension::DISABLE_NOT_VERIFIED) {
      should_do_verification_check = true;
      break;
    }
  }

[Devlin, 2015/04/07 16:07:54]

Okay.

+  }
+
   UMA_HISTOGRAM_BOOLEAN("ExtensionSettings.ShouldDoVerificationCheck",
-                        should_do_verification_check_);
-  if (should_do_verification_check_) {
-    should_do_verification_check_ = false;
-    ExtensionSystem::Get(Profile::FromWebUI(web_ui()))
-        ->install_verifier()
-        ->VerifyAllExtensions();
-  }
+                        should_do_verification_check);
+  if (should_do_verification_check)
+    ExtensionSystem::Get(profile)->install_verifier()->VerifyAllExtensions();
 }
 
 void ExtensionSettingsHandler::HandleToggleDeveloperMode(
     const base::ListValue* args) {
   Profile* profile = Profile::FromWebUI(web_ui());
   if (profile->IsSupervised())
     return;
 
   bool developer_mode_on;
   CHECK(args->GetBoolean(0, &developer_mode_on));
@@ skipping 106 matching lines @@
       this,
       extensions::NOTIFICATION_EXTENSION_BROWSER_ACTION_VISIBILITY_CHANGED,
       content::Source<ExtensionPrefs>(ExtensionPrefs::Get(profile)));
   registrar_.Add(this,
                  extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this,
                  content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
                  content::NotificationService::AllBrowserContextsAndSources());
 
-  extension_registry_observer_.Add(ExtensionRegistry::Get(profile));
-
   content::WebContentsObserver::Observe(web_ui()->GetWebContents());
 
   warning_service_observer_.Add(WarningService::Get(profile));
 
-  error_console_observer_.Add(ErrorConsole::Get(profile));
-
   extension_management_observer_.Add(
       ExtensionManagementFactory::GetForBrowserContext(profile));
 }
 
 void ExtensionSettingsHandler::OnReinstallComplete(
     bool success,
     const std::string& error,
     webstore_install::Result result) {
   MaybeUpdateAfterNotification();
 }
 
 }  // namespace extensions