// Copyright (c) 2011 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/browser/chromeos/proxy_cros_settings_provider.h"
#include "base/command_line.h"
#include "base/string_util.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/ui/browser_list.h"
#include "chrome/common/chrome_switches.h"
namespace chromeos {
static const char kProxyPacUrl[] = "cros.session.proxy.pacurl";
static const char kProxySingleHttp[] = "cros.session.proxy.singlehttp";
static const char kProxySingleHttpPort[] = "cros.session.proxy.singlehttpport";
static const char kProxyHttpUrl[] = "cros.session.proxy.httpurl";
static const char kProxyHttpPort[] = "cros.session.proxy.httpport";
static const char kProxyHttpsUrl[] = "cros.session.proxy.httpsurl";
static const char kProxyHttpsPort[] = "cros.session.proxy.httpsport";
static const char kProxyType[] = "cros.session.proxy.type";
static const char kProxySingle[] = "cros.session.proxy.single";
static const char kProxyFtpUrl[] = "cros.session.proxy.ftpurl";
static const char kProxyFtpPort[] = "cros.session.proxy.ftpport";
static const char kProxySocks[] = "cros.session.proxy.socks";
static const char kProxySocksPort[] = "cros.session.proxy.socksport";
static const char kProxyIgnoreList[] = "cros.session.proxy.ignorelist";
//------------------ ProxyCrosSettingsProvider: public methods -----------------
ProxyCrosSettingsProvider::ProxyCrosSettingsProvider() { }
void ProxyCrosSettingsProvider::DoSet(const std::string& path,
Value* in_value) {
if (!in_value) {
return;
}
chromeos::ProxyConfigServiceImpl* config_service = GetConfigService();
// Don't persist settings to device for guest session.
config_service->UISetPersistToDevice(
!CommandLine::ForCurrentProcess()->HasSwitch(switches::kGuestSession));
// Retrieve proxy config.
chromeos::ProxyConfigServiceImpl::ProxyConfig config;
config_service->UIGetProxyConfig(&config);
if (path == kProxyPacUrl) {
std::string val;
if (in_value->GetAsString(&val)) {
GURL url(val);
config_service->UISetProxyConfigToPACScript(url);
}
} else if (path == kProxySingleHttp) {
std::string val;
if (in_value->GetAsString(&val)) {
config_service->UISetProxyConfigToSingleProxy(CreateProxyServerFromHost(
val, config.single_proxy, net::ProxyServer::SCHEME_HTTP));
}
} else if (path == kProxySingleHttpPort) {
int val;
if (in_value->GetAsInteger(&val)) {
config_service->UISetProxyConfigToSingleProxy(CreateProxyServerFromPort(
val, config.single_proxy, net::ProxyServer::SCHEME_HTTP));
}
} else if (path == kProxyHttpUrl) {
std::string val;
if (in_value->GetAsString(&val)) {
config_service->UISetProxyConfigToProxyPerScheme("http",
CreateProxyServerFromHost(
val, config.http_proxy, net::ProxyServer::SCHEME_HTTP));
}
} else if (path == kProxyHttpPort) {
int val;
if (in_value->GetAsInteger(&val)) {
config_service->UISetProxyConfigToProxyPerScheme("http",
CreateProxyServerFromPort(
val, config.http_proxy, net::ProxyServer::SCHEME_HTTP));
}
} else if (path == kProxyHttpsUrl) {
std::string val;
if (in_value->GetAsString(&val)) {
config_service->UISetProxyConfigToProxyPerScheme("https",
CreateProxyServerFromHost(
val, config.https_proxy, net::ProxyServer::SCHEME_HTTP));
}
} else if (path == kProxyHttpsPort) {
int val;
if (in_value->GetAsInteger(&val)) {
config_service->UISetProxyConfigToProxyPerScheme("https",
CreateProxyServerFromPort(
val, config.https_proxy, net::ProxyServer::SCHEME_HTTP));
}
} else if (path == kProxyType) {
int val;
if (in_value->GetAsInteger(&val)) {
if (val == 3) {
if (config.automatic_proxy.pac_url.is_valid())
config_service->UISetProxyConfigToPACScript(
config.automatic_proxy.pac_url);
else
config_service->UISetProxyConfigToAutoDetect();
} else if (val == 2) {
if (config.single_proxy.server.is_valid()) {
config_service->UISetProxyConfigToSingleProxy(
config.single_proxy.server);
} else {
bool set_config = false;
if (config.http_proxy.server.is_valid()) {
config_service->UISetProxyConfigToProxyPerScheme("http",
config.http_proxy.server);
set_config = true;
}
if (config.https_proxy.server.is_valid()) {
config_service->UISetProxyConfigToProxyPerScheme("https",
config.https_proxy.server);
set_config = true;
}
if (config.ftp_proxy.server.is_valid()) {
config_service->UISetProxyConfigToProxyPerScheme("ftp",
config.ftp_proxy.server);
set_config = true;
}
if (config.socks_proxy.server.is_valid()) {
config_service->UISetProxyConfigToProxyPerScheme("socks",
config.socks_proxy.server);
set_config = true;
}
if (!set_config) {
config_service->UISetProxyConfigToProxyPerScheme("http",
net::ProxyServer());
}
}
} else {
config_service->UISetProxyConfigToDirect();
}
}
} else if (path == kProxySingle) {
bool val;
if (in_value->GetAsBoolean(&val)) {
if (val)
config_service->UISetProxyConfigToSingleProxy(
config.single_proxy.server);
else
config_service->UISetProxyConfigToProxyPerScheme("http",
config.http_proxy.server);
}
} else if (path == kProxyFtpUrl) {
std::string val;
if (in_value->GetAsString(&val)) {
config_service->UISetProxyConfigToProxyPerScheme("ftp",
CreateProxyServerFromHost(
val, config.ftp_proxy, net::ProxyServer::SCHEME_HTTP));
}
} else if (path == kProxyFtpPort) {
int val;
if (in_value->GetAsInteger(&val)) {
config_service->UISetProxyConfigToProxyPerScheme("ftp",
CreateProxyServerFromPort(
val, config.ftp_proxy, net::ProxyServer::SCHEME_HTTP));
}
} else if (path == kProxySocks) {
std::string val;
if (in_value->GetAsString(&val)) {
config_service->UISetProxyConfigToProxyPerScheme("socks",
CreateProxyServerFromHost(val, config.socks_proxy,
StartsWithASCII(val, "socks5://", false) ?
net::ProxyServer::SCHEME_SOCKS5 :
net::ProxyServer::SCHEME_SOCKS4));
}
} else if (path == kProxySocksPort) {
int val;
if (in_value->GetAsInteger(&val)) {
std::string host = config.socks_proxy.server.host_port_pair().host();
config_service->UISetProxyConfigToProxyPerScheme("socks",
CreateProxyServerFromPort(val, config.socks_proxy,
StartsWithASCII(host, "socks5://", false) ?
net::ProxyServer::SCHEME_SOCKS5 :
net::ProxyServer::SCHEME_SOCKS4));
}
} else if (path == kProxyIgnoreList) {
net::ProxyBypassRules bypass_rules;
if (in_value->GetType() == Value::TYPE_LIST) {
const ListValue* list_value = static_cast<const ListValue*>(in_value);
for (size_t x = 0; x < list_value->GetSize(); x++) {
std::string val;
if (list_value->GetString(x, &val)) {
bypass_rules.AddRuleFromString(val);
}
}
config_service->UISetProxyConfigBypassRules(bypass_rules);
}
}
}
bool ProxyCrosSettingsProvider::Get(const std::string& path,
Value** out_value) const {
bool found = false;
bool managed = false;
Value* data;
chromeos::ProxyConfigServiceImpl* config_service = GetConfigService();
chromeos::ProxyConfigServiceImpl::ProxyConfig config;
config_service->UIGetProxyConfig(&config);
if (path == kProxyPacUrl) {
if (config.automatic_proxy.pac_url.is_valid()) {
data = Value::CreateStringValue(config.automatic_proxy.pac_url.spec());
found = true;
}
} else if (path == kProxySingleHttp) {
found = (data = CreateServerHostValue(config.single_proxy));
} else if (path == kProxySingleHttpPort) {
found = (data = CreateServerPortValue(config.single_proxy));
} else if (path == kProxyHttpUrl) {
found = (data = CreateServerHostValue(config.http_proxy));
} else if (path == kProxyHttpsUrl) {
found = (data = CreateServerHostValue(config.https_proxy));
} else if (path == kProxyType) {
if (config.mode ==
chromeos::ProxyConfigServiceImpl::ProxyConfig::MODE_AUTO_DETECT ||
config.mode ==
chromeos::ProxyConfigServiceImpl::ProxyConfig::MODE_PAC_SCRIPT) {
data = Value::CreateIntegerValue(3);
} else if (config.mode ==
chromeos::ProxyConfigServiceImpl::ProxyConfig::MODE_SINGLE_PROXY ||
config.mode ==
chromeos::ProxyConfigServiceImpl::ProxyConfig::MODE_PROXY_PER_SCHEME) {
data = Value::CreateIntegerValue(2);
} else {
data = Value::CreateIntegerValue(1);
}
found = true;
} else if (path == kProxySingle) {
data = Value::CreateBooleanValue(config.mode ==
chromeos::ProxyConfigServiceImpl::ProxyConfig::MODE_SINGLE_PROXY);
found = true;
} else if (path == kProxyFtpUrl) {
found = (data = CreateServerHostValue(config.ftp_proxy));
} else if (path == kProxySocks) {
found = (data = CreateServerHostValue(config.socks_proxy));
} else if (path == kProxyHttpPort) {
found = (data = CreateServerPortValue(config.http_proxy));
} else if (path == kProxyHttpsPort) {
found = (data = CreateServerPortValue(config.https_proxy));
} else if (path == kProxyFtpPort) {
found = (data = CreateServerPortValue(config.ftp_proxy));
} else if (path == kProxySocksPort) {
found = (data = CreateServerPortValue(config.socks_proxy));
} else if (path == kProxyIgnoreList) {
ListValue* list = new ListValue();
net::ProxyBypassRules::RuleList bypass_rules = config.bypass_rules.rules();
for (size_t x = 0; x < bypass_rules.size(); x++) {
list->Append(Value::CreateStringValue(bypass_rules[x]->ToString()));
}
*out_value = list;
return true;
}
if (found) {
DictionaryValue* dict = new DictionaryValue;
dict->Set("value", data);
dict->SetBoolean("managed", managed);
*out_value = dict;
return true;
} else {
*out_value = NULL;
return false;
}
}
bool ProxyCrosSettingsProvider::HandlesSetting(const std::string& path) {
return ::StartsWithASCII(path, "cros.session.proxy", true);
}
//----------------- ProxyCrosSettingsProvider: private methods -----------------
chromeos::ProxyConfigServiceImpl*
ProxyCrosSettingsProvider::GetConfigService() const {
return g_browser_process->chromeos_proxy_config_service_impl();
}
net::ProxyServer ProxyCrosSettingsProvider::CreateProxyServerFromHost(
const std::string& host,
const ProxyConfigServiceImpl::ProxyConfig::ManualProxy& proxy,
net::ProxyServer::Scheme scheme) const {
uint16 port = 0;
if (proxy.server.is_valid())
port = proxy.server.host_port_pair().port();
if (host.length() == 0 && port == 0)
return net::ProxyServer();
if (port == 0)
port = net::ProxyServer::GetDefaultPortForScheme(scheme);
net::HostPortPair host_port_pair(host, port);
return net::ProxyServer(scheme, host_port_pair);
}
net::ProxyServer ProxyCrosSettingsProvider::CreateProxyServerFromPort(
uint16 port,
const ProxyConfigServiceImpl::ProxyConfig::ManualProxy& proxy,
net::ProxyServer::Scheme scheme) const {
std::string host;
if (proxy.server.is_valid())
host = proxy.server.host_port_pair().host();
if (host.length() == 0 && port == 0)
return net::ProxyServer();
net::HostPortPair host_port_pair(host, port);
return net::ProxyServer(scheme, host_port_pair);
}
Value* ProxyCrosSettingsProvider::CreateServerHostValue(
const ProxyConfigServiceImpl::ProxyConfig::ManualProxy& proxy) const {
return proxy.server.is_valid() ?
Value::CreateStringValue(proxy.server.host_port_pair().host()) :
NULL;
}
Value* ProxyCrosSettingsProvider::CreateServerPortValue(
const ProxyConfigServiceImpl::ProxyConfig::ManualProxy& proxy) const {
return proxy.server.is_valid() ?
Value::CreateIntegerValue(proxy.server.host_port_pair().port()) :
NULL;
}
} // namespace chromeos