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.
5 #ifndef NET_PROXY_PROXY_SERVICE_H_
6 #define NET_PROXY_PROXY_SERVICE_H_
11 #include "base/gtest_prod_util.h"
12 #include "base/memory/ref_counted.h"
13 #include "base/memory/scoped_ptr.h"
14 #include "base/synchronization/waitable_event.h"
15 #include "base/threading/non_thread_safe.h"
16 #include "net/base/completion_callback.h"
17 #include "net/base/load_states.h"
18 #include "net/base/net_export.h"
19 #include "net/base/net_log.h"
20 #include "net/base/network_change_notifier.h"
21 #include "net/proxy/proxy_config_service.h"
22 #include "net/proxy/proxy_info.h"
23 #include "net/proxy/proxy_server.h"
29 class SingleThreadTaskRunner
;
35 class DhcpProxyScriptFetcher
;
37 class NetworkDelegate
;
39 class ProxyResolverScriptData
;
40 class ProxyScriptDecider
;
41 class ProxyScriptFetcher
;
43 // This class can be used to resolve the proxy server to use when loading a
44 // HTTP(S) URL. It uses the given ProxyResolver to handle the actual proxy
45 // resolution. See ProxyResolverV8 for example.
46 class NET_EXPORT ProxyService
: public NetworkChangeNotifier::IPAddressObserver
,
47 public NetworkChangeNotifier::DNSObserver
,
48 public ProxyConfigService::Observer
,
49 NON_EXPORTED_BASE(public base::NonThreadSafe
) {
51 static const size_t kDefaultNumPacThreads
= 4;
53 // This interface defines the set of policies for when to poll the PAC
54 // script for changes.
56 // The polling policy decides what the next poll delay should be in
57 // milliseconds. It also decides how to wait for this delay -- either
58 // by starting a timer to do the poll at exactly |next_delay_ms|
59 // (MODE_USE_TIMER) or by waiting for the first network request issued after
60 // |next_delay_ms| (MODE_START_AFTER_ACTIVITY).
62 // The timer method is more precise and guarantees that polling happens when
63 // it was requested. However it has the disadvantage of causing spurious CPU
64 // and network activity. It is a reasonable choice to use for short poll
65 // intervals which only happen a couple times.
67 // However for repeated timers this will prevent the browser from going
68 // idle. MODE_START_AFTER_ACTIVITY solves this problem by only polling in
69 // direct response to network activity. The drawback to
70 // MODE_START_AFTER_ACTIVITY is since the poll is initiated only after the
71 // request is received, the first couple requests initiated after a long
72 // period of inactivity will likely see a stale version of the PAC script
73 // until the background polling gets a chance to update things.
74 class NET_EXPORT_PRIVATE PacPollPolicy
{
78 MODE_START_AFTER_ACTIVITY
,
81 virtual ~PacPollPolicy() {}
83 // Decides the next poll delay. |current_delay| is the delay used
84 // by the preceding poll, or a negative TimeDelta value if determining
85 // the delay for the initial poll. |initial_error| is the network error
86 // code that the last PAC fetch (or WPAD initialization) failed with,
87 // or OK if it completed successfully. Implementations must set
88 // |next_delay| to a non-negative value.
89 virtual Mode
GetNextDelay(int initial_error
,
90 base::TimeDelta current_delay
,
91 base::TimeDelta
* next_delay
) const = 0;
94 // The instance takes ownership of |config_service| and |resolver|.
95 // |net_log| is a possibly NULL destination to send log events to. It must
96 // remain alive for the lifetime of this ProxyService.
97 ProxyService(ProxyConfigService
* config_service
,
98 ProxyResolver
* resolver
,
101 virtual ~ProxyService();
103 // Used internally to handle PAC queries.
104 // TODO(eroman): consider naming this simply "Request".
107 // Returns ERR_IO_PENDING if the proxy information could not be provided
108 // synchronously, to indicate that the result will be available when the
109 // callback is run. The callback is run on the thread that calls
112 // The caller is responsible for ensuring that |results| and |callback|
113 // remain valid until the callback is run or until |pac_request| is cancelled
114 // via CancelPacRequest. |pac_request| is only valid while the completion
115 // callback is still pending. NULL can be passed for |pac_request| if
116 // the caller will not need to cancel the request.
118 // We use the three possible proxy access types in the following order,
119 // doing fallback if one doesn't work. See "pac_script_decider.h"
120 // for the specifics.
121 // 1. WPAD auto-detection
125 // Profiling information for the request is saved to |net_log| if non-NULL.
126 int ResolveProxy(const GURL
& url
,
128 const net::CompletionCallback
& callback
,
129 PacRequest
** pac_request
,
130 const BoundNetLog
& net_log
);
132 // This method is called after a failure to connect or resolve a host name.
133 // It gives the proxy service an opportunity to reconsider the proxy to use.
134 // The |results| parameter contains the results returned by an earlier call
135 // to ResolveProxy. The |net_error| parameter contains the network error
136 // code associated with the failure. See "net/base/net_error_list.h" for a
137 // list of possible values. The semantics of this call are otherwise
138 // similar to ResolveProxy.
140 // NULL can be passed for |pac_request| if the caller will not need to
141 // cancel the request.
143 // Returns ERR_FAILED if there is not another proxy config to try.
145 // Profiling information for the request is saved to |net_log| if non-NULL.
146 int ReconsiderProxyAfterError(const GURL
& url
,
149 const CompletionCallback
& callback
,
150 PacRequest
** pac_request
,
151 const BoundNetLog
& net_log
);
153 // Explicitly trigger proxy fallback for the given |results| by updating our
154 // list of bad proxies to include the first entry of |results|, and,
155 // optionally, another bad proxy. Will retry after |retry_delay| if positive,
156 // and will use the default proxy retry duration otherwise. Proxies marked as
157 // bad will not be retried until |retry_delay| has passed. Returns true if
158 // there will be at least one proxy remaining in the list after fallback and
160 bool MarkProxiesAsBadUntil(const ProxyInfo
& results
,
161 base::TimeDelta retry_delay
,
162 const ProxyServer
& another_bad_proxy
,
163 const BoundNetLog
& net_log
);
165 // Called to report that the last proxy connection succeeded. If |proxy_info|
166 // has a non empty proxy_retry_info map, the proxies that have been tried (and
167 // failed) for this request will be marked as bad.
168 void ReportSuccess(const ProxyInfo
& proxy_info
);
170 // Call this method with a non-null |pac_request| to cancel the PAC request.
171 void CancelPacRequest(PacRequest
* pac_request
);
173 // Returns the LoadState for this |pac_request| which must be non-NULL.
174 LoadState
GetLoadState(const PacRequest
* pac_request
) const;
176 // Sets the ProxyScriptFetcher and DhcpProxyScriptFetcher dependencies. This
177 // is needed if the ProxyResolver is of type ProxyResolverWithoutFetch.
178 // ProxyService takes ownership of both objects.
179 void SetProxyScriptFetchers(
180 ProxyScriptFetcher
* proxy_script_fetcher
,
181 DhcpProxyScriptFetcher
* dhcp_proxy_script_fetcher
);
182 ProxyScriptFetcher
* GetProxyScriptFetcher() const;
184 // Tells this ProxyService to start using a new ProxyConfigService to
185 // retrieve its ProxyConfig from. The new ProxyConfigService will immediately
186 // be queried for new config info which will be used for all subsequent
187 // ResolveProxy calls. ProxyService takes ownership of
188 // |new_proxy_config_service|.
189 void ResetConfigService(ProxyConfigService
* new_proxy_config_service
);
191 // Returns the last configuration fetched from ProxyConfigService.
192 const ProxyConfig
& fetched_config() {
193 return fetched_config_
;
196 // Returns the current configuration being used by ProxyConfigService.
197 const ProxyConfig
& config() {
201 // Returns the map of proxies which have been marked as "bad".
202 const ProxyRetryInfoMap
& proxy_retry_info() const {
203 return proxy_retry_info_
;
206 // Clears the list of bad proxy servers that has been cached.
207 void ClearBadProxiesCache() {
208 proxy_retry_info_
.clear();
211 // Forces refetching the proxy configuration, and applying it.
212 // This re-does everything from fetching the system configuration,
213 // to downloading and testing the PAC files.
214 void ForceReloadProxyConfig();
216 // Same as CreateProxyServiceUsingV8ProxyResolver, except it uses system
217 // libraries for evaluating the PAC script if available, otherwise skips
219 static ProxyService
* CreateUsingSystemProxyResolver(
220 ProxyConfigService
* proxy_config_service
,
221 size_t num_pac_threads
,
224 // Creates a ProxyService without support for proxy autoconfig.
225 static ProxyService
* CreateWithoutProxyResolver(
226 ProxyConfigService
* proxy_config_service
,
229 // Convenience methods that creates a proxy service using the
230 // specified fixed settings.
231 static ProxyService
* CreateFixed(const ProxyConfig
& pc
);
232 static ProxyService
* CreateFixed(const std::string
& proxy
);
234 // Creates a proxy service that uses a DIRECT connection for all requests.
235 static ProxyService
* CreateDirect();
236 // |net_log|'s lifetime must exceed ProxyService.
237 static ProxyService
* CreateDirectWithNetLog(NetLog
* net_log
);
239 // This method is used by tests to create a ProxyService that returns a
240 // hardcoded proxy fallback list (|pac_string|) for every URL.
242 // |pac_string| is a list of proxy servers, in the format that a PAC script
243 // would return it. For example, "PROXY foobar:99; SOCKS fml:2; DIRECT"
244 static ProxyService
* CreateFixedFromPacResult(const std::string
& pac_string
);
246 // Creates a config service appropriate for this platform that fetches the
247 // system proxy settings.
248 static ProxyConfigService
* CreateSystemProxyConfigService(
249 base::SingleThreadTaskRunner
* io_thread_task_runner
,
250 base::MessageLoop
* file_loop
);
252 // This method should only be used by unit tests.
253 void set_stall_proxy_auto_config_delay(base::TimeDelta delay
) {
254 stall_proxy_auto_config_delay_
= delay
;
257 // This method should only be used by unit tests. Returns the previously
259 static const PacPollPolicy
* set_pac_script_poll_policy(
260 const PacPollPolicy
* policy
);
262 // This method should only be used by unit tests. Creates an instance
263 // of the default internal PacPollPolicy used by ProxyService.
264 static scoped_ptr
<PacPollPolicy
> CreateDefaultPacPollPolicy();
266 void set_quick_check_enabled(bool value
) {
267 quick_check_enabled_
= value
;
270 bool quick_check_enabled() const { return quick_check_enabled_
; }
272 #if defined(SPDY_PROXY_AUTH_ORIGIN)
273 // Values of the UMA DataReductionProxy.BypassInfo{Primary|Fallback}
274 // histograms. This enum must remain synchronized with the enum of the same
275 // name in metrics/histograms/histograms.xml.
276 enum DataReductionProxyBypassEventType
{
277 // Bypass the proxy for less than 30 minutes.
280 // Bypass the proxy for 30 minutes or more.
283 // Bypass the proxy because of an internal server error.
284 INTERNAL_SERVER_ERROR_BYPASS
,
286 // Bypass the proxy because of any other error.
289 // Bypass the proxy because responses appear not to be coming via it.
292 // Bypass the proxy because the proxy, not the origin, sent a 4xx response.
295 // This must always be last.
296 BYPASS_EVENT_TYPE_MAX
299 // Records a |DataReductionProxyBypassEventType| for either the data reduction
300 // proxy (|is_primary| is true) or the data reduction proxy fallback.
301 void RecordDataReductionProxyBypassInfo(
303 const ProxyServer
& proxy_server
,
304 DataReductionProxyBypassEventType bypass_type
) const;
306 // Records a net error code that resulted in bypassing the data reduction
307 // proxy (|is_primary| is true) or the data reduction proxy fallback.
308 void RecordDataReductionProxyBypassOnNetworkError(
310 const ProxyServer
& proxy_server
,
315 FRIEND_TEST_ALL_PREFIXES(ProxyServiceTest
, UpdateConfigAfterFailedAutodetect
);
316 FRIEND_TEST_ALL_PREFIXES(ProxyServiceTest
, UpdateConfigFromPACToDirect
);
317 friend class PacRequest
;
318 class InitProxyResolver
;
319 class ProxyScriptDeciderPoller
;
321 // TODO(eroman): change this to a std::set. Note that this requires updating
322 // some tests in proxy_service_unittest.cc such as:
323 // ProxyServiceTest.InitialPACScriptDownload
324 // which expects requests to finish in the order they were added.
325 typedef std::vector
<scoped_refptr
<PacRequest
> > PendingRequests
;
329 STATE_WAITING_FOR_PROXY_CONFIG
,
330 STATE_WAITING_FOR_INIT_PROXY_RESOLVER
,
334 // Resets all the variables associated with the current proxy configuration,
335 // and rewinds the current state to |STATE_NONE|. Returns the previous value
336 // of |current_state_|. If |reset_fetched_config| is true then
337 // |fetched_config_| will also be reset, otherwise it will be left as-is.
338 // Resetting it means that we will have to re-fetch the configuration from
339 // the ProxyConfigService later.
340 State
ResetProxyConfig(bool reset_fetched_config
);
342 // Retrieves the current proxy configuration from the ProxyConfigService, and
343 // starts initializing for it.
344 void ApplyProxyConfigIfAvailable();
346 // Callback for when the proxy resolver has been initialized with a
348 void OnInitProxyResolverComplete(int result
);
350 // Returns ERR_IO_PENDING if the request cannot be completed synchronously.
351 // Otherwise it fills |result| with the proxy information for |url|.
352 // Completing synchronously means we don't need to query ProxyResolver.
353 int TryToCompleteSynchronously(const GURL
& url
, ProxyInfo
* result
);
355 // Cancels all of the requests sent to the ProxyResolver. These will be
356 // restarted when calling SetReady().
357 void SuspendAllPendingRequests();
359 // Advances the current state to |STATE_READY|, and resumes any pending
360 // requests which had been stalled waiting for initialization to complete.
363 // Returns true if |pending_requests_| contains |req|.
364 bool ContainsPendingRequest(PacRequest
* req
);
366 // Removes |req| from the list of pending requests.
367 void RemovePendingRequest(PacRequest
* req
);
369 // Called when proxy resolution has completed (either synchronously or
370 // asynchronously). Handles logging the result, and cleaning out
371 // bad entries from the results list.
372 int DidFinishResolvingProxy(ProxyInfo
* result
,
374 const BoundNetLog
& net_log
);
376 // Start initialization using |fetched_config_|.
377 void InitializeUsingLastFetchedConfig();
379 // Start the initialization skipping past the "decision" phase.
380 void InitializeUsingDecidedConfig(
382 ProxyResolverScriptData
* script_data
,
383 const ProxyConfig
& effective_config
);
385 // NetworkChangeNotifier::IPAddressObserver
386 // When this is called, we re-fetch PAC scripts and re-run WPAD.
387 virtual void OnIPAddressChanged() OVERRIDE
;
389 // NetworkChangeNotifier::DNSObserver
390 // We respond as above.
391 virtual void OnDNSChanged() OVERRIDE
;
393 // ProxyConfigService::Observer
394 virtual void OnProxyConfigChanged(
395 const ProxyConfig
& config
,
396 ProxyConfigService::ConfigAvailability availability
) OVERRIDE
;
398 scoped_ptr
<ProxyConfigService
> config_service_
;
399 scoped_ptr
<ProxyResolver
> resolver_
;
401 // We store the proxy configuration that was last fetched from the
402 // ProxyConfigService, as well as the resulting "effective" configuration.
403 // The effective configuration is what we condense the original fetched
404 // settings to after testing the various automatic settings (auto-detect
405 // and custom PAC url).
406 ProxyConfig fetched_config_
;
409 // Increasing ID to give to the next ProxyConfig that we set.
412 // The time when the proxy configuration was last read from the system.
413 base::TimeTicks config_last_update_time_
;
415 // Map of the known bad proxies and the information about the retry time.
416 ProxyRetryInfoMap proxy_retry_info_
;
418 // Set of pending/inprogress requests.
419 PendingRequests pending_requests_
;
421 // The fetcher to use when downloading PAC scripts for the ProxyResolver.
422 // This dependency can be NULL if our ProxyResolver has no need for
423 // external PAC script fetching.
424 scoped_ptr
<ProxyScriptFetcher
> proxy_script_fetcher_
;
426 // The fetcher to use when attempting to download the most appropriate PAC
427 // script configured in DHCP, if any. Can be NULL if the ProxyResolver has
428 // no need for DHCP PAC script fetching.
429 scoped_ptr
<DhcpProxyScriptFetcher
> dhcp_proxy_script_fetcher_
;
431 // Helper to download the PAC script (wpad + custom) and apply fallback rules.
433 // Note that the declaration is important here: |proxy_script_fetcher_| and
434 // |proxy_resolver_| must outlive |init_proxy_resolver_|.
435 scoped_ptr
<InitProxyResolver
> init_proxy_resolver_
;
437 // Helper to poll the PAC script for changes.
438 scoped_ptr
<ProxyScriptDeciderPoller
> script_poller_
;
440 State current_state_
;
442 // Either OK or an ERR_* value indicating that a permanent error (e.g.
443 // failed to fetch the PAC script) prevents proxy resolution.
444 int permanent_error_
;
446 // This is the log where any events generated by |init_proxy_resolver_| are
450 // The earliest time at which we should run any proxy auto-config. (Used to
451 // stall re-configuration following an IP address change).
452 base::TimeTicks stall_proxy_autoconfig_until_
;
454 // The amount of time to stall requests following IP address changes.
455 base::TimeDelta stall_proxy_auto_config_delay_
;
457 // Whether child ProxyScriptDeciders should use QuickCheck
458 bool quick_check_enabled_
;
460 DISALLOW_COPY_AND_ASSIGN(ProxyService
);
463 // Wrapper for invoking methods on a ProxyService synchronously.
464 class NET_EXPORT SyncProxyServiceHelper
465 : public base::RefCountedThreadSafe
<SyncProxyServiceHelper
> {
467 SyncProxyServiceHelper(base::MessageLoop
* io_message_loop
,
468 ProxyService
* proxy_service
);
470 int ResolveProxy(const GURL
& url
,
471 ProxyInfo
* proxy_info
,
472 const BoundNetLog
& net_log
);
473 int ReconsiderProxyAfterError(const GURL
& url
,
475 ProxyInfo
* proxy_info
,
476 const BoundNetLog
& net_log
);
479 friend class base::RefCountedThreadSafe
<SyncProxyServiceHelper
>;
481 virtual ~SyncProxyServiceHelper();
483 void StartAsyncResolve(const GURL
& url
, const BoundNetLog
& net_log
);
484 void StartAsyncReconsider(const GURL
& url
,
486 const BoundNetLog
& net_log
);
488 void OnCompletion(int result
);
490 base::MessageLoop
* io_message_loop_
;
491 ProxyService
* proxy_service_
;
493 base::WaitableEvent event_
;
494 CompletionCallback callback_
;
495 ProxyInfo proxy_info_
;
501 #endif // NET_PROXY_PROXY_SERVICE_H_