Use PreloadCheckGroup in ExtensionInstallChecker. Make RequirementsChecker a PreloadCheck.

chrome/browser/extensions/crx_installer.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/extensions/crx_installer.h"
 
 #include <map>
 #include <set>
 #include <utility>
 
@@ skipping 338 matching lines @@
       // manually if they want.
       delete_source_ = false;
       did_handle_successfully_ = false;
 
       return CrxInstallError(
           CrxInstallError::ERROR_OFF_STORE,
           l10n_util::GetStringUTF16(IDS_EXTENSION_INSTALL_DISALLOWED_ON_SITE));
     }
   }
 
-  if (install_checker_.extension()->is_app()) {
+  if (extension->is_app()) {
     // If the app was downloaded, apps_require_extension_mime_type_
     // will be set.  In this case, check that it was served with the
     // right mime type.  Make an exception for file URLs, which come
     // from the users computer and have no headers.
     if (!download_url_.SchemeIsFile() &&
         apps_require_extension_mime_type_ &&
         original_mime_type_ != Extension::kMimeType) {
       return CrxInstallError(l10n_util::GetStringFUTF16(
           IDS_EXTENSION_INSTALL_INCORRECT_APP_CONTENT_TYPE,
           base::ASCIIToUTF16(Extension::kMimeType)));
@@ skipping 12 matching lines @@
             l10n_util::GetStringUTF16(IDS_EXTENSION_WEB_STORE_TITLE)));
       }
 
       // For self-hosted apps, verify that the entire extent is on the same
       // host (or a subdomain of the host) the download happened from.  There's
       // no way for us to verify that the app controls any other hosts.
       URLPattern pattern(UserScript::ValidUserScriptSchemes());
       pattern.SetHost(download_url_.host());
       pattern.SetMatchSubdomains(true);
 
-      URLPatternSet patterns = install_checker_.extension()->web_extent();
+      URLPatternSet patterns = extension->web_extent();
       for (URLPatternSet::const_iterator i = patterns.begin();
            i != patterns.end(); ++i) {
         if (!pattern.MatchesHost(i->host())) {
           return CrxInstallError(l10n_util::GetStringUTF16(
               IDS_EXTENSION_INSTALL_INCORRECT_INSTALL_HOST));
         }
       }
     }
   }
 
@@ skipping 22 matching lines @@
   DCHECK(installer_task_runner_->RunsTasksOnCurrentThread());
 
   UMA_HISTOGRAM_ENUMERATION("Extensions.UnpackSuccessInstallSource",
                             install_source(), Manifest::NUM_LOCATIONS);
 
 
   UMA_HISTOGRAM_ENUMERATION("Extensions.UnpackSuccessInstallCause",
                             install_cause(),
                             extension_misc::NUM_INSTALL_CAUSES);
 
-  install_checker_.set_extension(extension);
+  extension_ = extension;
   temp_dir_ = temp_dir;
   if (!install_icon.empty())
     install_icon_.reset(new SkBitmap(install_icon));
 
   if (original_manifest)
     original_manifest_.reset(new Manifest(
         Manifest::INVALID_LOCATION,
         std::unique_ptr<base::DictionaryValue>(original_manifest->DeepCopy())));
 
   // We don't have to delete the unpack dir explicity since it is a child of
@@ skipping 61 matching lines @@
       }
     }
   }
 
   // Run the policy, requirements and blacklist checks in parallel. Skip the
   // checks if the extension is a bookmark app.
   if (extension()->from_bookmark()) {
     CrxInstaller::OnInstallChecksComplete(0);
   } else {
     install_checker_.Start(
+        extension_,
         ExtensionInstallChecker::CHECK_ALL,
         false /* fail fast */,
         base::Bind(&CrxInstaller::OnInstallChecksComplete, this));
   }
 }
 
 void CrxInstaller::OnInstallChecksComplete(int failed_checks) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!service_weak_)
     return;
 
   // Check for requirement errors.
-  if (!install_checker_.requirement_errors().empty()) {
+  if (!install_checker_.requirement_error_message().empty()) {
     if (error_on_unsupported_requirements_) {
       ReportFailureFromUIThread(
           CrxInstallError(CrxInstallError::ERROR_DECLINED,
-                          base::UTF8ToUTF16(base::JoinString(
-                              install_checker_.requirement_errors(), " "))));
+                          install_checker_.requirement_error_message()));
       return;
     }
     install_flags_ |= kInstallFlagHasRequirementErrors;
   }
 
   // Check the blacklist state.
   if (install_checker_.blacklist_error() == PreloadCheck::BLACKLISTED_ID) {
     install_flags_ |= kInstallFlagIsBlacklistedForMalware;
   }
 
