Update ExtensionInstallChecker to use PreloadCheck classes

chrome/browser/extensions/extension_install_checker.h

 // Copyright 2014 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_INSTALL_CHECKER_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_INSTALL_CHECKER_H_
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
-#include "base/memory/weak_ptr.h"
 #include "base/strings/string16.h"
-#include "extensions/browser/blacklist_state.h"
+#include "extensions/browser/preload_check.h"
 #include "extensions/common/extension.h"
 
 class Profile;
 
 namespace extensions {
 
 class RequirementsChecker;
 
 // Performs common checks for validating whether an extension may be installed.
 // This class should be Start()-ed at most once.
@@ skipping 32 matching lines @@
 
   // Returns true if any checks are currently running.
   bool is_running() const { return running_checks_ != 0; }
 
   // Returns the requirement violations. A non-empty list is considered to be
   // a check failure.
   const std::vector<std::string>& requirement_errors() const {
     return requirement_errors_;
   }
 
-  // Returns the blacklist state of the extension. A blacklist state of
+  // Returns the blacklist error of the extension. A blacklist state of
   // BLACKLISTED_MALWARE is considered to be a check failure.

[Devlin, 2017/03/22 15:08:46]

BLACKLISTED_ID

[michaelpg, 2017/03/24 02:34:16]

I see why this is confusing, so I've changed the comment. The blacklist_error_
is a PreloadCheck::Error, not a BlacklistState. The error will be NONE,
BLACKLISTED_ID, or BLACKLISTED_UNKNOWN.

The error is set to BLACKLISTED_ID if the BlacklistState was
BLACKLISTED_MALWARE. That is, the "greylist" states like
BLACKLISTED_SECURITY_VULNERABILITY do not cause us to set a PreloadCheck::Error.
(This is how this class works today, so it's not a behavior change.)

The reason I didn't call the PreloadCheck::Error enumerator
"BLACKLISTED_MALWARE" instead of BLACKLISTED_ID is to avoid coupling the error
to the blacklist state. Should we decide the greylists should cause install
errors too, we can update the BlacklistCheck class to return BLACKLISTED_ID for
those too, and not have to update every client of BlacklistCheck (including
clients of ExtensionInstallCheck) to handle the additional errors.

-  BlacklistState blacklist_state() const { return blacklist_state_; }
+  PreloadCheck::Error blacklist_error() const { return blacklist_error_; }
 
   // Returns whether management policy permits installation of the extension.
-  bool policy_allows_load() const { return policy_allows_load_; }
   const std::string& policy_error() const { return policy_error_; }
 
+  void SetBlacklistCheckForTesting(std::unique_ptr<PreloadCheck> policy_check) {
+    blacklist_check_ = std::move(policy_check);
+  }
+  void SetPolicyCheckForTesting(std::unique_ptr<PreloadCheck> policy_check) {
+    policy_check_ = std::move(policy_check);
+  }
+
  protected:
   virtual void CheckManagementPolicy();
-  void OnManagementPolicyCheckDone(bool allows_load, const std::string& error);
+  void OnManagementPolicyCheckDone(PreloadCheck::Errors errors);
 
   virtual void CheckRequirements();
   void OnRequirementsCheckDone(const std::vector<std::string>& errors);
 
   virtual void CheckBlacklistState();
-  void OnBlacklistStateCheckDone(BlacklistState state);
+  void OnBlacklistStateCheckDone(PreloadCheck::Errors errors);
 
  private:
   void MaybeInvokeCallback();
 
-  std::unique_ptr<RequirementsChecker> requirements_checker_;
-
   // The Profile where the extension is being installed in.
   Profile* profile_;
 
   // The extension to run checks for.
   scoped_refptr<const Extension> extension_;
 
-  // Requirement violations.
+  // Checks requirements specified in the manifest.
+  std::unique_ptr<RequirementsChecker> requirements_checker_;
   std::vector<std::string> requirement_errors_;
 
-  // Result of the blacklist state check.
-  BlacklistState blacklist_state_;
+  // Checks if the extension is blacklisted.
+  std::unique_ptr<PreloadCheck> blacklist_check_;
+  PreloadCheck::Error blacklist_error_;
 
-  // Whether the extension can be installed, according to management policies.
-  bool policy_allows_load_;
+  // Checks whether management policies allow the extension to be installed.
+  std::unique_ptr<PreloadCheck> policy_check_;
   std::string policy_error_;
 
   // Bitmask of enabled checks.
   int enabled_checks_;
 
   // Bitmask of currently running checks.
   int running_checks_;
 
   // If true, the callback is invoked when the first check fails.
   bool fail_fast_;
 
   // The callback to invoke when checks are complete.
   Callback callback_;
 
-  base::WeakPtrFactory<ExtensionInstallChecker> weak_ptr_factory_;
-
   DISALLOW_COPY_AND_ASSIGN(ExtensionInstallChecker);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_INSTALL_CHECKER_H_