Revert https://codereview.chromium.org/1060993003

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/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"
 #include "chrome/browser/ui/apps/app_info_dialog.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/extensions/app_launch_params.h"
 #include "chrome/browser/ui/extensions/application_launch.h"
 #include "chrome/browser/ui/webui/extensions/extension_basic_info.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/pref_names.h"
@@ skipping 40 matching lines @@
 // ExtensionSettingsHandler
 //
 ///////////////////////////////////////////////////////////////////////////////
 
 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),
       extension_prefs_observer_(this),
       extension_management_observer_(this) {
 }
 
 ExtensionSettingsHandler::~ExtensionSettingsHandler() {
 }
 
 // static
 void ExtensionSettingsHandler::RegisterProfilePrefs(
@@ skipping 209 matching lines @@
     content::NavigationController::ReloadType reload_type) {
   if (reload_type != content::NavigationController::NO_RELOAD)
     ReloadUnpackedExtensions();
 }
 
 void ExtensionSettingsHandler::RegisterMessages() {
   Profile* profile = Profile::FromWebUI(web_ui())->GetOriginalProfile();
   extension_service_ =
       extensions::ExtensionSystem::Get(profile)->extension_service();
 
+  web_ui()->RegisterMessageCallback("extensionSettingsRequestExtensionsData",
+      base::Bind(&ExtensionSettingsHandler::HandleRequestExtensionsData,
+                 AsWeakPtr()));
+  web_ui()->RegisterMessageCallback("extensionSettingsToggleDeveloperMode",
+      base::Bind(&ExtensionSettingsHandler::HandleToggleDeveloperMode,
+                 AsWeakPtr()));
   web_ui()->RegisterMessageCallback("extensionSettingsLaunch",
       base::Bind(&ExtensionSettingsHandler::HandleLaunchMessage,
                  AsWeakPtr()));
   web_ui()->RegisterMessageCallback("extensionSettingsRepair",
       base::Bind(&ExtensionSettingsHandler::HandleRepairMessage,
                  AsWeakPtr()));
   web_ui()->RegisterMessageCallback("extensionSettingsOptions",
       base::Bind(&ExtensionSettingsHandler::HandleOptionsMessage,
                  AsWeakPtr()));
   web_ui()->RegisterMessageCallback("extensionSettingsAutoupdate",
       base::Bind(&ExtensionSettingsHandler::HandleAutoUpdateMessage,
                  AsWeakPtr()));
   web_ui()->RegisterMessageCallback("extensionSettingsShowPath",
       base::Bind(&ExtensionSettingsHandler::HandleShowPath,
                  AsWeakPtr()));
-  web_ui()->RegisterMessageCallback("extensionSettingsRegister",
-      base::Bind(&ExtensionSettingsHandler::HandleRegisterMessage,
-                 AsWeakPtr()));
 }
 
 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
@@ skipping 64 matching lines @@
     if (Manifest::IsUnpackedLocation(extension->location()))
       unpacked_extensions.push_back(extension.get());
   }
 
   for (std::vector<const Extension*>::iterator iter =
        unpacked_extensions.begin(); iter != unpacked_extensions.end(); ++iter) {
     extension_service_->ReloadExtensionWithQuietFailure((*iter)->id());
   }
 }
 
