Allow re-enabling of DISABLE_NOT_VERIFIED extensions if appropriate

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 154 matching lines @@
 ExtensionSettingsHandler::ExtensionSettingsHandler(ExtensionService* service,
                                                    ManagementPolicy* policy)
     : extension_service_(service),
       management_policy_(policy),
       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) {
+      error_console_observer_(this),
+      should_do_verification_check_(false) {
 }
 
 // static
 void ExtensionSettingsHandler::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterBooleanPref(
       prefs::kExtensionsUIDeveloperMode,
       false,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 }
 
 base::DictionaryValue* ExtensionSettingsHandler::CreateExtensionDetailValue(
     const Extension* extension,
     const std::vector<ExtensionPage>& pages,
     const ExtensionWarningService* warning_service) {
   base::DictionaryValue* extension_data = new base::DictionaryValue();
   bool enabled = extension_service_->IsExtensionEnabled(extension->id());
   GetExtensionBasicInfo(extension, enabled, extension_data);
 
   ExtensionPrefs* prefs = extension_service_->extension_prefs();
   int disable_reasons = prefs->GetDisableReasons(extension->id());
 
   bool suspicious_install =
       (disable_reasons & Extension::DISABLE_NOT_VERIFIED) != 0;
   extension_data->SetBoolean("suspiciousInstall", suspicious_install);
+  if (suspicious_install)
+    should_do_verification_check_ = true;
 
   bool managed_install =
       !management_policy_->UserMayModifySettings(extension, NULL);
   extension_data->SetBoolean("managedInstall", managed_install);
 
   // We should not get into a state where both are true.
   DCHECK(managed_install == false || suspicious_install == false);
 
   GURL icon =
       ExtensionIconSource::GetIconURL(extension,
@@ skipping 513 matching lines @@
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kAppsDevtool));
 
   bool load_unpacked_disabled =
       extension_service_->extension_prefs()->ExtensionsBlacklistedByDefault();
   results.SetBoolean("loadUnpackedDisabled", load_unpacked_disabled);
 
   web_ui()->CallJavascriptFunction(
       "extensions.ExtensionSettings.returnExtensionsData", results);
 
   MaybeRegisterForNotifications();
+  if (should_do_verification_check_) {
+    should_do_verification_check_ = false;
+    extension_service_->VerifyAllExtensions();
+  }

[Finnur, 2013/12/16 14:21:51]

Does this result in HandleRequestExtensionsData getting called again? Or how
does the status change of an extension get reflected? Does the user have to
refresh the page to see the change?

[asargent_no_longer_on_chrome, 2013/12/16 18:47:10]

VerifyAllExtensions will post a task to talk to the server, and that comes back
asynchronously to be handled in ExtensionService::FinishVerifyAllExtensions.
Inside there, if any extensions that are currently disabled with
DISABLE_NOT_VERIFIED actually could be verified, then I send the
NOTIFICATION_EXTENSION_UNLOADED notification which will cause this object to
notice the change and make it possible for the user to enable the item again.
(without them having to manually refresh the page)
 

 }
 
 void ExtensionSettingsHandler::HandleToggleDeveloperMode(
     const base::ListValue* args) {
   Profile* profile = Profile::FromWebUI(web_ui());
   if (profile->IsManaged())
     return;
 
   bool developer_mode =
       !profile->GetPrefs()->GetBoolean(prefs::kExtensionsUIDeveloperMode);
@@ skipping 483 matching lines @@
     extension_service_->EnableExtension(extension_id);
   } else {
     ExtensionErrorReporter::GetInstance()->ReportError(
         UTF8ToUTF16(JoinString(requirement_errors, ' ')),
         true /* be noisy */);
   }
   requirements_checker_.reset();
 }
 
 }  // namespace extensions