// Copyright (c) 2006-2008 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 "net/proxy/proxy_service.h"
#include <algorithm>
#include "base/compiler_specific.h"
#include "base/logging.h"
#include "base/message_loop.h"
#include "base/string_util.h"
#include "googleurl/src/gurl.h"
#include "net/base/load_log.h"
#include "net/base/net_errors.h"
#include "net/base/net_util.h"
#include "net/proxy/init_proxy_resolver.h"
#include "net/proxy/proxy_config_service_fixed.h"
#include "net/proxy/proxy_script_fetcher.h"
#if defined(OS_WIN)
#include "net/proxy/proxy_config_service_win.h"
#include "net/proxy/proxy_resolver_winhttp.h"
#elif defined(OS_MACOSX)
#include "net/proxy/proxy_config_service_mac.h"
#include "net/proxy/proxy_resolver_mac.h"
#elif defined(OS_LINUX)
#include "net/proxy/proxy_config_service_linux.h"
#endif
#include "net/proxy/proxy_resolver.h"
#include "net/proxy/proxy_resolver_js_bindings.h"
#include "net/proxy/proxy_resolver_v8.h"
#include "net/proxy/single_threaded_proxy_resolver.h"
#include "net/url_request/url_request_context.h"
using base::TimeDelta;
using base::TimeTicks;
namespace net {
static const size_t kMaxNumLoadLogEntries = 100;
// Config getter that fails every time.
class ProxyConfigServiceNull : public ProxyConfigService {
public:
// ProxyConfigService implementation:
virtual int GetProxyConfig(ProxyConfig* config) {
return ERR_NOT_IMPLEMENTED;
}
};
// Proxy resolver that fails every time.
class ProxyResolverNull : public ProxyResolver {
public:
ProxyResolverNull() : ProxyResolver(false /*expects_pac_bytes*/) {}
// ProxyResolver implementation:
virtual int GetProxyForURL(const GURL& url,
ProxyInfo* results,
CompletionCallback* callback,
RequestHandle* request,
LoadLog* load_log) {
return ERR_NOT_IMPLEMENTED;
}
virtual void CancelRequest(RequestHandle request) {
NOTREACHED();
}
private:
virtual int SetPacScript(const GURL& /*pac_url*/,
const std::string& /*pac_bytes*/,
CompletionCallback* /*callback*/) {
return ERR_NOT_IMPLEMENTED;
}
};
// ProxyService::PacRequest ---------------------------------------------------
class ProxyService::PacRequest
: public base::RefCounted<ProxyService::PacRequest> {
public:
PacRequest(ProxyService* service,
const GURL& url,
ProxyInfo* results,
CompletionCallback* user_callback,
LoadLog* load_log)
: service_(service),
user_callback_(user_callback),
ALLOW_THIS_IN_INITIALIZER_LIST(io_callback_(
this, &PacRequest::QueryComplete)),
results_(results),
url_(url),
resolve_job_(NULL),
config_id_(ProxyConfig::INVALID_ID),
load_log_(load_log) {
DCHECK(user_callback);
}
// Starts the resolve proxy request.
int Start() {
DCHECK(!was_cancelled());
DCHECK(!is_started());
config_id_ = service_->config_.id();
return resolver()->GetProxyForURL(
url_, results_, &io_callback_, &resolve_job_, load_log_);
}
bool is_started() const {
// Note that !! casts to bool. (VS gives a warning otherwise).
return !!resolve_job_;
}
void StartAndCompleteCheckingForSynchronous() {
int rv = service_->TryToCompleteSynchronously(url_, results_);
if (rv == ERR_IO_PENDING)
rv = Start();
if (rv != ERR_IO_PENDING)
QueryComplete(rv);
}
void CancelResolveJob() {
DCHECK(is_started());
// The request may already be running in the resolver.
resolver()->CancelRequest(resolve_job_);
resolve_job_ = NULL;
DCHECK(!is_started());
}
void Cancel() {
LoadLog::AddEvent(load_log_, LoadLog::TYPE_CANCELLED);
if (is_started())
CancelResolveJob();
// Mark as cancelled, to prevent accessing this again later.
service_ = NULL;
user_callback_ = NULL;
results_ = NULL;
LoadLog::EndEvent(load_log_, LoadLog::TYPE_PROXY_SERVICE);
}
// Returns true if Cancel() has been called.
bool was_cancelled() const { return user_callback_ == NULL; }
// Helper to call after ProxyResolver completion (both synchronous and
// asynchronous). Fixes up the result that is to be returned to user.
int QueryDidComplete(int result_code) {
DCHECK(!was_cancelled());
// Make a note in the results which configuration was in use at the
// time of the resolve.
results_->config_id_ = config_id_;
// Reset the state associated with in-progress-resolve.
resolve_job_ = NULL;
config_id_ = ProxyConfig::INVALID_ID;
return service_->DidFinishResolvingProxy(results_, result_code, load_log_);
}
LoadLog* load_log() const { return load_log_; }
private:
friend class base::RefCounted<ProxyService::PacRequest>;
~PacRequest() {}
// Callback for when the ProxyResolver request has completed.
void QueryComplete(int result_code) {
result_code = QueryDidComplete(result_code);
// Remove this completed PacRequest from the service's pending list.
/// (which will probably cause deletion of |this|).
CompletionCallback* callback = user_callback_;
service_->RemovePendingRequest(this);
callback->Run(result_code);
}
ProxyResolver* resolver() const { return service_->resolver_.get(); }
// Note that we don't hold a reference to the ProxyService. Outstanding
// requests are cancelled during ~ProxyService, so this is guaranteed
// to be valid throughout our lifetime.
ProxyService* service_;
CompletionCallback* user_callback_;
CompletionCallbackImpl<PacRequest> io_callback_;
ProxyInfo* results_;
GURL url_;
ProxyResolver::RequestHandle resolve_job_;
ProxyConfig::ID config_id_; // The config id when the resolve was started.
scoped_refptr<LoadLog> load_log_;
};
// ProxyService ---------------------------------------------------------------
ProxyService::ProxyService(ProxyConfigService* config_service,
ProxyResolver* resolver,
NetworkChangeNotifier* network_change_notifier)
: config_service_(config_service),
resolver_(resolver),
next_config_id_(1),
should_use_proxy_resolver_(false),
ALLOW_THIS_IN_INITIALIZER_LIST(init_proxy_resolver_callback_(
this, &ProxyService::OnInitProxyResolverComplete)),
network_change_notifier_(network_change_notifier) {
// Register to receive network change notifications.
if (network_change_notifier_)
network_change_notifier_->AddObserver(this);
}
// static
ProxyService* ProxyService::Create(
ProxyConfigService* proxy_config_service,
bool use_v8_resolver,
URLRequestContext* url_request_context,
NetworkChangeNotifier* network_change_notifier,
MessageLoop* io_loop) {
ProxyResolver* proxy_resolver;
if (use_v8_resolver) {
// Send javascript errors and alerts to LOG(INFO).
HostResolver* host_resolver = url_request_context->host_resolver();
ProxyResolverJSBindings* js_bindings =
ProxyResolverJSBindings::CreateDefault(host_resolver, io_loop);
proxy_resolver = new ProxyResolverV8(js_bindings);
} else {
proxy_resolver = CreateNonV8ProxyResolver();
}
// Wrap the (synchronous) ProxyResolver implementation in a single-threaded
// runner. This will dispatch requests to a threadpool of size 1.
proxy_resolver = new SingleThreadedProxyResolver(proxy_resolver);
ProxyService* proxy_service = new ProxyService(
proxy_config_service, proxy_resolver, network_change_notifier);
if (proxy_resolver->expects_pac_bytes()) {
// Configure PAC script downloads to be issued using |url_request_context|.
DCHECK(url_request_context);
proxy_service->SetProxyScriptFetcher(
ProxyScriptFetcher::Create(url_request_context));
}
return proxy_service;
}
// static
ProxyService* ProxyService::CreateFixed(const ProxyConfig& pc) {
return Create(new ProxyConfigServiceFixed(pc), false, NULL, NULL, NULL);
}
// static
ProxyService* ProxyService::CreateNull() {
// Use a configuration fetcher and proxy resolver which always fail.
return new ProxyService(new ProxyConfigServiceNull,
new ProxyResolverNull,
NULL);
}
int ProxyService::ResolveProxy(const GURL& raw_url,
ProxyInfo* result,
CompletionCallback* callback,
PacRequest** pac_request,
LoadLog* load_log) {
DCHECK(callback);
LoadLog::BeginEvent(load_log, LoadLog::TYPE_PROXY_SERVICE);
// Strip away any reference fragments and the username/password, as they
// are not relevant to proxy resolution.
GURL url = SimplifyUrlForRequest(raw_url);
// Check if the request can be completed right away. This is the case when
// using a direct connection, or when the config is bad.
UpdateConfigIfOld(load_log);
int rv = TryToCompleteSynchronously(url, result);
if (rv != ERR_IO_PENDING)
return DidFinishResolvingProxy(result, rv, load_log);
scoped_refptr<PacRequest> req =
new PacRequest(this, url, result, callback, load_log);
bool resolver_is_ready = !IsInitializingProxyResolver();
if (resolver_is_ready) {
// Start the resolve request.
rv = req->Start();
if (rv != ERR_IO_PENDING)
return req->QueryDidComplete(rv);
} else {
LoadLog::BeginEvent(req->load_log(),
LoadLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC);
}
DCHECK_EQ(ERR_IO_PENDING, rv);
DCHECK(!ContainsPendingRequest(req));
pending_requests_.push_back(req);
// Completion will be notifed through |callback|, unless the caller cancels
// the request using |pac_request|.
if (pac_request)
*pac_request = req.get();
return rv; // ERR_IO_PENDING
}
int ProxyService::TryToCompleteSynchronously(const GURL& url,
ProxyInfo* result) {
result->config_id_ = config_.id();
DCHECK(config_.id() != ProxyConfig::INVALID_ID);
if (should_use_proxy_resolver_ || IsInitializingProxyResolver()) {
// May need to go through ProxyResolver for this.
return ERR_IO_PENDING;
}
if (!config_.proxy_rules.empty()) {
ApplyProxyRules(url, config_.proxy_rules, result);
return OK;
}
// otherwise, we have no proxy config
result->UseDirect();
return OK;
}
void ProxyService::ApplyProxyRules(const GURL& url,
const ProxyConfig::ProxyRules& proxy_rules,
ProxyInfo* result) {
DCHECK(!proxy_rules.empty());
if (ShouldBypassProxyForURL(url)) {
result->UseDirect();
return;
}
switch (proxy_rules.type) {
case ProxyConfig::ProxyRules::TYPE_SINGLE_PROXY:
result->UseProxyServer(proxy_rules.single_proxy);
break;
case ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME: {
const ProxyServer* entry = proxy_rules.MapUrlSchemeToProxy(url.scheme());
if (entry) {
result->UseProxyServer(*entry);
} else {
// We failed to find a matching proxy server for the current URL
// scheme. Default to direct.
result->UseDirect();
}
break;
}
default:
result->UseDirect();
NOTREACHED();
break;
}
}
ProxyService::~ProxyService() {
// Unregister to receive network change notifications.
if (network_change_notifier_)
network_change_notifier_->RemoveObserver(this);
// Cancel any inprogress requests.
for (PendingRequests::iterator it = pending_requests_.begin();
it != pending_requests_.end();
++it) {
(*it)->Cancel();
}
}
void ProxyService::SuspendAllPendingRequests() {
for (PendingRequests::iterator it = pending_requests_.begin();
it != pending_requests_.end();
++it) {
PacRequest* req = it->get();
if (req->is_started()) {
req->CancelResolveJob();
LoadLog::BeginEvent(req->load_log(),
LoadLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC);
}
}
}
void ProxyService::ResumeAllPendingRequests() {
DCHECK(!IsInitializingProxyResolver());
// Make a copy in case |this| is deleted during the synchronous completion
// of one of the requests. If |this| is deleted then all of the PacRequest
// instances will be Cancel()-ed.
PendingRequests pending_copy = pending_requests_;
for (PendingRequests::iterator it = pending_copy.begin();
it != pending_copy.end();
++it) {
PacRequest* req = it->get();
if (!req->is_started() && !req->was_cancelled()) {
LoadLog::EndEvent(req->load_log(),
LoadLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC);
// Note that we re-check for synchronous completion, in case we are
// no longer using a ProxyResolver (can happen if we fell-back to manual).
req->StartAndCompleteCheckingForSynchronous();
}
}
}
void ProxyService::OnInitProxyResolverComplete(int result) {
DCHECK(init_proxy_resolver_.get());
DCHECK(config_.MayRequirePACResolver());
DCHECK(!should_use_proxy_resolver_);
init_proxy_resolver_.reset();
should_use_proxy_resolver_ = result == OK;
if (result != OK) {
LOG(INFO) << "Failed configuring with PAC script, falling-back to manual "
"proxy servers.";
}
// Resume any requests which we had to defer until the PAC script was
// downloaded.
ResumeAllPendingRequests();
}
int ProxyService::ReconsiderProxyAfterError(const GURL& url,
ProxyInfo* result,
CompletionCallback* callback,
PacRequest** pac_request,
LoadLog* load_log) {
// Check to see if we have a new config since ResolveProxy was called. We
// want to re-run ResolveProxy in two cases: 1) we have a new config, or 2) a
// direct connection failed and we never tried the current config.
bool re_resolve = result->config_id_ != config_.id();
if (!re_resolve) {
UpdateConfig(load_log);
if (result->config_id_ != config_.id()) {
// A new configuration!
re_resolve = true;
}
}
if (re_resolve) {
// If we have a new config or the config was never tried, we delete the
// list of bad proxies and we try again.
proxy_retry_info_.clear();
return ResolveProxy(url, result, callback, pac_request, load_log);
}
// We don't have new proxy settings to try, try to fallback to the next proxy
// in the list.
bool did_fallback = result->Fallback(&proxy_retry_info_);
// Return synchronous failure if there is nothing left to fall-back to.
// TODO(eroman): This is a yucky API, clean it up.
return did_fallback ? OK : ERR_FAILED;
}
void ProxyService::CancelPacRequest(PacRequest* req) {
DCHECK(req);
req->Cancel();
RemovePendingRequest(req);
}
bool ProxyService::ContainsPendingRequest(PacRequest* req) {
PendingRequests::iterator it = std::find(
pending_requests_.begin(), pending_requests_.end(), req);
return pending_requests_.end() != it;
}
void ProxyService::RemovePendingRequest(PacRequest* req) {
DCHECK(ContainsPendingRequest(req));
PendingRequests::iterator it = std::find(
pending_requests_.begin(), pending_requests_.end(), req);
pending_requests_.erase(it);
}
int ProxyService::DidFinishResolvingProxy(ProxyInfo* result,
int result_code,
LoadLog* load_log) {
// Log the result of the proxy resolution.
if (result_code == OK) {
// When full logging is enabled, dump the proxy list.
if (LoadLog::IsUnbounded(load_log)) {
LoadLog::AddString(
load_log,
std::string("Resolved proxy list: ") + result->ToPacString());
}
} else {
LoadLog::AddErrorCode(load_log, result_code);
}
// Clean up the results list.
if (result_code == OK)
result->DeprioritizeBadProxies(proxy_retry_info_);
LoadLog::EndEvent(load_log, LoadLog::TYPE_PROXY_SERVICE);
return result_code;
}
void ProxyService::SetProxyScriptFetcher(
ProxyScriptFetcher* proxy_script_fetcher) {
if (init_proxy_resolver_.get()) {
// We need to be careful to first cancel |init_proxy_resolver_|, since it
// holds a pointer to the old proxy script fetcher we are about to delete.
DCHECK(IsInitializingProxyResolver());
init_proxy_resolver_.reset();
proxy_script_fetcher_.reset(proxy_script_fetcher);
// Restart the initialization, using the new proxy script fetcher.
StartInitProxyResolver();
} else {
proxy_script_fetcher_.reset(proxy_script_fetcher);
}
}
ProxyScriptFetcher* ProxyService::GetProxyScriptFetcher() const {
return proxy_script_fetcher_.get();
}
void ProxyService::ResetConfigService(
ProxyConfigService* new_proxy_config_service) {
config_service_.reset(new_proxy_config_service);
UpdateConfig(NULL);
}
void ProxyService::PurgeMemory() {
if (resolver_.get())
resolver_->PurgeMemory();
}
void ProxyService::ForceReloadProxyConfig() {
// Mark the current configuration as being un-initialized, then force it to
// start updating (normally this would happen lazily during the next
// call to ResolveProxy()).
config_.set_id(ProxyConfig::INVALID_ID);
UpdateConfig(NULL);
}
// static
ProxyConfigService* ProxyService::CreateSystemProxyConfigService(
MessageLoop* io_loop, MessageLoop* file_loop) {
#if defined(OS_WIN)
return new ProxyConfigServiceWin();
#elif defined(OS_MACOSX)
return new ProxyConfigServiceMac();
#elif defined(OS_LINUX)
ProxyConfigServiceLinux* linux_config_service
= new ProxyConfigServiceLinux();
// Assume we got called from the UI loop, which runs the default
// glib main loop, so the current thread is where we should be
// running gconf calls from.
MessageLoop* glib_default_loop = MessageLoopForUI::current();
// The file loop should be a MessageLoopForIO on Linux.
DCHECK_EQ(MessageLoop::TYPE_IO, file_loop->type());
// Synchronously fetch the current proxy config (since we are
// running on glib_default_loop). Additionally register for
// notifications (delivered in either |glib_default_loop| or
// |file_loop|) to keep us updated when the proxy config changes.
linux_config_service->SetupAndFetchInitialConfig(glib_default_loop, io_loop,
static_cast<MessageLoopForIO*>(file_loop));
return linux_config_service;
#else
LOG(WARNING) << "Failed to choose a system proxy settings fetcher "
"for this platform.";
return new ProxyConfigServiceNull();
#endif
}
// static
ProxyResolver* ProxyService::CreateNonV8ProxyResolver() {
#if defined(OS_WIN)
return new ProxyResolverWinHttp();
#elif defined(OS_MACOSX)
return new ProxyResolverMac();
#else
LOG(WARNING) << "PAC support disabled because there is no fallback "
"non-V8 implementation";
return new ProxyResolverNull();
#endif
}
void ProxyService::UpdateConfig(LoadLog* load_log) {
bool is_first_update = !config_has_been_initialized();
ProxyConfig latest;
// Fetch the proxy settings.
TimeTicks start_time = TimeTicks::Now();
LoadLog::BeginEvent(load_log,
LoadLog::TYPE_PROXY_SERVICE_POLL_CONFIG_SERVICE_FOR_CHANGES);
int rv = config_service_->GetProxyConfig(&latest);
LoadLog::EndEvent(load_log,
LoadLog::TYPE_PROXY_SERVICE_POLL_CONFIG_SERVICE_FOR_CHANGES);
TimeTicks end_time = TimeTicks::Now();
// Record how long the call to config_service_->GetConfig() above took.
// On some setups of Windows, we have reports that querying the system
// proxy settings can take multiple seconds (http://crbug.com/12189).
UMA_HISTOGRAM_CUSTOM_TIMES("Net.ProxyPollConfigurationTime",
end_time - start_time,
TimeDelta::FromMilliseconds(1),
TimeDelta::FromSeconds(30),
50);
if (rv != OK) {
if (is_first_update) {
// Default to direct-connection if the first fetch fails.
LOG(INFO) << "Failed initial proxy configuration fetch.";
SetConfig(ProxyConfig());
}
return;
}
config_last_update_time_ = TimeTicks::Now();
if (!is_first_update && latest.Equals(config_))
return;
SetConfig(latest);
}
void ProxyService::SetConfig(const ProxyConfig& config) {
config_ = config;
// Increment the ID to reflect that the config has changed.
config_.set_id(next_config_id_++);
// Reset state associated with latest config.
proxy_retry_info_.clear();
// Cancel any PAC fetching / ProxyResolver::SetPacScript() which was
// in progress for the previous configuration.
init_proxy_resolver_.reset();
should_use_proxy_resolver_ = false;
// Start downloading + testing the PAC scripts for this new configuration.
if (config_.MayRequirePACResolver()) {
// Since InitProxyResolver will be playing around with the proxy resolver
// as it tests the parsing of various PAC scripts, make sure there is
// nothing in-flight in |resolver_|. These paused requests are resumed by
// OnInitProxyResolverComplete().
SuspendAllPendingRequests();
// Calls OnInitProxyResolverComplete() on completion.
StartInitProxyResolver();
}
}
void ProxyService::StartInitProxyResolver() {
DCHECK(!init_proxy_resolver_.get());
init_proxy_resolver_.reset(
new InitProxyResolver(resolver_.get(), proxy_script_fetcher_.get()));
init_proxy_resolver_log_ = new LoadLog(kMaxNumLoadLogEntries);
int rv = init_proxy_resolver_->Init(
config_, &init_proxy_resolver_callback_, init_proxy_resolver_log_);
if (rv != ERR_IO_PENDING)
OnInitProxyResolverComplete(rv);
}
void ProxyService::UpdateConfigIfOld(LoadLog* load_log) {
// The overhead of calling ProxyConfigService::GetProxyConfig is very low.
const TimeDelta kProxyConfigMaxAge = TimeDelta::FromSeconds(5);
// Periodically check for a new config.
if (!config_has_been_initialized() ||
(TimeTicks::Now() - config_last_update_time_) > kProxyConfigMaxAge)
UpdateConfig(load_log);
}
bool ProxyService::ShouldBypassProxyForURL(const GURL& url) {
std::string url_domain = url.scheme();
if (!url_domain.empty())
url_domain += "://";
url_domain += url.host();
// This isn't superfluous; GURL case canonicalization doesn't hit the embedded
// percent-encoded characters.
StringToLowerASCII(&url_domain);
// TODO(eroman): use GetHostAndPort().
std::string url_domain_and_port = url_domain + ":"
+ IntToString(url.EffectiveIntPort());
if (config_.proxy_bypass_local_names && IsLocalName(url))
return true;
for(std::vector<std::string>::const_iterator i = config_.proxy_bypass.begin();
i != config_.proxy_bypass.end(); ++i) {
std::string bypass_url_domain = *i;
// The proxy server bypass list can contain entities with http/https
// If no scheme is specified then it indicates that all schemes are
// allowed for the current entry. For matching this we just use
// the protocol scheme of the url passed in.
size_t scheme_colon = bypass_url_domain.find("://");
if (scheme_colon == std::string::npos) {
std::string bypass_url_domain_with_scheme = url.scheme();
scheme_colon = bypass_url_domain_with_scheme.length();
bypass_url_domain_with_scheme += "://";
bypass_url_domain_with_scheme += bypass_url_domain;
bypass_url_domain = bypass_url_domain_with_scheme;
}
std::string* url_compare_reference = &url_domain;
size_t port_colon = bypass_url_domain.rfind(":");
if (port_colon > scheme_colon) {
// If our match pattern includes a colon followed by a digit,
// and either it's preceded by ']' (IPv6 with port)
// or has no other colon (IPv4),
// then match against <domain>:<port>.
// TODO(sdoyon): straighten this out, in particular the IPv6 brackets,
// and do the parsing in ProxyConfig when we do the CIDR matching
// mentioned below.
std::string::const_iterator domain_begin =
bypass_url_domain.begin() + scheme_colon + 3; // after ://
std::string::const_iterator port_iter =
bypass_url_domain.begin() + port_colon;
std::string::const_iterator end = bypass_url_domain.end();
if ((port_iter + 1) < end && IsAsciiDigit(*(port_iter + 1)) &&
(*(port_iter - 1) == ']' ||
std::find(domain_begin, port_iter, ':') == port_iter))
url_compare_reference = &url_domain_and_port;
}
StringToLowerASCII(&bypass_url_domain);
if (MatchPatternASCII(*url_compare_reference, bypass_url_domain))
return true;
// Some systems (the Mac, for example) allow CIDR-style specification of
// proxy bypass for IP-specified hosts (e.g. "10.0.0.0/8"; see
// http://www.tcd.ie/iss/internet/osx_proxy.php for a real-world example).
// That's kinda cool so we'll provide that for everyone.
// TODO(avi): implement here. See: http://crbug.com/9835.
// IP addresses ought to be canonicalized for comparison (whether
// with CIDR, port, or IP address alone).
}
return false;
}
// This matches IE's interpretation of the
// "Bypass proxy server for local addresses" settings checkbox. Fully
// qualified domain names or IP addresses are considered non-local,
// regardless of what they map to.
//
// static
bool ProxyService::IsLocalName(const GURL& url) {
const std::string& host = url.host();
if (host == "127.0.0.1" || host == "[::1]")
return true;
return host.find('.') == std::string::npos;
}
void ProxyService::OnIPAddressChanged() {
DCHECK(network_change_notifier_);
// Mark the current configuration as being un-initialized.
//
// This will force us to re-fetch the configuration (and re-run all of
// the initialization steps) on the next ResolveProxy() request, as part
// of UpdateConfigIfOld().
config_.set_id(ProxyConfig::INVALID_ID);
}
SyncProxyServiceHelper::SyncProxyServiceHelper(MessageLoop* io_message_loop,
ProxyService* proxy_service)
: io_message_loop_(io_message_loop),
proxy_service_(proxy_service),
event_(false, false),
ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
this, &SyncProxyServiceHelper::OnCompletion)) {
DCHECK(io_message_loop_ != MessageLoop::current());
}
int SyncProxyServiceHelper::ResolveProxy(const GURL& url,
ProxyInfo* proxy_info,
LoadLog* load_log) {
DCHECK(io_message_loop_ != MessageLoop::current());
io_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
this, &SyncProxyServiceHelper::StartAsyncResolve, url, load_log));
event_.Wait();
if (result_ == net::OK) {
*proxy_info = proxy_info_;
}
return result_;
}
int SyncProxyServiceHelper::ReconsiderProxyAfterError(
const GURL& url, ProxyInfo* proxy_info, LoadLog* load_log) {
DCHECK(io_message_loop_ != MessageLoop::current());
io_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
this, &SyncProxyServiceHelper::StartAsyncReconsider, url, load_log));
event_.Wait();
if (result_ == net::OK) {
*proxy_info = proxy_info_;
}
return result_;
}
void SyncProxyServiceHelper::StartAsyncResolve(const GURL& url,
LoadLog* load_log) {
result_ = proxy_service_->ResolveProxy(
url, &proxy_info_, &callback_, NULL, load_log);
if (result_ != net::ERR_IO_PENDING) {
OnCompletion(result_);
}
}
void SyncProxyServiceHelper::StartAsyncReconsider(const GURL& url,
LoadLog* load_log) {
result_ = proxy_service_->ReconsiderProxyAfterError(
url, &proxy_info_, &callback_, NULL, load_log);
if (result_ != net::ERR_IO_PENDING) {
OnCompletion(result_);
}
}
void SyncProxyServiceHelper::OnCompletion(int rv) {
result_ = rv;
event_.Signal();
}
} // namespace net