// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/installer/util/channel_info.h"
#include "base/logging.h"
#include "base/win/registry.h"
#include "chrome/installer/util/google_update_constants.h"
#include "chrome/installer/util/util_constants.h"
using base::win::RegKey;
namespace {
const wchar_t kModChrome[] = L"-chrome";
const wchar_t kModChromeFrame[] = L"-chromeframe";
// TODO(huangs): Remove by M27.
const wchar_t kModAppHostDeprecated[] = L"-apphost";
const wchar_t kModAppLauncher[] = L"-applauncher";
const wchar_t kModMultiInstall[] = L"-multi";
const wchar_t kModReadyMode[] = L"-readymode";
const wchar_t kModStage[] = L"-stage:";
const wchar_t kSfxFull[] = L"-full";
const wchar_t kSfxMigrating[] = L"-migrating";
const wchar_t kSfxMultiFail[] = L"-multifail";
const wchar_t* const kChannels[] = {
installer::kChromeChannelBeta,
installer::kChromeChannelDev,
installer::kChromeChannelStableExplicit
};
const wchar_t* const kModifiers[] = {
kModStage,
kModMultiInstall,
kModChrome,
kModChromeFrame,
kModAppHostDeprecated, // TODO(huangs): Remove by M27.
kModAppLauncher,
kModReadyMode,
kSfxMultiFail,
kSfxMigrating,
kSfxFull,
};
enum ModifierIndex {
MOD_STAGE,
MOD_MULTI_INSTALL,
MOD_CHROME,
MOD_CHROME_FRAME,
MOD_APP_HOST_DEPRECATED, // TODO(huangs): Remove by M27.
MOD_APP_LAUNCHER,
MOD_READY_MODE,
SFX_MULTI_FAIL,
SFX_MIGRATING,
SFX_FULL,
NUM_MODIFIERS
};
COMPILE_ASSERT(NUM_MODIFIERS == arraysize(kModifiers),
kModifiers_disagrees_with_ModifierIndex_comma_they_must_match_bang);
// Returns true if the modifier is found, in which case |position| holds the
// location at which the modifier was found. The number of characters in the
// modifier is returned in |length|, if non-NULL.
bool FindModifier(ModifierIndex index,
const std::wstring& ap_value,
std::wstring::size_type* position,
std::wstring::size_type* length) {
DCHECK(position != NULL);
std::wstring::size_type mod_position = std::wstring::npos;
std::wstring::size_type mod_length =
std::wstring::traits_type::length(kModifiers[index]);
const bool mod_takes_arg = (kModifiers[index][mod_length - 1] == L':');
std::wstring::size_type pos = 0;
do {
mod_position = ap_value.find(kModifiers[index], pos, mod_length);
if (mod_position == std::wstring::npos)
return false; // Modifier not found.
pos = mod_position + mod_length;
// Modifiers that take an argument gobble up to the next separator or to the
// end.
if (mod_takes_arg) {
pos = ap_value.find(L'-', pos);
if (pos == std::wstring::npos)
pos = ap_value.size();
break;
}
// Regular modifiers must be followed by '-' or the end of the string.
} while (pos != ap_value.size() && ap_value[pos] != L'-');
DCHECK_NE(mod_position, std::wstring::npos);
*position = mod_position;
if (length != NULL)
*length = pos - mod_position;
return true;
}
bool HasModifier(ModifierIndex index, const std::wstring& ap_value) {
DCHECK(index >= 0 && index < NUM_MODIFIERS);
std::wstring::size_type position;
return FindModifier(index, ap_value, &position, NULL);
}
std::wstring::size_type FindInsertionPoint(ModifierIndex index,
const std::wstring& ap_value) {
// Return the location of the next modifier.
std::wstring::size_type result;
for (int scan = index + 1; scan < NUM_MODIFIERS; ++scan) {
if (FindModifier(static_cast<ModifierIndex>(scan), ap_value, &result, NULL))
return result;
}
return ap_value.size();
}
// Returns true if |ap_value| is modified.
bool SetModifier(ModifierIndex index, bool set, std::wstring* ap_value) {
DCHECK(index >= 0 && index < NUM_MODIFIERS);
DCHECK(ap_value);
std::wstring::size_type position;
std::wstring::size_type length;
bool have_modifier = FindModifier(index, *ap_value, &position, &length);
if (set) {
if (!have_modifier) {
ap_value->insert(FindInsertionPoint(index, *ap_value), kModifiers[index]);
return true;
}
} else {
if (have_modifier) {
ap_value->erase(position, length);
return true;
}
}
return false;
}
} // namespace
namespace installer {
bool ChannelInfo::Initialize(const RegKey& key) {
LONG result = key.ReadValue(google_update::kRegApField, &value_);
return result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND ||
result == ERROR_INVALID_HANDLE;
}
bool ChannelInfo::Write(RegKey* key) const {
DCHECK(key);
// Google Update deletes the value when it is empty, so we may as well, too.
LONG result = value_.empty() ?
key->DeleteValue(google_update::kRegApField) :
key->WriteValue(google_update::kRegApField, value_.c_str());
if (result != ERROR_SUCCESS) {
LOG(ERROR) << "Failed writing channel info; result: " << result;
return false;
}
return true;
}
bool ChannelInfo::GetChannelName(std::wstring* channel_name) const {
DCHECK(channel_name);
if (value_.empty()) {
channel_name->erase();
return true;
} else {
for (const wchar_t* const* scan = &kChannels[0],
*const* end = &kChannels[arraysize(kChannels)]; scan != end;
++scan) {
if (value_.find(*scan) != std::wstring::npos) {
// Report channels with "stable" in them as stable (empty string).
if (*scan == installer::kChromeChannelStableExplicit)
channel_name->erase();
else
channel_name->assign(*scan);
return true;
}
}
// There may be modifiers present. Strip them off and see if we're left
// with the empty string (stable channel).
std::wstring tmp_value = value_;
for (int i = 0; i != NUM_MODIFIERS; ++i) {
SetModifier(static_cast<ModifierIndex>(i), false, &tmp_value);
}
if (tmp_value.empty()) {
channel_name->erase();
return true;
}
}
return false;
}
bool ChannelInfo::IsChrome() const {
return HasModifier(MOD_CHROME, value_);
}
bool ChannelInfo::SetChrome(bool value) {
return SetModifier(MOD_CHROME, value, &value_);
}
bool ChannelInfo::IsChromeFrame() const {
return HasModifier(MOD_CHROME_FRAME, value_);
}
bool ChannelInfo::SetChromeFrame(bool value) {
return SetModifier(MOD_CHROME_FRAME, value, &value_);
}
bool ChannelInfo::IsAppLauncher() const {
return HasModifier(MOD_APP_LAUNCHER, value_);
}
bool ChannelInfo::SetAppLauncher(bool value) {
// Unconditionally remove -apphost since it has been deprecated.
bool changed_app_host = SetModifier(MOD_APP_HOST_DEPRECATED, false, &value_);
bool changed_app_launcher = SetModifier(MOD_APP_LAUNCHER, value, &value_);
return changed_app_host || changed_app_launcher;
}
bool ChannelInfo::IsMultiInstall() const {
return HasModifier(MOD_MULTI_INSTALL, value_);
}
bool ChannelInfo::SetMultiInstall(bool value) {
return SetModifier(MOD_MULTI_INSTALL, value, &value_);
}
bool ChannelInfo::IsReadyMode() const {
return HasModifier(MOD_READY_MODE, value_);
}
bool ChannelInfo::SetReadyMode(bool value) {
return SetModifier(MOD_READY_MODE, value, &value_);
}
bool ChannelInfo::SetStage(const wchar_t* stage) {
std::wstring::size_type position;
std::wstring::size_type length;
bool have_modifier = FindModifier(MOD_STAGE, value_, &position, &length);
if (stage != NULL && *stage != L'\0') {
std::wstring stage_str(kModStage);
stage_str.append(stage);
if (!have_modifier) {
value_.insert(FindInsertionPoint(MOD_STAGE, value_), stage_str);
return true;
}
if (value_.compare(position, length, stage_str) != 0) {
value_.replace(position, length, stage_str);
return true;
}
} else {
if (have_modifier) {
value_.erase(position, length);
return true;
}
}
return false;
}
std::wstring ChannelInfo::GetStage() const {
std::wstring::size_type position;
std::wstring::size_type length;
if (FindModifier(MOD_STAGE, value_, &position, &length)) {
// Return the portion after the prefix.
std::wstring::size_type pfx_length =
std::wstring::traits_type::length(kModStage);
DCHECK_LE(pfx_length, length);
return value_.substr(position + pfx_length, length - pfx_length);
}
return std::wstring();
}
bool ChannelInfo::HasFullSuffix() const {
return HasModifier(SFX_FULL, value_);
}
bool ChannelInfo::SetFullSuffix(bool value) {
return SetModifier(SFX_FULL, value, &value_);
}
bool ChannelInfo::HasMultiFailSuffix() const {
return HasModifier(SFX_MULTI_FAIL, value_);
}
bool ChannelInfo::SetMultiFailSuffix(bool value) {
return SetModifier(SFX_MULTI_FAIL, value, &value_);
}
bool ChannelInfo::SetMigratingSuffix(bool value) {
return SetModifier(SFX_MIGRATING, value, &value_);
}
bool ChannelInfo::HasMigratingSuffix() const {
return HasModifier(SFX_MIGRATING, value_);
}
bool ChannelInfo::RemoveAllModifiersAndSuffixes() {
bool modified = false;
for (int scan = 0; scan < NUM_MODIFIERS; ++scan) {
ModifierIndex index = static_cast<ModifierIndex>(scan);
modified = SetModifier(index, false, &value_) || modified;
}
return modified;
}
} // namespace installer