Simplify ExtensionInstallChecker into a single-use class

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>
@@ skipping 24 matching lines @@
     CHECK_BLACKLIST = 1 << 0,
     // Check whether the extension has requirement errors.
     CHECK_REQUIREMENTS = 1 << 1,
     // Check whether the extension can be installed and loaded, according to
     // management policies.
     CHECK_MANAGEMENT_POLICY = 1 << 2,
     // Perform all checks.
     CHECK_ALL = (1 << 3) - 1
   };
 
-  explicit ExtensionInstallChecker(Profile* profile);
+  explicit ExtensionInstallChecker(Profile* profile,

[Devlin, 2017/03/16 19:29:40]

This no longer needs explicit.

[michaelpg, 2017/03/17 04:25:23]

Made PG-rated.

+                                   scoped_refptr<const Extension> extension);
   virtual ~ExtensionInstallChecker();
 
-  // Start a set of checks. |enabled_checks| is a bitmask of CheckTypes to run.
-  // If |fail_fast| is true, the callback will be invoked once any check fails.
-  // Otherwise it will be invoked when all checks have completed. |callback|
-  // will only be called once.
+  // Start the set of checks. |enabled_checks| is a bitmask of CheckTypes to

[Devlin, 2017/03/16 19:29:41]

nit: since we're updating this anyway, function comments should be descriptive,
not imperative.

[michaelpg, 2017/03/17 04:25:23]

Done.

+  // run. If |fail_fast| is true, the callback will be invoked once any check
+  // fails. Otherwise it will be invoked when all checks have completed.
+  // |callback| will only be called once.
   // This function must be called on the UI thread. The callback also occurs on
   // the UI thread. Checks may run asynchronously in parallel.
-  // If checks are currently running, the caller must wait for the callback to
-  // be invoked before starting another set of checks.
+  // This function should be invoked at most once.

[Devlin, 2017/03/16 19:29:40]

Let's also put something about single use in the class comments.

[michaelpg, 2017/03/17 04:25:23]

Done.

   void Start(int enabled_checks, bool fail_fast, const Callback& callback);
 
   Profile* profile() const { return profile_; }
 
   const scoped_refptr<const Extension>& extension() { return extension_; }
-  void set_extension(const scoped_refptr<const Extension>& extension) {
-    extension_ = extension;
-  }
 
   // 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
   // BLACKLISTED_MALWARE is considered to be a check failure.
   BlacklistState blacklist_state() const { return blacklist_state_; }
 
   // 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_; }
 
  protected:
   virtual void CheckManagementPolicy();
   void OnManagementPolicyCheckDone(bool allows_load, const std::string& error);
 
   virtual void CheckRequirements();
-  void OnRequirementsCheckDone(int sequence_number,
-                               const std::vector<std::string>& errors);
+  void OnRequirementsCheckDone(const std::vector<std::string>& errors);
 
   virtual void CheckBlacklistState();
-  void OnBlacklistStateCheckDone(int sequence_number, BlacklistState state);
-
-  virtual void ResetResults();
-  int current_sequence_number() const { return current_sequence_number_; }
+  void OnBlacklistStateCheckDone(BlacklistState state);
 
  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.
   std::vector<std::string> requirement_errors_;
 
   // Result of the blacklist state check.
   BlacklistState blacklist_state_;
 
   // Whether the extension can be installed, according to management policies.
   bool policy_allows_load_;
   std::string policy_error_;
 
-  // The sequence number of the currently running checks.
-  int current_sequence_number_;
+  // 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_