Use PreloadCheckGroup in ExtensionInstallChecker. Make RequirementsChecker a PreloadCheck.

extensions/browser/api/management/management_api.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 "extensions/browser/api/management/management_api.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
-#include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "content/public/browser/browser_context.h"
 #include "extensions/browser/api/extensions_api_client.h"
 #include "extensions/browser/api/management/management_api_constants.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
@@ skipping 408 matching lines @@
 
       AddRef();  // Matched in OnInstallPromptDone().
       install_prompt_ = delegate->SetEnabledFunctionDelegate(
           GetSenderWebContents(), browser_context(), extension,
           base::Bind(&ManagementSetEnabledFunction::OnInstallPromptDone, this));
       return RespondLater();
     }
     if (prefs->GetDisableReasons(extension_id_) &
             Extension::DISABLE_UNSUPPORTED_REQUIREMENT) {
       // Recheck the requirements.
-      requirements_checker_ = delegate->CreateRequirementsChecker();
-      requirements_checker_->Check(
-          extension,
+      requirements_checker_ =
+          base::MakeUnique<extensions::RequirementsChecker>(extension);
+      requirements_checker_->Start(
           base::Bind(&ManagementSetEnabledFunction::OnRequirementsChecked,
                      this));  // This bind creates a reference.
       return RespondLater();
     }
     delegate->EnableExtension(browser_context(), extension_id_);
   } else if (currently_enabled && !params->enabled) {
     delegate->DisableExtension(browser_context(), extension_id_,
                                Extension::DISABLE_USER_ACTION);
   }
 
   return RespondNow(NoArguments());
 }
 
 void ManagementSetEnabledFunction::OnInstallPromptDone(bool did_accept) {
   if (did_accept) {
     ManagementAPI::GetFactoryInstance()
         ->Get(browser_context())
         ->GetDelegate()
         ->EnableExtension(browser_context(), extension_id_);
     Respond(OneArgument(base::MakeUnique<base::Value>(true)));
   } else {
     Respond(Error(keys::kUserDidNotReEnableError));
   }
 
   Release();  // Balanced in Run().
 }
 
 void ManagementSetEnabledFunction::OnRequirementsChecked(
-    const std::vector<std::string>& requirements_errors) {
+    PreloadCheck::Errors requirements_errors) {
   if (requirements_errors.empty()) {
     ManagementAPI::GetFactoryInstance()->Get(browser_context())->GetDelegate()->
         EnableExtension(browser_context(), extension_id_);
     Respond(NoArguments());
   } else {
     // TODO(devlin): Should we really be noisy here all the time?
     Respond(Error(keys::kMissingRequirementsError,
-                  base::JoinString(requirements_errors, " ")));
+                  base::UTF16ToUTF8(requirements_checker_->GetErrorMessage())));
   }
 }
 
 ManagementUninstallFunctionBase::ManagementUninstallFunctionBase() {
 }
 
 ManagementUninstallFunctionBase::~ManagementUninstallFunctionBase() {
 }
 
 ExtensionFunction::ResponseAction ManagementUninstallFunctionBase::Uninstall(
@@ skipping 366 matching lines @@
 ManagementAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 void ManagementAPI::OnListenerAdded(const EventListenerInfo& details) {
   management_event_router_.reset(new ManagementEventRouter(browser_context_));
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
 }  // namespace extensions