Update the CrxInstaller and UnpackedInstaller to use the ExtensionInstallChecker

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 "base/bind.h"
@@ skipping 115 matching lines @@
       apps_require_extension_mime_type_(false),
       allow_silent_install_(false),
       grant_permissions_(true),
       install_cause_(extension_misc::INSTALL_CAUSE_UNSET),
       creation_flags_(Extension::NO_FLAGS),
       off_store_install_allow_reason_(OffStoreInstallDisallowed),
       did_handle_successfully_(true),
       error_on_unsupported_requirements_(false),
       update_from_settings_page_(false),
       install_flags_(kInstallFlagNone),
-      installer_(service_weak->profile()) {
+      install_checker_(service_weak->profile()) {
   installer_task_runner_ = service_weak->GetFileTaskRunner();
   if (!approval)
     return;
 
   CHECK(profile()->IsSameProfile(approval->profile));
   if (client_) {
     client_->install_ui()->SetUseAppInstalledBubble(
         approval->use_app_installed_bubble);
     client_->install_ui()->set_skip_post_install_ui(
         approval->skip_post_install_ui);
@@ skipping 215 matching lines @@
         did_handle_successfully_ = false;
 
         return CrxInstallerError(
             CrxInstallerError::ERROR_OFF_STORE,
             l10n_util::GetStringUTF16(
                 IDS_EXTENSION_INSTALL_DISALLOWED_ON_SITE));
       }
     }
   }
 
-  if (installer_.extension()->is_app()) {
+  if (install_checker_.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 CrxInstallerError(
           l10n_util::GetStringFUTF16(
               IDS_EXTENSION_INSTALL_INCORRECT_APP_CONTENT_TYPE,
@@ skipping 14 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 = installer_.extension()->web_extent();
+      URLPatternSet patterns = install_checker_.extension()->web_extent();
       for (URLPatternSet::const_iterator i = patterns.begin();
            i != patterns.end(); ++i) {
         if (!pattern.MatchesHost(i->host())) {
           return CrxInstallerError(
               l10n_util::GetStringUTF16(
                   IDS_EXTENSION_INSTALL_INCORRECT_INSTALL_HOST));
         }
       }
     }
   }
@@ skipping 23 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);
 
-  installer_.set_extension(extension);
+  install_checker_.set_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,
         scoped_ptr<base::DictionaryValue>(original_manifest->DeepCopy())));
 
   // We don't have to delete the unpack dir explicity since it is a child of
   // the temp dir.
   unpacked_extension_root_ = extension_dir;
 
   CrxInstallerError error = AllowInstall(extension);
   if (error.type() != CrxInstallerError::ERROR_NONE) {
     ReportFailureFromFileThread(error);
     return;
   }
 
-  if (!BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE,
-        base::Bind(&CrxInstaller::CheckImportsAndRequirements, this)))
+  if (!BrowserThread::PostTask(BrowserThread::UI,
+                               FROM_HERE,
+                               base::Bind(&CrxInstaller::CheckInstall, this)))
     NOTREACHED();
 }
 
-void CrxInstaller::CheckImportsAndRequirements() {
+void CrxInstaller::CheckInstall() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   ExtensionService* service = service_weak_.get();
   if (!service || service->browser_terminating())
     return;
 
   if (SharedModuleInfo::ImportsModules(extension())) {
     const std::vector<SharedModuleInfo::ImportInfo>& imports =
         SharedModuleInfo::GetImports(extension());
     std::vector<SharedModuleInfo::ImportInfo>::const_iterator i;
     for (i = imports.begin(); i != imports.end(); ++i) {
@@ skipping 10 matching lines @@
           !SharedModuleInfo::IsExportAllowedByWhitelist(imported_module,
                                                         extension()->id())) {
         ReportFailureFromUIThread(
             CrxInstallerError(l10n_util::GetStringFUTF16(
                 IDS_EXTENSION_INSTALL_DEPENDENCY_NOT_WHITELISTED,
                 base::ASCIIToUTF16(i->extension_id))));
         return;
       }
     }
   }
-  installer_.CheckRequirements(base::Bind(&CrxInstaller::OnRequirementsChecked,
-                                          this));
+
+  // Run the policy, requirements and blacklist checks in parallel.
+  install_checker_.Start(
+      ExtensionInstallChecker::CHECK_ALL,
+      false /* fail fast */,
+      base::Bind(&CrxInstaller::OnInstallChecksComplete, this));
 }
 
