Replace ExtensionInstallChecker with generic PreloadCheckGroup

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/memory/ptr_util.h"
 #include "base/strings/string16.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_checker.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 "components/crx_file/id_util.h"
 #include "components/sync/model/string_ordinal.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/install/extension_install_ui.h"
 #include "extensions/browser/install_flag.h"
+#include "extensions/browser/policy_check.h"
+#include "extensions/browser/preload_check_group.h"
+#include "extensions/browser/requirements_checker.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_l10n_util.h"
 #include "extensions/common/file_util.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_handlers/plugins_handler.h"
 #include "extensions/common/manifest_handlers/shared_module_info.h"
 #include "extensions/common/permissions/permissions_data.h"
 
 using content::BrowserThread;
 using extensions::Extension;
@@ skipping 196 matching lines @@
         } else if (imported_module && (version_required.IsValid() &&
                                        imported_module->version()->CompareTo(
                                            version_required) < 0)) {
           ReportExtensionLoadError(kImportMinVersionNewer);
           return;
         }
       }
     }
   }
 
-  install_checker_ = base::MakeUnique<ExtensionInstallChecker>(
-      profile_, extension_,
-      ExtensionInstallChecker::CHECK_REQUIREMENTS |
-          ExtensionInstallChecker::CHECK_MANAGEMENT_POLICY,
-      true /* fail fast */);
-  install_checker_->Start(
-      base::Bind(&UnpackedInstaller::OnInstallChecksComplete, this));
+  policy_check_ = base::MakeUnique<PolicyCheck>(profile_, extension_);
+  requirements_check_ = base::MakeUnique<RequirementsChecker>(extension_);
+
+  check_group_ = base::MakeUnique<PreloadCheckGroup>();
+  check_group_->set_stop_on_first_error(true);
+
+  check_group_->AddCheck(policy_check_.get());
+  check_group_->AddCheck(requirements_check_.get());
+  check_group_->Start(
+      base::BindOnce(&UnpackedInstaller::OnInstallChecksComplete, this));
 }
 
-void UnpackedInstaller::OnInstallChecksComplete(int failed_checks) {
+void UnpackedInstaller::OnInstallChecksComplete(PreloadCheck::Errors errors) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  base::string16 error_message = install_checker_->policy_error();
-  if (error_message.empty())
-    error_message = install_checker_->requirements_error_message();
-
-  if (!error_message.empty()) {
-    ReportExtensionLoadError(base::UTF16ToUTF8(error_message));
+  if (errors.empty()) {
+    InstallExtension();
     return;
   }
 
-  InstallExtension();
+  base::string16 error_message;
+  if (errors.count(PreloadCheck::DISALLOWED_BY_POLICY))
+    error_message = policy_check_->GetErrorMessage();
+  else
+    error_message = requirements_check_->GetErrorMessage();
+
+  DCHECK(!error_message.empty());
+  ReportExtensionLoadError(base::UTF16ToUTF8(error_message));
 }
 
 int UnpackedInstaller::GetFlags() {
   std::string id = crx_file::id_util::GenerateIdForPath(extension_path_);
   bool allow_file_access =
       Manifest::ShouldAlwaysAllowFileAccess(Manifest::UNPACKED);
   ExtensionPrefs* prefs = ExtensionPrefs::Get(service_weak_->profile());
   if (prefs->HasAllowFileAccessSetting(id))
     allow_file_access = prefs->AllowFileAccess(id);
 
@@ skipping 104 matching lines @@
   service_weak_->OnExtensionInstalled(
       extension(), syncer::StringOrdinal(), kInstallFlagInstallImmediately);
 
   if (!callback_.is_null()) {
     callback_.Run(extension(), extension_path_, std::string());
     callback_.Reset();
   }
 }
 
 }  // namespace extensions