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_INSTALLER_STATE_H_ 6 #define CHROME_INSTALLER_UTIL_INSTALLER_STATE_H_ 7 8 #include <set> 9 #include <string> 10 #include <vector> 11 12 #include "base/basictypes.h" 13 #include "base/files/file_path.h" 14 #include "base/logging.h" 15 #include "base/memory/scoped_ptr.h" 16 #include "base/memory/scoped_vector.h" 17 #include "base/version.h" 18 #include "chrome/installer/util/browser_distribution.h" 19 #include "chrome/installer/util/product.h" 20 #include "chrome/installer/util/util_constants.h" 21 22 #if defined(OS_WIN) 23 #include <windows.h> // NOLINT 24 #endif 25 26 class CommandLine; 27 28 namespace installer { 29 30 class ChannelInfo; 31 class InstallationState; 32 class MasterPreferences; 33 34 class ProductState; 35 36 typedef std::vector<Product*> Products; 37 38 // Encapsulates the state of the current installation operation. Only valid 39 // for installs and upgrades (not for uninstalls or non-install commands). 40 // This class interprets the command-line arguments and master preferences and 41 // determines the operations to be performed. For example, the Chrome Binaries 42 // are automatically added if required in multi-install mode. 43 // TODO(erikwright): This is now used a fair bit during uninstall, and 44 // InstallerState::Initialize() contains a lot of code for uninstall. The class 45 // comment should probably be updated. 46 // TODO(grt): Rename to InstallerEngine/Conductor or somesuch? 47 class InstallerState { 48 public: 49 enum Level { 50 UNKNOWN_LEVEL, 51 USER_LEVEL, 52 SYSTEM_LEVEL 53 }; 54 55 enum PackageType { 56 UNKNOWN_PACKAGE_TYPE, 57 SINGLE_PACKAGE, 58 MULTI_PACKAGE 59 }; 60 61 enum Operation { 62 UNINITIALIZED, 63 SINGLE_INSTALL_OR_UPDATE, 64 MULTI_INSTALL, 65 MULTI_UPDATE, 66 UNINSTALL 67 }; 68 69 // Constructs an uninitialized instance; see Initialize(). 70 InstallerState(); 71 72 // Constructs an initialized but empty instance. 73 explicit InstallerState(Level level); 74 75 // Initializes this object based on the current operation. 76 void Initialize(const CommandLine& command_line, 77 const MasterPreferences& prefs, 78 const InstallationState& machine_state); 79 80 // Adds a product constructed on the basis of |state|, setting this object's 81 // msi flag if |state| is msi-installed. Returns the product that was added, 82 // or NULL if |state| is incompatible with this object. Ownership is not 83 // passed to the caller. 84 Product* AddProductFromState(BrowserDistribution::Type type, 85 const ProductState& state); 86 87 // Returns the product that was added, or NULL if |product| is incompatible 88 // with this object. Ownership of |product| is taken by this object, while 89 // ownership of the return value is not passed to the caller. 90 Product* AddProduct(scoped_ptr<Product>* product); 91 92 // Removes |product| from the set of products to be operated on. The object 93 // pointed to by |product| is freed. Returns false if |product| is not 94 // present in the set. 95 bool RemoveProduct(const Product* product); 96 97 // The level (user or system) of this operation. level()98 Level level() const { return level_; } 99 100 // The package type (single or multi) of this operation. package_type()101 PackageType package_type() const { return package_type_; } 102 103 // An identifier of this operation. operation()104 Operation operation() const { return operation_; } 105 106 // A convenience method returning level() == SYSTEM_LEVEL. 107 // TODO(grt): Eradicate the bool in favor of the enum. 108 bool system_install() const; 109 110 // A convenience method returning package_type() == MULTI_PACKAGE. 111 // TODO(grt): Eradicate the bool in favor of the enum. 112 bool is_multi_install() const; 113 114 // A convenient method returning the presence of the 115 // --ensure-google-update-present switch. ensure_google_update_present()116 bool ensure_google_update_present() const { 117 return ensure_google_update_present_; 118 } 119 120 // The full path to the place where the operand resides. target_path()121 const base::FilePath& target_path() const { return target_path_; } 122 123 // True if the "msi" preference is set or if a product with the "msi" state 124 // flag is set is to be operated on. is_msi()125 bool is_msi() const { return msi_; } 126 127 // True if the --verbose-logging command-line flag is set or if the 128 // verbose_logging master preferences option is true. verbose_logging()129 bool verbose_logging() const { return verbose_logging_; } 130 131 #if defined(OS_WIN) root_key()132 HKEY root_key() const { return root_key_; } 133 #endif 134 135 // The ClientState key by which we interact with Google Update. state_key()136 const std::wstring& state_key() const { return state_key_; } 137 138 // Convenience method to return the type of the BrowserDistribution associated 139 // with the ClientState key we will be interacting with. state_type()140 BrowserDistribution::Type state_type() const { return state_type_; } 141 142 // Returns the BrowserDistribution instance corresponding to the binaries for 143 // this run if we're operating on a multi-package product. multi_package_binaries_distribution()144 BrowserDistribution* multi_package_binaries_distribution() const { 145 DCHECK(package_type_ == MULTI_PACKAGE); 146 DCHECK(multi_package_distribution_ != NULL); 147 return multi_package_distribution_; 148 } 149 products()150 const Products& products() const { return products_.get(); } 151 152 // Returns the product of the desired type, or NULL if none found. 153 const Product* FindProduct(BrowserDistribution::Type distribution_type) const; 154 155 // Returns the currently installed version in |target_path|, or NULL if no 156 // products are installed. Ownership is passed to the caller. 157 base::Version* GetCurrentVersion( 158 const InstallationState& machine_state) const; 159 160 // Returns the critical update version if all of the following are true: 161 // * --critical-update-version=CUV was specified on the command-line. 162 // * current_version == NULL or current_version < CUV. 163 // * new_version >= CUV. 164 // Otherwise, returns an invalid version. 165 base::Version DetermineCriticalVersion( 166 const base::Version* current_version, 167 const base::Version& new_version) const; 168 169 // Returns whether or not there is currently a Chrome Frame instance running. 170 // Note that there isn't a mechanism to lock Chrome Frame in place, so Chrome 171 // Frame may either exit or start up after this is called. 172 bool IsChromeFrameRunning(const InstallationState& machine_state) const; 173 174 // Returns true if any of the binaries from a multi-install Chrome Frame that 175 // has been migrated to single-install are still in use. 176 bool AreBinariesInUse(const InstallationState& machine_state) const; 177 178 // Returns the path to the installer under Chrome version folder 179 // (for example <target_path>\Google\Chrome\Application\<Version>\Installer) 180 base::FilePath GetInstallerDirectory(const base::Version& version) const; 181 182 // Try to delete all directories under |temp_path| whose versions are less 183 // than |new_version| and not equal to |existing_version|. |existing_version| 184 // may be NULL. 185 void RemoveOldVersionDirectories(const base::Version& new_version, 186 base::Version* existing_version, 187 const base::FilePath& temp_path) const; 188 189 // Adds to |com_dll_list| the list of COM DLLs that are to be registered 190 // and/or unregistered. The list may be empty. 191 void AddComDllList(std::vector<base::FilePath>* com_dll_list) const; 192 193 bool SetChannelFlags(bool set, ChannelInfo* channel_info) const; 194 195 // See InstallUtil::UpdateInstallerStage. 196 void UpdateStage(installer::InstallerStage stage) const; 197 198 // For a MULTI_INSTALL or MULTI_UPDATE operation, updates the Google Update 199 // "ap" values for all products being operated on. 200 void UpdateChannels() const; 201 202 // Sets installer result information in the registry for consumption by Google 203 // Update. The InstallerResult value is set to 0 (SUCCESS) or 1 204 // (FAILED_CUSTOM_ERROR) depending on whether |status| maps to success or not. 205 // |status| itself is written to the InstallerError value. 206 // |string_resource_id|, if non-zero, identifies a localized string written to 207 // the InstallerResultUIString value. |launch_cmd|, if non-NULL and 208 // non-empty, is written to the InstallerSuccessLaunchCmdLine value. 209 void WriteInstallerResult(InstallStatus status, 210 int string_resource_id, 211 const std::wstring* launch_cmd) const; 212 213 // Returns true if this install needs to register an Active Setup command. 214 bool RequiresActiveSetup() const; 215 216 protected: 217 // Bits for the |file_bits| argument of AnyExistsAndIsInUse. 218 enum { 219 CHROME_DLL = 1 << 0, 220 CHROME_FRAME_DLL = 1 << 1, 221 CHROME_FRAME_HELPER_DLL = 1 << 2, 222 CHROME_FRAME_HELPER_EXE = 1 << 3, 223 NUM_BINARIES = 4 224 }; 225 226 // Returns true if |file| exists and cannot be opened for exclusive write 227 // access. 228 static bool IsFileInUse(const base::FilePath& file); 229 230 // Clears the instance to an uninitialized state. 231 void Clear(); 232 233 // Returns true if any file corresponding to a bit in |file_bits| (from the 234 // enum above) for the currently installed version exists and is in use. 235 bool AnyExistsAndIsInUse(const InstallationState& machine_state, 236 uint32 file_bits) const; 237 base::FilePath GetDefaultProductInstallPath(BrowserDistribution* dist) const; 238 bool CanAddProduct(const Product& product, 239 const base::FilePath* product_dir) const; 240 Product* AddProductInDirectory(const base::FilePath* product_dir, 241 scoped_ptr<Product>* product); 242 Product* AddProductFromPreferences( 243 BrowserDistribution::Type distribution_type, 244 const MasterPreferences& prefs, 245 const InstallationState& machine_state); 246 bool IsMultiInstallUpdate(const MasterPreferences& prefs, 247 const InstallationState& machine_state); 248 249 // Enumerates all files named one of 250 // [chrome.exe, old_chrome.exe, new_chrome.exe] in target_path_ and 251 // returns their version numbers in a set. 252 void GetExistingExeVersions(std::set<std::string>* existing_versions) const; 253 254 // Sets this object's level and updates the root_key_ accordingly. 255 void set_level(Level level); 256 257 // Sets this object's package type and updates the multi_package_distribution_ 258 // accordingly. 259 void set_package_type(PackageType type); 260 261 Operation operation_; 262 base::FilePath target_path_; 263 std::wstring state_key_; 264 BrowserDistribution::Type state_type_; 265 ScopedVector<Product> products_; 266 BrowserDistribution* multi_package_distribution_; 267 base::Version critical_update_version_; 268 Level level_; 269 PackageType package_type_; 270 #if defined(OS_WIN) 271 HKEY root_key_; 272 #endif 273 bool msi_; 274 bool verbose_logging_; 275 bool ensure_google_update_present_; 276 277 private: 278 DISALLOW_COPY_AND_ASSIGN(InstallerState); 279 }; // class InstallerState 280 281 } // namespace installer 282 283 #endif // CHROME_INSTALLER_UTIL_INSTALLER_STATE_H_ 284