channel_info.cc revision 68043e1e95eeb07d5cae7aca370b26518b0867d6 
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/channel_info.h"
6
7#include "base/logging.h"
8#include "base/win/registry.h"
9#include "chrome/installer/util/google_update_constants.h"
10#include "chrome/installer/util/util_constants.h"
11
12using base::win::RegKey;
13
14namespace {
15
16const wchar_t kModChrome[] = L"-chrome";
17const wchar_t kModChromeFrame[] = L"-chromeframe";
18// TODO(huangs): Remove by M27.
19const wchar_t kModAppHostDeprecated[] = L"-apphost";
20const wchar_t kModAppLauncher[] = L"-applauncher";
21const wchar_t kModMultiInstall[] = L"-multi";
22const wchar_t kModReadyMode[] = L"-readymode";
23const wchar_t kModStage[] = L"-stage:";
24const wchar_t kSfxFull[] = L"-full";
25const wchar_t kSfxMigrating[] = L"-migrating";
26const wchar_t kSfxMultiFail[] = L"-multifail";
27
28const wchar_t* const kChannels[] = {
29  installer::kChromeChannelBeta,
30  installer::kChromeChannelDev
31};
32
33const wchar_t* const kModifiers[] = {
34  kModStage,
35  kModMultiInstall,
36  kModChrome,
37  kModChromeFrame,
38  kModAppHostDeprecated,  // TODO(huangs): Remove by M27.
39  kModAppLauncher,
40  kModReadyMode,
41  kSfxMultiFail,
42  kSfxMigrating,
43  kSfxFull,
44};
45
46enum ModifierIndex {
47  MOD_STAGE,
48  MOD_MULTI_INSTALL,
49  MOD_CHROME,
50  MOD_CHROME_FRAME,
51  MOD_APP_HOST_DEPRECATED,  // TODO(huangs): Remove by M27.
52  MOD_APP_LAUNCHER,
53  MOD_READY_MODE,
54  SFX_MULTI_FAIL,
55  SFX_MIGRATING,
56  SFX_FULL,
57  NUM_MODIFIERS
58};
59
60COMPILE_ASSERT(NUM_MODIFIERS == arraysize(kModifiers),
61    kModifiers_disagrees_with_ModifierIndex_comma_they_must_match_bang);
62
63// Returns true if the modifier is found, in which case |position| holds the
64// location at which the modifier was found.  The number of characters in the
65// modifier is returned in |length|, if non-NULL.
66bool FindModifier(ModifierIndex index,
67                  const std::wstring& ap_value,
68                  std::wstring::size_type* position,
69                  std::wstring::size_type* length) {
70  DCHECK(position != NULL);
71  std::wstring::size_type mod_position = std::wstring::npos;
72  std::wstring::size_type mod_length =
73      std::wstring::traits_type::length(kModifiers[index]);
74  const bool mod_takes_arg = (kModifiers[index][mod_length - 1] == L':');
75  std::wstring::size_type pos = 0;
76  do {
77    mod_position = ap_value.find(kModifiers[index], pos, mod_length);
78    if (mod_position == std::wstring::npos)
79      return false;  // Modifier not found.
80    pos = mod_position + mod_length;
81    // Modifiers that take an argument gobble up to the next separator or to the
82    // end.
83    if (mod_takes_arg) {
84      pos = ap_value.find(L'-', pos);
85      if (pos == std::wstring::npos)
86        pos = ap_value.size();
87      break;
88    }
89    // Regular modifiers must be followed by '-' or the end of the string.
90  } while (pos != ap_value.size() && ap_value[pos] != L'-');
91  DCHECK_NE(mod_position, std::wstring::npos);
92  *position = mod_position;
93  if (length != NULL)
94    *length = pos - mod_position;
95  return true;
96}
97
98bool HasModifier(ModifierIndex index, const std::wstring& ap_value) {
99  DCHECK(index >= 0 && index < NUM_MODIFIERS);
100  std::wstring::size_type position;
101  return FindModifier(index, ap_value, &position, NULL);
102}
103
104std::wstring::size_type FindInsertionPoint(ModifierIndex index,
105                                           const std::wstring& ap_value) {
106  // Return the location of the next modifier.
107  std::wstring::size_type result;
108
109  for (int scan = index + 1; scan < NUM_MODIFIERS; ++scan) {
110    if (FindModifier(static_cast<ModifierIndex>(scan), ap_value, &result, NULL))
111      return result;
112  }
113
114  return ap_value.size();
115}
116
117// Returns true if |ap_value| is modified.
118bool SetModifier(ModifierIndex index, bool set, std::wstring* ap_value) {
119  DCHECK(index >= 0 && index < NUM_MODIFIERS);
120  DCHECK(ap_value);
121  std::wstring::size_type position;
122  std::wstring::size_type length;
123  bool have_modifier = FindModifier(index, *ap_value, &position, &length);
124  if (set) {
125    if (!have_modifier) {
126      ap_value->insert(FindInsertionPoint(index, *ap_value), kModifiers[index]);
127      return true;
128    }
129  } else {
130    if (have_modifier) {
131      ap_value->erase(position, length);
132      return true;
133    }
134  }
135  return false;
136}
137
138}  // namespace
139
140namespace installer {
141
142bool ChannelInfo::Initialize(const RegKey& key) {
143  LONG result = key.ReadValue(google_update::kRegApField, &value_);
144  return result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND ||
145         result == ERROR_INVALID_HANDLE;
146}
147
148bool ChannelInfo::Write(RegKey* key) const {
149  DCHECK(key);
150  // Google Update deletes the value when it is empty, so we may as well, too.
151  LONG result = value_.empty() ?
152      key->DeleteValue(google_update::kRegApField) :
153      key->WriteValue(google_update::kRegApField, value_.c_str());
154  if (result != ERROR_SUCCESS) {
155    LOG(ERROR) << "Failed writing channel info; result: " << result;
156    return false;
157  }
158  return true;
159}
160
161bool ChannelInfo::GetChannelName(std::wstring* channel_name) const {
162  DCHECK(channel_name);
163  if (value_.empty()) {
164    channel_name->erase();
165    return true;
166  } else {
167    for (const wchar_t* const* scan = &kChannels[0],
168             *const* end = &kChannels[arraysize(kChannels)]; scan != end;
169         ++scan) {
170      if (value_.find(*scan) != std::wstring::npos) {
171        channel_name->assign(*scan);
172        return true;
173      }
174    }
175    // There may be modifiers present.  Strip them off and see if we're left
176    // with the empty string (stable channel).
177    std::wstring tmp_value = value_;
178    for (int i = 0; i != NUM_MODIFIERS; ++i) {
179      SetModifier(static_cast<ModifierIndex>(i), false, &tmp_value);
180    }
181    if (tmp_value.empty()) {
182      channel_name->erase();
183      return true;
184    }
185  }
186
187  return false;
188}
189
190bool ChannelInfo::IsChrome() const {
191  return HasModifier(MOD_CHROME, value_);
192}
193
194bool ChannelInfo::SetChrome(bool value) {
195  return SetModifier(MOD_CHROME, value, &value_);
196}
197
198bool ChannelInfo::IsChromeFrame() const {
199  return HasModifier(MOD_CHROME_FRAME, value_);
200}
201
202bool ChannelInfo::SetChromeFrame(bool value) {
203  return SetModifier(MOD_CHROME_FRAME, value, &value_);
204}
205
206bool ChannelInfo::IsAppLauncher() const {
207  return HasModifier(MOD_APP_LAUNCHER, value_);
208}
209
210bool ChannelInfo::SetAppLauncher(bool value) {
211  // Unconditionally remove -apphost since it has been deprecated.
212  bool changed_app_host = SetModifier(MOD_APP_HOST_DEPRECATED, false, &value_);
213  bool changed_app_launcher = SetModifier(MOD_APP_LAUNCHER, value, &value_);
214  return changed_app_host || changed_app_launcher;
215}
216
217bool ChannelInfo::IsMultiInstall() const {
218  return HasModifier(MOD_MULTI_INSTALL, value_);
219}
220
221bool ChannelInfo::SetMultiInstall(bool value) {
222  return SetModifier(MOD_MULTI_INSTALL, value, &value_);
223}
224
225bool ChannelInfo::IsReadyMode() const {
226  return HasModifier(MOD_READY_MODE, value_);
227}
228
229bool ChannelInfo::SetReadyMode(bool value) {
230  return SetModifier(MOD_READY_MODE, value, &value_);
231}
232
233bool ChannelInfo::SetStage(const wchar_t* stage) {
234  std::wstring::size_type position;
235  std::wstring::size_type length;
236  bool have_modifier = FindModifier(MOD_STAGE, value_, &position, &length);
237  if (stage != NULL && *stage != L'\0') {
238    std::wstring stage_str(kModStage);
239    stage_str.append(stage);
240    if (!have_modifier) {
241      value_.insert(FindInsertionPoint(MOD_STAGE, value_), stage_str);
242      return true;
243    }
244    if (value_.compare(position, length, stage_str) != 0) {
245      value_.replace(position, length, stage_str);
246      return true;
247    }
248  } else {
249    if (have_modifier) {
250      value_.erase(position, length);
251      return true;
252    }
253  }
254  return false;
255}
256
257std::wstring ChannelInfo::GetStage() const {
258  std::wstring::size_type position;
259  std::wstring::size_type length;
260
261  if (FindModifier(MOD_STAGE, value_, &position, &length)) {
262    // Return the portion after the prefix.
263    std::wstring::size_type pfx_length =
264        std::wstring::traits_type::length(kModStage);
265    DCHECK_LE(pfx_length, length);
266    return value_.substr(position + pfx_length, length - pfx_length);
267  }
268  return std::wstring();
269}
270
271bool ChannelInfo::HasFullSuffix() const {
272  return HasModifier(SFX_FULL, value_);
273}
274
275bool ChannelInfo::SetFullSuffix(bool value) {
276  return SetModifier(SFX_FULL, value, &value_);
277}
278
279bool ChannelInfo::HasMultiFailSuffix() const {
280  return HasModifier(SFX_MULTI_FAIL, value_);
281}
282
283bool ChannelInfo::SetMultiFailSuffix(bool value) {
284  return SetModifier(SFX_MULTI_FAIL, value, &value_);
285}
286
287bool ChannelInfo::SetMigratingSuffix(bool value) {
288  return SetModifier(SFX_MIGRATING, value, &value_);
289}
290
291bool ChannelInfo::HasMigratingSuffix() const {
292  return HasModifier(SFX_MIGRATING, value_);
293}
294
295bool ChannelInfo::RemoveAllModifiersAndSuffixes() {
296  bool modified = false;
297
298  for (int scan = 0; scan < NUM_MODIFIERS; ++scan) {
299    ModifierIndex index = static_cast<ModifierIndex>(scan);
300    modified = SetModifier(index, false, &value_) || modified;
301  }
302
303  return modified;
304}
305
306}  // namespace installer
307