-void CrxInstaller::OnRequirementsChecked(
-    std::vector<std::string> requirement_errors) {
+void CrxInstaller::OnInstallChecksComplete(int failed_checks) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!service_weak_)
     return;
 
-  if (!requirement_errors.empty()) {
+  // Check for requirement errors.
+  if (!install_checker_.requirement_errors().empty()) {
     if (error_on_unsupported_requirements_) {
-      ReportFailureFromUIThread(CrxInstallerError(
-          base::UTF8ToUTF16(JoinString(requirement_errors, ' '))));
+      ReportFailureFromUIThread(CrxInstallerError(base::UTF8ToUTF16(
+          JoinString(install_checker_.requirement_errors(), ' '))));
       return;
     }
     install_flags_ |= kInstallFlagHasRequirementErrors;
   }
 
-  ExtensionSystem::Get(profile())->blacklist()->IsBlacklisted(
-      extension()->id(),
-      base::Bind(&CrxInstaller::OnBlacklistChecked, this));
-}
-
-void CrxInstaller::OnBlacklistChecked(
-    extensions::BlacklistState blacklist_state) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (!service_weak_)
-    return;
-
-  if (blacklist_state == extensions::BLACKLISTED_MALWARE) {
+  // Check the blacklist state.
+  if (install_checker_.blacklist_state() == extensions::BLACKLISTED_MALWARE) {
     install_flags_ |= kInstallFlagIsBlacklistedForMalware;
   }
 
-  if ((blacklist_state == extensions::BLACKLISTED_MALWARE ||
-       blacklist_state == extensions::BLACKLISTED_UNKNOWN) &&
+  if ((install_checker_.blacklist_state() == extensions::BLACKLISTED_MALWARE ||
+       install_checker_.blacklist_state() == extensions::BLACKLISTED_UNKNOWN) &&
       !allow_silent_install_) {
     // User tried to install a blacklisted extension. Show an error and
     // refuse to install it.
     ReportFailureFromUIThread(extensions::CrxInstallerError(
         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()->set_skip_post_install_ui(true);
+    ReportFailureFromUIThread(
+        CrxInstallerError(base::UTF8ToUTF16(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(installer_.extension())) {
+  if (KioskModeInfo::IsKioskOnly(install_checker_.extension())) {
     bool in_kiosk_mode = false;
 #if defined(OS_CHROMEOS)
     chromeos::UserManager* user_manager = chromeos::UserManager::Get();
     in_kiosk_mode = user_manager && user_manager->IsLoggedInAsKioskApp();
 #endif
     if (!in_kiosk_mode) {
       ReportFailureFromUIThread(CrxInstallerError(
           l10n_util::GetStringUTF16(
               IDS_EXTENSION_INSTALL_KIOSK_MODE_ONLY)));
       return;
     }
   }
 
-  base::string16 error = installer_.CheckManagementPolicy();
-  if (!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()->set_skip_post_install_ui(true);
-    ReportFailureFromUIThread(CrxInstallerError(error));
-    return;
-  }
-
   // Check whether this install is initiated from the settings page to
   // update an existing extension or app.
   CheckUpdateFromSettingsPage();
 
   GURL overlapping_url;
   const Extension* overlapping_extension =
       service->extensions()->GetHostedAppByOverlappingWebExtent(
           extension()->web_extent());
   if (overlapping_extension &&
       overlapping_extension->id() != extension()->id()) {
@@ skipping 112 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;
-  installer_.set_extension(
+  install_checker_.set_extension(
       file_util::LoadExtension(
           version_dir,
           install_source_,
           extension()->creation_flags() | Extension::REQUIRE_KEY,
           &error).get());
 
   if (extension()) {
     ReportSuccessFromFileThread();
   } else {
     LOG(ERROR) << error << " " << extension_id << " " << download_url_;
@@ skipping 162 matching lines @@
   if (!prefs->DidExtensionEscalatePermissions(extension()->id()))
     return;
 
   if (client_) {
     AddRef();  // Balanced in InstallUIProceed() and InstallUIAbort().
     client_->ConfirmReEnable(this, extension());
   }
 }
 
 }  // namespace extensions