Use PreloadCheckGroup in ExtensionInstallChecker. Make RequirementsChecker a PreloadCheck.

chrome/browser/extensions/unpacked_installer.cc

 // Copyright (c) 2013 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/unpacked_installer.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_util.h"
-#include "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_install_prompt.h"
 #include "chrome/browser/extensions/extension_management.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/permissions_updater.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/extensions/extension_install_ui_factory.h"
 #include "chrome/common/extensions/api/plugins/plugins_handler.h"
 #include "components/crx_file/id_util.h"
@@ skipping 121 matching lines @@
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
   extension_path_ = base::MakeAbsoluteFilePath(path_in);
 
   if (!IsLoadingUnpackedAllowed()) {
     ReportExtensionLoadError(kUnpackedExtensionsBlacklistedError);
     return false;
   }
 
   std::string error;
-  install_checker_.set_extension(
+  extension_ =
       file_util::LoadExtension(
-          extension_path_, Manifest::COMMAND_LINE, GetFlags(), &error).get());
+          extension_path_, Manifest::COMMAND_LINE, GetFlags(), &error);
 
-  if (!extension() ||
+  if (!extension_ ||
       !extension_l10n_util::ValidateExtensionLocales(
-          extension_path_, extension()->manifest()->value(), &error)) {
+          extension_path_, extension_->manifest()->value(), &error)) {
     ReportExtensionLoadError(error);
     return false;
   }
 
-  if (only_allow_apps && !extension()->is_platform_app()) {
+  if (only_allow_apps && !extension_->is_platform_app()) {
 #if defined(GOOGLE_CHROME_BUILD)
     // Avoid crashing for users with hijacked shortcuts.
     return true;
 #else
     // Defined here to avoid unused variable errors in official builds.
     const char extension_instead_of_app_error[] =
         "App loading flags cannot be used to load extensions. Please use "
         "--load-extension instead.";
     ReportExtensionLoadError(extension_instead_of_app_error);
     return false;
 #endif
   }
 
-  extension()->permissions_data()->BindToCurrentThread();
+  extension_->permissions_data()->BindToCurrentThread();
   PermissionsUpdater(
       service_weak_->profile(), PermissionsUpdater::INIT_FLAG_TRANSIENT)
-      .InitializePermissions(extension());
+      .InitializePermissions(extension_.get());
   ShowInstallPrompt();
 
-  *extension_id = extension()->id();
+  *extension_id = extension_->id();
   return true;
 }
 
 void UnpackedInstaller::ShowInstallPrompt() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!service_weak_.get())
     return;
 
   const ExtensionSet& disabled_extensions =
       ExtensionRegistry::Get(service_weak_->profile())->disabled_extensions();
   if (prompt_for_plugins_ &&
-      PluginInfo::HasPlugins(extension()) &&
-      !disabled_extensions.Contains(extension()->id())) {
+      PluginInfo::HasPlugins(extension_.get()) &&
+      !disabled_extensions.Contains(extension_->id())) {
     SimpleExtensionLoadPrompt* prompt = new SimpleExtensionLoadPrompt(
-        extension(),
+        extension_.get(),
         install_checker_.profile(),
         base::Bind(&UnpackedInstaller::StartInstallChecks, this));
     prompt->ShowPrompt();
     return;
   }
   StartInstallChecks();
 }
 
 void UnpackedInstaller::StartInstallChecks() {
   // TODO(crbug.com/421128): Enable these checks all the time.  The reason
   // they are disabled for extensions loaded from the command-line is that
   // installing unpacked extensions is asynchronous, but there can be
   // dependencies between the extensions loaded by the command line.
-  if (extension()->manifest()->location() != Manifest::COMMAND_LINE) {
+  if (extension_->manifest()->location() != Manifest::COMMAND_LINE) {
     ExtensionService* service = service_weak_.get();
     if (!service || service->browser_terminating())
       return;
 
     // TODO(crbug.com/420147): Move this code to a utility class to avoid
     // duplication of SharedModuleService::CheckImports code.
-    if (SharedModuleInfo::ImportsModules(extension())) {
+    if (SharedModuleInfo::ImportsModules(extension_.get())) {
       const std::vector<SharedModuleInfo::ImportInfo>& imports =
-          SharedModuleInfo::GetImports(extension());
+          SharedModuleInfo::GetImports(extension_.get());
       std::vector<SharedModuleInfo::ImportInfo>::const_iterator i;
       for (i = imports.begin(); i != imports.end(); ++i) {
         base::Version version_required(i->minimum_version);
         const Extension* imported_module =
             service->GetExtensionById(i->extension_id, true);
         if (!imported_module) {
           ReportExtensionLoadError(kImportMissing);
           return;
         } else if (imported_module &&
                    !SharedModuleInfo::IsSharedModule(imported_module)) {
           ReportExtensionLoadError(kImportNotSharedModule);
           return;
         } else if (imported_module && (version_required.IsValid() &&
                                        imported_module->version()->CompareTo(
                                            version_required) < 0)) {
           ReportExtensionLoadError(kImportMinVersionNewer);
           return;
         }
       }
     }
   }
 
   install_checker_.Start(
+      extension_,
       ExtensionInstallChecker::CHECK_REQUIREMENTS |
           ExtensionInstallChecker::CHECK_MANAGEMENT_POLICY,
       true /* fail fast */,
       base::Bind(&UnpackedInstaller::OnInstallChecksComplete, this));
 }
 
 void UnpackedInstaller::OnInstallChecksComplete(int failed_checks) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!install_checker_.policy_error().empty()) {
-    ReportExtensionLoadError(install_checker_.policy_error());
+    ReportExtensionLoadError(
+        base::UTF16ToUTF8(install_checker_.policy_error()));
     return;
   }
 
-  if (!install_checker_.requirement_errors().empty()) {
+  if (!install_checker_.requirement_error_message().empty()) {
     ReportExtensionLoadError(
-        base::JoinString(install_checker_.requirement_errors(), " "));
+        base::UTF16ToUTF8(install_checker_.requirement_error_message()));
     return;
   }
 
   InstallExtension();
 }
 
 int UnpackedInstaller::GetFlags() {
   std::string id = crx_file::id_util::GenerateIdForPath(extension_path_);
   bool allow_file_access =
       Manifest::ShouldAlwaysAllowFileAccess(Manifest::UNPACKED);
@@ skipping 50 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&UnpackedInstaller::LoadWithFileAccess, this, GetFlags()));
 }
 
 void UnpackedInstaller::LoadWithFileAccess(int flags) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   std::string error;