-  if ((install_checker_.blacklist_error() == PreloadCheck::BLACKLISTED_ID ||
-       install_checker_.blacklist_error() ==
-           PreloadCheck::BLACKLISTED_UNKNOWN) &&
+  if (install_checker_.blacklist_error() != PreloadCheck::NONE &&
       !allow_silent_install_) {
     // User tried to install a blacklisted extension. Show an error and
     // refuse to install it.
     ReportFailureFromUIThread(CrxInstallError(
         CrxInstallError::ERROR_DECLINED,
         l10n_util::GetStringFUTF16(IDS_EXTENSION_IS_BLACKLISTED,
                                    base::UTF8ToUTF16(extension()->name()))));
     UMA_HISTOGRAM_ENUMERATION("ExtensionBlacklist.BlockCRX",
                               extension()->location(),
                               Manifest::NUM_LOCATIONS);
     return;
   }
 
   // NOTE: extension may still be blacklisted, but we're forced to silently
   // install it. In this case, ExtensionService::OnExtensionInstalled needs to
   // deal with it.
 
   // Check for policy errors.
   if (!install_checker_.policy_error().empty()) {
     // We don't want to show the error infobar for installs from the WebStore,
     // because the WebStore already shows an error dialog itself.
     // Note: |client_| can be NULL in unit_tests!
     if (extension()->from_webstore() && client_)
       client_->install_ui()->SetSkipPostInstallUI(true);
     ReportFailureFromUIThread(
         CrxInstallError(CrxInstallError::ERROR_DECLINED,
-                        base::UTF8ToUTF16(install_checker_.policy_error())));
+                        install_checker_.policy_error()));
     return;
   }
 
   ConfirmInstall();
 }
 
 void CrxInstaller::ConfirmInstall() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   ExtensionService* service = service_weak_.get();
   if (!service || service->browser_terminating())
     return;
 
-  if (KioskModeInfo::IsKioskOnly(install_checker_.extension().get())) {
+  if (KioskModeInfo::IsKioskOnly(extension())) {
     bool in_kiosk_mode = false;
 #if defined(OS_CHROMEOS)
     user_manager::UserManager* user_manager = user_manager::UserManager::Get();
     in_kiosk_mode = user_manager && user_manager->IsLoggedInAsKioskApp();
 #endif
     if (!in_kiosk_mode) {
       ReportFailureFromUIThread(CrxInstallError(
           CrxInstallError::ERROR_DECLINED,
           l10n_util::GetStringUTF16(IDS_EXTENSION_INSTALL_KIOSK_MODE_ONLY)));
       return;
@@ skipping 118 matching lines @@
 
   // This is lame, but we must reload the extension because absolute paths
   // inside the content scripts are established inside InitFromValue() and we
   // just moved the extension.
   // TODO(aa): All paths to resources inside extensions should be created
   // lazily and based on the Extension's root path at that moment.
   // TODO(rdevlin.cronin): Continue removing std::string errors and replacing
   // with base::string16
   std::string extension_id = extension()->id();
   std::string error;
-  install_checker_.set_extension(
+  extension_ =
       file_util::LoadExtension(
           version_dir,
           install_source_,
           // Note: modified by UpdateCreationFlagsAndCompleteInstall.
           creation_flags_,
-          &error).get());
+          &error).get();
 
   if (extension()) {
     ReportSuccessFromFileThread();
   } else {
     LOG(ERROR) << error << " " << extension_id << " " << download_url_;
     ReportFailureFromFileThread(CrxInstallError(base::UTF8ToUTF16(error)));
   }
 }
 
 void CrxInstaller::ReportFailureFromFileThread(const CrxInstallError& error) {
@@ skipping 167 matching lines @@
         ExtensionInstallPrompt::GetReEnablePromptTypeForExtension(
             service->profile(), extension());
     client_->ShowDialog(base::Bind(&CrxInstaller::OnInstallPromptDone, this),
                         extension(), nullptr,
                         base::MakeUnique<ExtensionInstallPrompt::Prompt>(type),
                         ExtensionInstallPrompt::GetDefaultShowDialogCallback());
   }
 }
 
 }  // namespace extensions