master_preferences.cc revision 58537e28ecd584eab876aee8be7156509866d23a 
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
19namespace {
20
21const char kFirstRunTabs[] = "first_run_tabs";
22
23base::LazyInstance<installer::MasterPreferences> g_master_preferences =
24    LAZY_INSTANCE_INITIALIZER;
25
26bool GetURLFromValue(const base::Value* in_value, std::string* out_value) {
27  return in_value && out_value && in_value->GetAsString(out_value);
28}
29
30std::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
53base::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
72namespace installer {
73
74MasterPreferences::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
83MasterPreferences::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
93MasterPreferences::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      !base::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
112MasterPreferences::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
122MasterPreferences::~MasterPreferences() {
123}
124
125void 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
214bool 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
233void 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
269void 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
283bool 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
290bool 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
297bool 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
305std::vector<std::string> MasterPreferences::GetFirstRunTabs() const {
306  return GetNamedList(kFirstRunTabs, master_dictionary_.get());
307}
308
309bool MasterPreferences::GetExtensionsBlock(
310    base::DictionaryValue** extensions) const {
311  return master_dictionary_->GetDictionary(
312      master_preferences::kExtensionsBlock, extensions);
313}
314
315std::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
322const MasterPreferences& MasterPreferences::ForCurrentProcess() {
323  return g_master_preferences.Get();
324}
325
326}  // namespace installer
327