-  install_checker_.set_extension(
+  extension_ =
       file_util::LoadExtension(
-          extension_path_, Manifest::UNPACKED, flags, &error).get());
+          extension_path_, Manifest::UNPACKED, flags, &error);
 
-  if (!extension() ||
+  if (!extension_ ||
       !extension_l10n_util::ValidateExtensionLocales(
-          extension_path_, extension()->manifest()->value(), &error)) {
+          extension_path_, extension_->manifest()->value(), &error)) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&UnpackedInstaller::ReportExtensionLoadError, this, error));
     return;
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
@@ skipping 19 matching lines @@
 
 void UnpackedInstaller::InstallExtension() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!service_weak_.get()) {
     callback_.Reset();
     return;
   }
 
   PermissionsUpdater perms_updater(service_weak_->profile());
-  perms_updater.InitializePermissions(extension());
-  perms_updater.GrantActivePermissions(extension());
+  perms_updater.InitializePermissions(extension_.get());
+  perms_updater.GrantActivePermissions(extension_.get());
 
   service_weak_->OnExtensionInstalled(
-      extension(), syncer::StringOrdinal(), kInstallFlagInstallImmediately);
+      extension_.get(), syncer::StringOrdinal(), kInstallFlagInstallImmediately);
 
   if (!callback_.is_null()) {
-    callback_.Run(extension(), extension_path_, std::string());
+    callback_.Run(extension_.get(), extension_path_, std::string());
     callback_.Reset();
   }
 }
 
 }  // namespace extensions