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_STATE_H_
      6 #define CHROME_INSTALLER_UTIL_INSTALLATION_STATE_H_
      7 
      8 #include <string>
      9 
     10 #include "base/basictypes.h"
     11 #include "base/command_line.h"
     12 #include "base/files/file_path.h"
     13 #include "base/memory/scoped_ptr.h"
     14 #include "chrome/installer/util/app_commands.h"
     15 #include "chrome/installer/util/browser_distribution.h"
     16 #include "chrome/installer/util/channel_info.h"
     17 
     18 namespace base {
     19 class Version;
     20 namespace win {
     21 class RegKey;
     22 }
     23 }
     24 
     25 namespace installer {
     26 
     27 class InstallationState;
     28 
     29 // A representation of a product's state on the machine based on the contents
     30 // of the Windows registry.
     31 // TODO(grt): Pull this out into its own file.
     32 class ProductState {
     33  public:
     34   ProductState();
     35 
     36   // Returns true if the product is installed (i.e., the product's Clients key
     37   // exists and has a "pv" value); false otherwise.
     38   bool Initialize(bool system_install,
     39                   BrowserDistribution::Type type);
     40   bool Initialize(bool system_install,
     41                   BrowserDistribution* distribution);
     42 
     43   // Returns the product's channel info (i.e., the Google Update "ap" value).
     44   const ChannelInfo& channel() const { return channel_; }
     45 
     46   // Returns the path to the product's "setup.exe"; may be empty.
     47   base::FilePath GetSetupPath() const;
     48 
     49   // Returns the product's version.  This method may only be called on an
     50   // instance that has been initialized for an installed product.
     51   const base::Version& version() const;
     52 
     53   // Returns the current version of the product if a new version is awaiting
     54   // update; may be NULL.  Ownership of a returned value is not passed to the
     55   // caller.
     56   const base::Version* old_version() const { return old_version_.get(); }
     57 
     58   // Returns the brand code the product is currently installed with.
     59   const std::wstring& brand() const { return brand_; }
     60 
     61   // Returns the command to be used to update to the new version that is
     62   // awaiting update; may be empty.
     63   const std::wstring& rename_cmd() const { return rename_cmd_; }
     64 
     65   // Returns true and populates |eula_accepted| if the product has such a value;
     66   // otherwise, returns false and does not modify |eula_accepted|.  Expected
     67   // values are 0 (false) and 1 (true), although |eula_accepted| is given
     68   // whatever is found.
     69   bool GetEulaAccepted(DWORD* eula_accepted) const;
     70 
     71   // Returns true and populates |oem_install| if the product has such a value;
     72   // otherwise, returns false and does not modify |oem_install|.  Expected
     73   // value is "1", although |oem_install| is given whatever is found.
     74   bool GetOemInstall(std::wstring* oem_install) const;
     75 
     76   // Returns true and populates |usagestats| if the product has such a value;
     77   // otherwise, returns false and does not modify |usagestats|.  Expected values
     78   // are 0 (false) and 1 (true), although |usagestats| is given whatever is
     79   // found.
     80   bool GetUsageStats(DWORD* usagestats) const;
     81 
     82   // True if the "msi" value in the ClientState key is present and non-zero.
     83   bool is_msi() const { return msi_; }
     84 
     85   // The command to uninstall the product; may be empty.
     86   const base::CommandLine& uninstall_command() const {
     87     return uninstall_command_;
     88   }
     89 
     90   // True if |uninstall_command| contains --multi-install.
     91   bool is_multi_install() const { return multi_install_; }
     92 
     93   // Returns the set of Google Update commands.
     94   const AppCommands& commands() const { return commands_; }
     95 
     96   // Returns this object a la operator=().
     97   ProductState& CopyFrom(const ProductState& other);
     98 
     99   // Clears the state of this object.
    100   void Clear();
    101 
    102  protected:
    103   static bool InitializeCommands(const base::win::RegKey& version_key,
    104                                  AppCommands* commands);
    105 
    106   ChannelInfo channel_;
    107   scoped_ptr<Version> version_;
    108   scoped_ptr<Version> old_version_;
    109   std::wstring brand_;
    110   std::wstring rename_cmd_;
    111   std::wstring oem_install_;
    112   base::CommandLine uninstall_command_;
    113   AppCommands commands_;
    114   DWORD eula_accepted_;
    115   DWORD usagestats_;
    116   bool msi_ : 1;
    117   bool multi_install_ : 1;
    118   bool has_eula_accepted_ : 1;
    119   bool has_oem_install_ : 1;
    120   bool has_usagestats_ : 1;
    121 
    122  private:
    123   friend class InstallationState;
    124 
    125   DISALLOW_COPY_AND_ASSIGN(ProductState);
    126 };  // class ProductState
    127 
    128 // Encapsulates the state of all products on the system.
    129 // TODO(grt): Rename this to MachineState and put it in its own file.
    130 class InstallationState {
    131  public:
    132   InstallationState();
    133 
    134   // Initializes this object with the machine's current state.
    135   void Initialize();
    136 
    137   // Returns the state of a product or NULL if not installed.
    138   // Caller does NOT assume ownership of returned pointer.
    139   const ProductState* GetProductState(bool system_install,
    140                                       BrowserDistribution::Type type) const;
    141 
    142   // Returns the state of a product, even one that has not yet been installed.
    143   // This is useful during first install, when some but not all ProductState
    144   // information has been written by Omaha. Notably absent from the
    145   // ProductState returned here are the version numbers. Do NOT try to access
    146   // the version numbers from a ProductState returned by this method.
    147   // Caller does NOT assume ownership of returned pointer. This method will
    148   // never return NULL.
    149   const ProductState* GetNonVersionedProductState(
    150       bool system_install, BrowserDistribution::Type type) const;
    151 
    152  protected:
    153   enum {
    154     CHROME_BROWSER_INDEX,
    155     CHROME_FRAME_INDEX,
    156     CHROME_BINARIES_INDEX,
    157     CHROME_APP_HOST_INDEX,
    158     NUM_PRODUCTS
    159   };
    160 
    161   static int IndexFromDistType(BrowserDistribution::Type type);
    162 
    163   ProductState user_products_[NUM_PRODUCTS];
    164   ProductState system_products_[NUM_PRODUCTS];
    165 
    166  private:
    167   DISALLOW_COPY_AND_ASSIGN(InstallationState);
    168 };  // class InstallationState
    169 
    170 }  // namespace installer
    171 
    172 #endif  // CHROME_INSTALLER_UTIL_INSTALLATION_STATE_H_
    173