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 #include "chrome/installer/util/master_preferences.h" 6 7 #include "base/environment.h" 8 #include "base/file_util.h" 9 #include "base/json/json_string_value_serializer.h" 10 #include "base/lazy_instance.h" 11 #include "base/logging.h" 12 #include "base/path_service.h" 13 #include "base/strings/string_util.h" 14 #include "chrome/common/env_vars.h" 15 #include "chrome/common/pref_names.h" 16 #include "chrome/installer/util/master_preferences_constants.h" 17 #include "chrome/installer/util/util_constants.h" 18 19 namespace { 20 21 const char kFirstRunTabs[] = "first_run_tabs"; 22 23 base::LazyInstance<installer::MasterPreferences> g_master_preferences = 24 LAZY_INSTANCE_INITIALIZER; 25 26 bool GetURLFromValue(const base::Value* in_value, std::string* out_value) { 27 return in_value && out_value && in_value->GetAsString(out_value); 28 } 29 30 std::vector<std::string> GetNamedList(const char* name, 31 const base::DictionaryValue* prefs) { 32 std::vector<std::string> list; 33 if (!prefs) 34 return list; 35 36 const base::ListValue* value_list = NULL; 37 if (!prefs->GetList(name, &value_list)) 38 return list; 39 40 list.reserve(value_list->GetSize()); 41 for (size_t i = 0; i < value_list->GetSize(); ++i) { 42 const base::Value* entry; 43 std::string url_entry; 44 if (!value_list->Get(i, &entry) || !GetURLFromValue(entry, &url_entry)) { 45 NOTREACHED(); 46 break; 47 } 48 list.push_back(url_entry); 49 } 50 return list; 51 } 52 53 base::DictionaryValue* ParseDistributionPreferences( 54 const std::string& json_data) { 55 JSONStringValueSerializer json(json_data); 56 std::string error; 57 scoped_ptr<base::Value> root(json.Deserialize(NULL, &error)); 58 if (!root.get()) { 59 LOG(WARNING) << "Failed to parse master prefs file: " << error; 60 return NULL; 61 } 62 if (!root->IsType(base::Value::TYPE_DICTIONARY)) { 63 LOG(WARNING) << "Failed to parse master prefs file: " 64 << "Root item must be a dictionary."; 65 return NULL; 66 } 67 return static_cast<base::DictionaryValue*>(root.release()); 68 } 69 70 } // namespace 71 72 namespace installer { 73 74 MasterPreferences::MasterPreferences() : distribution_(NULL), 75 preferences_read_from_file_(false), 76 chrome_(true), 77 chrome_app_launcher_(false), 78 chrome_frame_(false), 79 multi_install_(false) { 80 InitializeFromCommandLine(*CommandLine::ForCurrentProcess()); 81 } 82 83 MasterPreferences::MasterPreferences(const CommandLine& cmd_line) 84 : distribution_(NULL), 85 preferences_read_from_file_(false), 86 chrome_(true), 87 chrome_app_launcher_(false), 88 chrome_frame_(false), 89 multi_install_(false) { 90 InitializeFromCommandLine(cmd_line); 91 } 92 93 MasterPreferences::MasterPreferences(const base::FilePath& prefs_path) 94 : distribution_(NULL), 95 preferences_read_from_file_(false), 96 chrome_(true), 97 chrome_app_launcher_(false), 98 chrome_frame_(false), 99 multi_install_(false) { 100 std::string json_data; 101 // Failure to read the file is ignored as |json_data| will be the empty string 102 // and the remainder of this MasterPreferences object should still be 103 // initialized as best as possible. 104 if (base::PathExists(prefs_path) && 105 !file_util::ReadFileToString(prefs_path, &json_data)) { 106 LOG(ERROR) << "Failed to read preferences from " << prefs_path.value(); 107 } 108 if (InitializeFromString(json_data)) 109 preferences_read_from_file_ = true; 110 } 111 112 MasterPreferences::MasterPreferences(const std::string& prefs) 113 : distribution_(NULL), 114 preferences_read_from_file_(false), 115 chrome_(true), 116 chrome_app_launcher_(false), 117 chrome_frame_(false), 118 multi_install_(false) { 119 InitializeFromString(prefs); 120 } 121 122 MasterPreferences::~MasterPreferences() { 123 } 124 125 void MasterPreferences::InitializeFromCommandLine(const CommandLine& cmd_line) { 126 #if defined(OS_WIN) 127 if (cmd_line.HasSwitch(installer::switches::kInstallerData)) { 128 base::FilePath prefs_path(cmd_line.GetSwitchValuePath( 129 installer::switches::kInstallerData)); 130 this->MasterPreferences::MasterPreferences(prefs_path); 131 } else { 132 master_dictionary_.reset(new base::DictionaryValue()); 133 } 134 135 DCHECK(master_dictionary_.get()); 136 137 // A simple map from command line switches to equivalent switches in the 138 // distribution dictionary. Currently all switches added will be set to 139 // 'true'. 140 static const struct CmdLineSwitchToDistributionSwitch { 141 const char* cmd_line_switch; 142 const char* distribution_switch; 143 } translate_switches[] = { 144 { installer::switches::kAutoLaunchChrome, 145 installer::master_preferences::kAutoLaunchChrome }, 146 { installer::switches::kChromeAppHostDeprecated, 147 installer::master_preferences::kChromeAppHostDeprecated }, 148 { installer::switches::kChromeAppLauncher, 149 installer::master_preferences::kChromeAppLauncher }, 150 { installer::switches::kChrome, 151 installer::master_preferences::kChrome }, 152 { installer::switches::kChromeFrame, 153 installer::master_preferences::kChromeFrame }, 154 { installer::switches::kChromeFrameReadyMode, 155 installer::master_preferences::kChromeFrameReadyMode }, 156 { installer::switches::kDisableLogging, 157 installer::master_preferences::kDisableLogging }, 158 { installer::switches::kMsi, 159 installer::master_preferences::kMsi }, 160 { installer::switches::kMultiInstall, 161 installer::master_preferences::kMultiInstall }, 162 { installer::switches::kDoNotRegisterForUpdateLaunch, 163 installer::master_preferences::kDoNotRegisterForUpdateLaunch }, 164 { installer::switches::kDoNotLaunchChrome, 165 installer::master_preferences::kDoNotLaunchChrome }, 166 { installer::switches::kMakeChromeDefault, 167 installer::master_preferences::kMakeChromeDefault }, 168 { installer::switches::kSystemLevel, 169 installer::master_preferences::kSystemLevel }, 170 { installer::switches::kVerboseLogging, 171 installer::master_preferences::kVerboseLogging }, 172 }; 173 174 std::string name(installer::master_preferences::kDistroDict); 175 for (int i = 0; i < arraysize(translate_switches); ++i) { 176 if (cmd_line.HasSwitch(translate_switches[i].cmd_line_switch)) { 177 name.assign(installer::master_preferences::kDistroDict); 178 name.append(".").append(translate_switches[i].distribution_switch); 179 master_dictionary_->SetBoolean(name, true); 180 } 181 } 182 183 // See if the log file path was specified on the command line. 184 std::wstring str_value(cmd_line.GetSwitchValueNative( 185 installer::switches::kLogFile)); 186 if (!str_value.empty()) { 187 name.assign(installer::master_preferences::kDistroDict); 188 name.append(".").append(installer::master_preferences::kLogFile); 189 master_dictionary_->SetString(name, str_value); 190 } 191 192 // Handle the special case of --system-level being implied by the presence of 193 // the kGoogleUpdateIsMachineEnvVar environment variable. 194 scoped_ptr<base::Environment> env(base::Environment::Create()); 195 if (env != NULL) { 196 std::string is_machine_var; 197 env->GetVar(env_vars::kGoogleUpdateIsMachineEnvVar, &is_machine_var); 198 if (!is_machine_var.empty() && is_machine_var[0] == '1') { 199 VLOG(1) << "Taking system-level from environment."; 200 name.assign(installer::master_preferences::kDistroDict); 201 name.append(".").append(installer::master_preferences::kSystemLevel); 202 master_dictionary_->SetBoolean(name, true); 203 } 204 } 205 206 // Cache a pointer to the distribution dictionary. Ignore errors if any. 207 master_dictionary_->GetDictionary(installer::master_preferences::kDistroDict, 208 &distribution_); 209 210 InitializeProductFlags(); 211 #endif 212 } 213 214 bool MasterPreferences::InitializeFromString(const std::string& json_data) { 215 if (!json_data.empty()) 216 master_dictionary_.reset(ParseDistributionPreferences(json_data)); 217 218 bool data_is_valid = true; 219 if (!master_dictionary_.get()) { 220 master_dictionary_.reset(new base::DictionaryValue()); 221 data_is_valid = false; 222 } else { 223 // Cache a pointer to the distribution dictionary. 224 master_dictionary_->GetDictionary( 225 installer::master_preferences::kDistroDict, &distribution_); 226 } 227 228 InitializeProductFlags(); 229 EnforceLegacyPreferences(); 230 return data_is_valid; 231 } 232 233 void MasterPreferences::InitializeProductFlags() { 234 // Make sure we start out with the correct defaults. 235 multi_install_ = false; 236 chrome_frame_ = false; 237 chrome_app_launcher_ = false; 238 chrome_ = true; 239 240 GetBool(installer::master_preferences::kMultiInstall, &multi_install_); 241 GetBool(installer::master_preferences::kChromeFrame, &chrome_frame_); 242 243 GetBool(installer::master_preferences::kChromeAppLauncher, 244 &chrome_app_launcher_); 245 246 // The deprecated switch --app-host behaves like --app-launcher. 247 bool chrome_app_host = false; 248 GetBool(installer::master_preferences::kChromeAppHostDeprecated, 249 &chrome_app_host); 250 chrome_app_launcher_ = chrome_app_launcher_ || chrome_app_host; 251 252 // When multi-install is specified, the checks are pretty simple (in theory): 253 // In order to be installed/uninstalled, each product must have its switch 254 // present on the command line. 255 // Before multi-install was introduced however, we only supported installing 256 // two products, Chrome and Chrome Frame. For the time being we need to 257 // continue to support this mode where multi-install is not set. 258 // So, when multi-install is not set, we continue to support mutually 259 // exclusive installation of Chrome and Chrome Frame. 260 if (multi_install_) { 261 if (!GetBool(installer::master_preferences::kChrome, &chrome_)) 262 chrome_ = false; 263 } else { 264 // If chrome-frame is on the command line however, we only install CF. 265 chrome_ = !chrome_frame_; 266 } 267 } 268 269 void MasterPreferences::EnforceLegacyPreferences() { 270 // If create_all_shortcuts was explicitly set to false, set 271 // do_not_create_(desktop|quick_launch)_shortcut to true. 272 bool create_all_shortcuts = true; 273 GetBool(installer::master_preferences::kCreateAllShortcuts, 274 &create_all_shortcuts); 275 if (!create_all_shortcuts) { 276 distribution_->SetBoolean( 277 installer::master_preferences::kDoNotCreateDesktopShortcut, true); 278 distribution_->SetBoolean( 279 installer::master_preferences::kDoNotCreateQuickLaunchShortcut, true); 280 } 281 } 282 283 bool MasterPreferences::GetBool(const std::string& name, bool* value) const { 284 bool ret = false; 285 if (distribution_) 286 ret = distribution_->GetBoolean(name, value); 287 return ret; 288 } 289 290 bool MasterPreferences::GetInt(const std::string& name, int* value) const { 291 bool ret = false; 292 if (distribution_) 293 ret = distribution_->GetInteger(name, value); 294 return ret; 295 } 296 297 bool MasterPreferences::GetString(const std::string& name, 298 std::string* value) const { 299 bool ret = false; 300 if (distribution_) 301 ret = (distribution_->GetString(name, value) && !value->empty()); 302 return ret; 303 } 304 305 std::vector<std::string> MasterPreferences::GetFirstRunTabs() const { 306 return GetNamedList(kFirstRunTabs, master_dictionary_.get()); 307 } 308 309 bool MasterPreferences::GetExtensionsBlock( 310 base::DictionaryValue** extensions) const { 311 return master_dictionary_->GetDictionary( 312 master_preferences::kExtensionsBlock, extensions); 313 } 314 315 std::string MasterPreferences::GetVariationsSeed() const { 316 std::string variations_seed; 317 master_dictionary_->GetString(prefs::kVariationsSeed, &variations_seed); 318 return variations_seed; 319 } 320 321 // static 322 const MasterPreferences& MasterPreferences::ForCurrentProcess() { 323 return g_master_preferences.Get(); 324 } 325 326 } // namespace installer 327
