chrome/browser/extensions/extension_install_checker.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_INSTALL_CHECKER_H_
   6 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_INSTALL_CHECKER_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/callback.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/memory/weak_ptr.h"
  14 #include "base/strings/string16.h"
  15 #include "extensions/browser/blacklist_state.h"
  16 #include "extensions/common/extension.h"
  17
  18 class Profile;
  19
  20 namespace extensions {
  21
  22 class RequirementsChecker;
  23
  24 // Performs common checks for an extension. Extensions that violate these checks
  25 // would be disabled or not even installed.
  26 class ExtensionInstallChecker {
  27  public:
  28   // Called when checks are complete. The returned value is a bitmask of
  29   // failed checks.
  30   typedef base::Callback<void(int)> Callback;
  31
  32   enum CheckType {
  33     // Check the blacklist state of the extension.
  34     CHECK_BLACKLIST = 1 << 0,
  35     // Check whether the extension has requirement errors.
  36     CHECK_REQUIREMENTS = 1 << 1,
  37     // Check whether the extension can be installed and loaded, according to
  38     // management policies.
  39     CHECK_MANAGEMENT_POLICY = 1 << 2,
  40     // Perform all checks.
  41     CHECK_ALL = (1 << 3) - 1
  42   };
  43
  44   explicit ExtensionInstallChecker(Profile* profile);
  45   virtual ~ExtensionInstallChecker();
  46
  47   // Start a set of checks. |enabled_checks| is a bitmask of CheckTypes to run.
  48   // If |fail_fast| is true, the callback will be invoked once any check fails.
  49   // Otherwise it will be invoked when all checks have completed. |callback|
  50   // will only be called once.
  51   // This function must be called on the UI thread. The callback also occurs on
  52   // the UI thread. Checks may run asynchronously in parallel.
  53   // If checks are currently running, the caller must wait for the callback to
  54   // be invoked before starting another set of checks.
  55   void Start(int enabled_checks, bool fail_fast, const Callback& callback);
  56
  57   Profile* profile() const { return profile_; }
  58
  59   const scoped_refptr<const Extension>& extension() { return extension_; }
  60   void set_extension(const scoped_refptr<const Extension>& extension) {
  61     extension_ = extension;
  62   }
  63
  64   // Returns true if any checks are currently running.
  65   bool is_running() const { return running_checks_ != 0; }
  66
  67   // Returns the requirement violations. A non-empty list is considered to be
  68   // a check failure.
  69   const std::vector<std::string>& requirement_errors() const {
  70     return requirement_errors_;
  71   }
  72
  73   // Returns the blacklist state of the extension. A blacklist state of
  74   // BLACKLISTED_MALWARE is considered to be a check failure.
  75   BlacklistState blacklist_state() const { return blacklist_state_; }
  76
  77   // Returns whether management policy permits installation of the extension.
  78   bool policy_allows_load() const { return policy_allows_load_; }
  79   const std::string& policy_error() const { return policy_error_; }
  80
  81  protected:
  82   virtual void CheckManagementPolicy();
  83   void OnManagementPolicyCheckDone(bool allows_load, const std::string& error);
  84
  85   virtual void CheckRequirements();
  86   void OnRequirementsCheckDone(int sequence_number,
  87                                const std::vector<std::string>& errors);
  88
  89   virtual void CheckBlacklistState();
  90   void OnBlacklistStateCheckDone(int sequence_number, BlacklistState state);
  91
  92   virtual void ResetResults();
  93   int current_sequence_number() const { return current_sequence_number_; }
  94
  95  private:
  96   void MaybeInvokeCallback();
  97
  98   scoped_ptr<RequirementsChecker> requirements_checker_;
  99
 100   // The Profile where the extension is being installed in.
 101   Profile* profile_;
 102
 103   // The extension to run checks for.
 104   scoped_refptr<const Extension> extension_;
 105
 106   // Requirement violations.
 107   std::vector<std::string> requirement_errors_;
 108
 109   // Result of the blacklist state check.
 110   BlacklistState blacklist_state_;
 111
 112   // Whether the extension can be installed, according to management policies.
 113   bool policy_allows_load_;
 114   std::string policy_error_;
 115
 116   // The sequence number of the currently running checks.
 117   int current_sequence_number_;
 118
 119   // Bitmask of currently running checks.
 120   int running_checks_;
 121
 122   // If true, the callback is invoked when the first check fails.
 123   bool fail_fast_;
 124
 125   // The callback to invoke when checks are complete.
 126   Callback callback_;
 127
 128   base::WeakPtrFactory<ExtensionInstallChecker> weak_ptr_factory_;
 129
 130   DISALLOW_COPY_AND_ASSIGN(ExtensionInstallChecker);
 131 };
 132
 133 }  // namespace extensions
 134
 135 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_INSTALL_CHECKER_H_