Home | History | Annotate | Download | only in util
      1 // Copyright (c) 2012 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_INSTALLER_UTIL_INSTALLATION_VALIDATOR_H_
      6 #define CHROME_INSTALLER_UTIL_INSTALLATION_VALIDATOR_H_
      7 
      8 #include <map>
      9 #include <set>
     10 #include <utility>
     11 #include <vector>
     12 
     13 #include "base/basictypes.h"
     14 #include "base/compiler_specific.h"
     15 #include "base/strings/string16.h"
     16 #include "chrome/installer/util/browser_distribution.h"
     17 
     18 namespace base {
     19 class CommandLine;
     20 class FilePath;
     21 }
     22 
     23 namespace installer {
     24 
     25 class InstallationState;
     26 class AppCommand;
     27 class ProductState;
     28 
     29 // A class that validates the state of an installation.  Violations are logged
     30 // via LOG(ERROR).
     31 class InstallationValidator {
     32  public:
     33   class ProductBits {
     34    public:
     35     // Bits that form the components of an installation type.
     36     enum {
     37       CHROME_SINGLE           = 0x01,
     38       CHROME_MULTI            = 0x02,
     39       CHROME_FRAME_SINGLE     = 0x04,
     40       CHROME_FRAME_MULTI      = 0x08,
     41       CHROME_APP_HOST         = 0x10,
     42     };
     43   };  // class ProductBits
     44 
     45   // Identifiers of all valid installation types.
     46   enum InstallationType {
     47     NO_PRODUCTS = 0,
     48     CHROME_SINGLE =
     49         ProductBits::CHROME_SINGLE,
     50     CHROME_MULTI =
     51         ProductBits::CHROME_MULTI,
     52     CHROME_FRAME_SINGLE =
     53         ProductBits::CHROME_FRAME_SINGLE,
     54     CHROME_FRAME_SINGLE_CHROME_SINGLE =
     55         ProductBits::CHROME_FRAME_SINGLE | ProductBits::CHROME_SINGLE,
     56     CHROME_FRAME_SINGLE_CHROME_MULTI =
     57         ProductBits::CHROME_FRAME_SINGLE | ProductBits::CHROME_MULTI,
     58     CHROME_FRAME_MULTI =
     59         ProductBits::CHROME_FRAME_MULTI,
     60     CHROME_FRAME_MULTI_CHROME_MULTI =
     61         ProductBits::CHROME_FRAME_MULTI | ProductBits::CHROME_MULTI,
     62     CHROME_APP_HOST =
     63         ProductBits::CHROME_APP_HOST,
     64     CHROME_APP_HOST_CHROME_FRAME_SINGLE =
     65         ProductBits::CHROME_APP_HOST | ProductBits::CHROME_FRAME_SINGLE,
     66     CHROME_APP_HOST_CHROME_FRAME_SINGLE_CHROME_MULTI =
     67         ProductBits::CHROME_APP_HOST | ProductBits::CHROME_FRAME_SINGLE |
     68         ProductBits::CHROME_MULTI,
     69     CHROME_APP_HOST_CHROME_FRAME_MULTI =
     70         ProductBits::CHROME_APP_HOST | ProductBits::CHROME_FRAME_MULTI,
     71     CHROME_APP_HOST_CHROME_FRAME_MULTI_CHROME_MULTI =
     72         ProductBits::CHROME_APP_HOST | ProductBits::CHROME_FRAME_MULTI |
     73         ProductBits::CHROME_MULTI,
     74     CHROME_APP_HOST_CHROME_MULTI =
     75         ProductBits::CHROME_APP_HOST | ProductBits::CHROME_MULTI,
     76   };
     77 
     78   // Validates |machine_state| at user or system level, returning true if valid.
     79   // |type| is populated in either case, although it is a best-guess when the
     80   // method returns false.
     81   static bool ValidateInstallationTypeForState(
     82       const InstallationState& machine_state,
     83       bool system_level,
     84       InstallationType* type);
     85 
     86   // Validates the machine's current installation at user or system level,
     87   // returning true and populating |type| if valid.
     88   static bool ValidateInstallationType(bool system_level,
     89                                        InstallationType* type);
     90 
     91  protected:
     92   struct ProductContext;
     93   typedef std::vector<std::pair<std::string, bool> > SwitchExpectations;
     94   typedef void (*CommandValidatorFn)(const ProductContext& ctx,
     95                                      const AppCommand& app_cmd,
     96                                      bool* is_valid);
     97   typedef std::map<base::string16, CommandValidatorFn> CommandExpectations;
     98 
     99   // An interface to product-specific validation rules.
    100   class ProductRules {
    101    public:
    102     virtual ~ProductRules() { }
    103     virtual BrowserDistribution::Type distribution_type() const = 0;
    104     virtual void AddUninstallSwitchExpectations(
    105         const ProductContext& ctx,
    106         SwitchExpectations* expectations) const = 0;
    107     virtual void AddRenameSwitchExpectations(
    108         const ProductContext& ctx,
    109         SwitchExpectations* expectations) const = 0;
    110     // Return true if the rules allow usagestats setting.
    111     virtual bool UsageStatsAllowed(const ProductContext& ctx) const = 0;
    112   };
    113 
    114   // Validation rules for the Chrome browser.
    115   class ChromeRules : public ProductRules {
    116    public:
    117     virtual BrowserDistribution::Type distribution_type() const OVERRIDE;
    118     virtual void AddUninstallSwitchExpectations(
    119         const ProductContext& ctx,
    120         SwitchExpectations* expectations) const OVERRIDE;
    121     virtual void AddRenameSwitchExpectations(
    122         const ProductContext& ctx,
    123         SwitchExpectations* expectations) const OVERRIDE;
    124     virtual bool UsageStatsAllowed(const ProductContext& ctx) const OVERRIDE;
    125   };
    126 
    127   // Validation rules for Chrome Frame.
    128   class ChromeFrameRules : public ProductRules {
    129    public:
    130     virtual BrowserDistribution::Type distribution_type() const OVERRIDE;
    131     virtual void AddUninstallSwitchExpectations(
    132         const ProductContext& ctx,
    133         SwitchExpectations* expectations) const OVERRIDE;
    134     virtual void AddRenameSwitchExpectations(
    135         const ProductContext& ctx,
    136         SwitchExpectations* expectations) const OVERRIDE;
    137     virtual bool UsageStatsAllowed(const ProductContext& ctx) const OVERRIDE;
    138   };
    139 
    140   // Validation rules for Chrome App Host.
    141   class ChromeAppHostRules : public ProductRules {
    142    public:
    143     virtual BrowserDistribution::Type distribution_type() const OVERRIDE;
    144     virtual void AddUninstallSwitchExpectations(
    145         const ProductContext& ctx,
    146         SwitchExpectations* expectations) const OVERRIDE;
    147     virtual void AddRenameSwitchExpectations(
    148         const ProductContext& ctx,
    149         SwitchExpectations* expectations) const OVERRIDE;
    150     virtual bool UsageStatsAllowed(const ProductContext& ctx) const OVERRIDE;
    151   };
    152 
    153   // Validation rules for the multi-install Chrome binaries.
    154   class ChromeBinariesRules : public ProductRules {
    155    public:
    156     virtual BrowserDistribution::Type distribution_type() const OVERRIDE;
    157     virtual void AddUninstallSwitchExpectations(
    158         const ProductContext& ctx,
    159         SwitchExpectations* expectations) const OVERRIDE;
    160     virtual void AddRenameSwitchExpectations(
    161         const ProductContext& ctx,
    162         SwitchExpectations* expectations) const OVERRIDE;
    163     virtual bool UsageStatsAllowed(const ProductContext& ctx) const OVERRIDE;
    164   };
    165 
    166   struct ProductContext {
    167     ProductContext(const InstallationState& machine_state_in,
    168                    bool system_install_in,
    169                    const ProductState& state_in,
    170                    const ProductRules& rules_in)
    171         : machine_state(machine_state_in),
    172           system_install(system_install_in),
    173           dist(BrowserDistribution::GetSpecificDistribution(
    174               rules_in.distribution_type())),
    175           state(state_in),
    176           rules(rules_in) {
    177     }
    178 
    179     const InstallationState& machine_state;
    180     bool system_install;
    181     BrowserDistribution* dist;
    182     const ProductState& state;
    183     const ProductRules& rules;
    184   };
    185 
    186   // Helper to validate the values of bool elements in AppCommand, and to output
    187   // error messages. |flag_expect| is a bit mask specifying the expected
    188   // presence/absence of bool variables.
    189   static void ValidateAppCommandFlags(
    190       const ProductContext& ctx,
    191       const AppCommand& app_cmd,
    192       const std::set<base::string16>& flags_expected,
    193       const base::string16& name,
    194       bool* is_valid);
    195   static void ValidateInstallCommand(const ProductContext& ctx,
    196                                      const AppCommand& app_cmd,
    197                                      const wchar_t* expected_command,
    198                                      const wchar_t* expected_app_name,
    199                                      const char* expected_switch,
    200                                      bool* is_valid);
    201   static void ValidateInstallAppCommand(const ProductContext& ctx,
    202                                         const AppCommand& app_cmd,
    203                                         bool* is_valid);
    204   static void ValidateInstallExtensionCommand(const ProductContext& ctx,
    205                                               const AppCommand& app_cmd,
    206                                               bool* is_valid);
    207   static void ValidateOnOsUpgradeCommand(const ProductContext& ctx,
    208                                          const AppCommand& app_cmd,
    209                                          bool* is_valid);
    210   static void ValidateQueryEULAAcceptanceCommand(const ProductContext& ctx,
    211                                                  const AppCommand& app_cmd,
    212                                                  bool* is_valid);
    213   static void ValidateQuickEnableApplicationHostCommand(
    214     const ProductContext& ctx,
    215     const AppCommand& app_cmd,
    216     bool* is_valid);
    217 
    218   static void ValidateAppCommandExpectations(
    219       const ProductContext& ctx,
    220       const CommandExpectations& expectations,
    221       bool* is_valid);
    222   static void ValidateBinariesCommands(const ProductContext& ctx,
    223                                        bool* is_valid);
    224   static void ValidateBinaries(const InstallationState& machine_state,
    225                                bool system_install,
    226                                const ProductState& binaries_state,
    227                                bool* is_valid);
    228   static void ValidateSetupPath(const ProductContext& ctx,
    229                                 const base::FilePath& setup_exe,
    230                                 const base::string16& purpose,
    231                                 bool* is_valid);
    232   static void ValidateCommandExpectations(const ProductContext& ctx,
    233                                           const base::CommandLine& command,
    234                                           const SwitchExpectations& expected,
    235                                           const base::string16& source,
    236                                           bool* is_valid);
    237   static void ValidateUninstallCommand(const ProductContext& ctx,
    238                                        const base::CommandLine& command,
    239                                        const base::string16& source,
    240                                        bool* is_valid);
    241   static void ValidateRenameCommand(const ProductContext& ctx,
    242                                     bool* is_valid);
    243   static void ValidateOldVersionValues(const ProductContext& ctx,
    244                                        bool* is_valid);
    245   static void ValidateMultiInstallProduct(const ProductContext& ctx,
    246                                           bool* is_valid);
    247   static void ValidateAppCommands(const ProductContext& ctx,
    248                                   bool* is_valid);
    249   static void ValidateUsageStats(const ProductContext& ctx,
    250                                  bool* is_valid);
    251   static void ValidateProduct(const InstallationState& machine_state,
    252                               bool system_install,
    253                               const ProductState& product_state,
    254                               const ProductRules& rules,
    255                               bool* is_valid);
    256 
    257   // A collection of all valid installation types.
    258   static const InstallationType kInstallationTypes[];
    259 
    260  private:
    261   DISALLOW_IMPLICIT_CONSTRUCTORS(InstallationValidator);
    262 };
    263 
    264 }  // namespace installer
    265 
    266 #endif  // CHROME_INSTALLER_UTIL_INSTALLATION_VALIDATOR_H_
    267