+void ExtensionSettingsHandler::HandleRequestExtensionsData(
+    const base::ListValue* args) {
+  // The items which are to be written into results are also described in
+  // chrome/browser/resources/extensions/extensions.js in @typedef for
+  // ExtensionDataResponse. Please update it whenever you add or remove any keys
+  // here.
+  base::DictionaryValue results;
+
+  Profile* profile = Profile::FromWebUI(web_ui());
+
+  bool is_supervised = profile->IsSupervised();
+  bool incognito_available =
+      IncognitoModePrefs::GetAvailability(profile->GetPrefs()) !=
+          IncognitoModePrefs::DISABLED;
+  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());
+
+  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 =
+      ExtensionRegistry::Get(profile)->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)) {
+      int disable_reasons = prefs->GetDisableReasons(extension->id());
+      if ((disable_reasons & Extension::DISABLE_NOT_VERIFIED)) {
+        should_do_verification_check = true;
+        break;
+      }
+    }
+  }
+
+  UMA_HISTOGRAM_BOOLEAN("ExtensionSettings.ShouldDoVerificationCheck",
+                        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));
+  profile->GetPrefs()->SetBoolean(prefs::kExtensionsUIDeveloperMode,
+                                  developer_mode_on);
+}
+
 void ExtensionSettingsHandler::HandleLaunchMessage(
     const base::ListValue* args) {
   CHECK_EQ(1U, args->GetSize());
   std::string extension_id;
   CHECK(args->GetString(0, &extension_id));
   const Extension* extension =
       extension_service_->GetExtensionById(extension_id, false);
   OpenApplication(AppLaunchParams(extension_service_->profile(), extension,
                                   extensions::LAUNCH_CONTAINER_WINDOW,
                                   NEW_WINDOW,
@@ skipping 40 matching lines @@
   const Extension* extension = registry->GetExtensionById(
       extension_id,
       ExtensionRegistry::EVERYTHING);
   CHECK(extension);
   // We explicitly show manifest.json in order to work around an issue in OSX
   // where opening the directory doesn't focus the Finder.
   platform_util::ShowItemInFolder(profile,
                                   extension->path().Append(kManifestFilename));
 }
 
-void ExtensionSettingsHandler::HandleRegisterMessage(
+const Extension* ExtensionSettingsHandler::GetActiveExtension(
     const base::ListValue* args) {
-  if (!registrar_.IsEmpty())
-    return;  // Only register once.
+  std::string extension_id = base::UTF16ToUTF8(ExtractStringValue(args));
+  CHECK(!extension_id.empty());
+  return extension_service_->GetExtensionById(extension_id, false);
+}
 
+void ExtensionSettingsHandler::MaybeUpdateAfterNotification() {
+  content::WebContents* contents = web_ui()->GetWebContents();
+  if (!ignore_notifications_ && contents && contents->GetRenderViewHost())
+    HandleRequestExtensionsData(NULL);
+  deleting_rvh_ = NULL;
+}
+
+void ExtensionSettingsHandler::MaybeRegisterForNotifications() {
+  if (registered_for_notifications_)
+    return;
+
+  registered_for_notifications_  = true;
   Profile* profile = Profile::FromWebUI(web_ui());
 
   // Register for notifications that we need to reload the page.
   registrar_.Add(this,
                  extensions::NOTIFICATION_EXTENSION_UPDATE_DISABLED,
                  content::Source<Profile>(profile));
   registrar_.Add(this,
                  extensions::NOTIFICATION_EXTENSION_HOST_CREATED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this,
@@ skipping 18 matching lines @@
   warning_service_observer_.Add(WarningService::Get(profile));
 
   extension_management_observer_.Add(
       ExtensionManagementFactory::GetForBrowserContext(profile));
 
   // Clear the preference for the ADT Promo before fully removing it.
   // TODO(devlin): Take this out when everyone's been updated.
   profile->GetPrefs()->ClearPref(prefs::kExtensionsUIDismissedADTPromo);
 }
 
-const Extension* ExtensionSettingsHandler::GetActiveExtension(
-    const base::ListValue* args) {
-  std::string extension_id = base::UTF16ToUTF8(ExtractStringValue(args));
-  CHECK(!extension_id.empty());
-  return extension_service_->GetExtensionById(extension_id, false);
-}
-
-void ExtensionSettingsHandler::MaybeUpdateAfterNotification() {
-  content::WebContents* contents = web_ui()->GetWebContents();
-  if (!ignore_notifications_ && contents && contents->GetRenderViewHost()) {
-    web_ui()->CallJavascriptFunction(
-        "extensions.ExtensionSettings.onExtensionsChanged");
-  }
-  deleting_rvh_ = NULL;
-}
-
 void ExtensionSettingsHandler::OnReinstallComplete(
     bool success,
     const std::string& error,
     webstore_install::Result result) {
   MaybeUpdateAfterNotification();
 }
 
 }  // namespace extensions