1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
// 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.
#ifndef NET_PROXY_DHCP_PROXY_SCRIPT_FETCHER_WIN_H_
#define NET_PROXY_DHCP_PROXY_SCRIPT_FETCHER_WIN_H_
#include <set>
#include <string>
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_vector.h"
#include "base/message_loop/message_loop_proxy.h"
#include "base/threading/non_thread_safe.h"
#include "base/time/time.h"
#include "base/timer/timer.h"
#include "net/proxy/dhcp_proxy_script_fetcher.h"
namespace base {
class SequencedWorkerPool;
}
namespace net {
class DhcpProxyScriptAdapterFetcher;
class URLRequestContext;
// Windows-specific implementation.
class NET_EXPORT_PRIVATE DhcpProxyScriptFetcherWin
: public DhcpProxyScriptFetcher,
public base::SupportsWeakPtr<DhcpProxyScriptFetcherWin>,
NON_EXPORTED_BASE(public base::NonThreadSafe) {
public:
// Creates a DhcpProxyScriptFetcherWin that issues requests through
// |url_request_context|. |url_request_context| must remain valid for
// the lifetime of DhcpProxyScriptFetcherWin.
explicit DhcpProxyScriptFetcherWin(URLRequestContext* url_request_context);
~DhcpProxyScriptFetcherWin() override;
// DhcpProxyScriptFetcher implementation.
int Fetch(base::string16* utf16_text,
const CompletionCallback& callback) override;
void Cancel() override;
const GURL& GetPacURL() const override;
std::string GetFetcherName() const override;
// Sets |adapter_names| to contain the name of each network adapter on
// this machine that has DHCP enabled and is not a loop-back adapter. Returns
// false on error.
static bool GetCandidateAdapterNames(std::set<std::string>* adapter_names);
protected:
int num_pending_fetchers() const;
URLRequestContext* url_request_context() const;
scoped_refptr<base::TaskRunner> GetTaskRunner();
// This inner class encapsulate work done on a worker pool thread.
// The class calls GetCandidateAdapterNames, which can take a couple of
// hundred milliseconds.
class NET_EXPORT_PRIVATE AdapterQuery
: public base::RefCountedThreadSafe<AdapterQuery> {
public:
AdapterQuery();
virtual ~AdapterQuery();
// This is the method that runs on the worker pool thread.
void GetCandidateAdapterNames();
// This set is valid after GetCandidateAdapterNames has
// been run. Its lifetime is scoped by this object.
const std::set<std::string>& adapter_names() const;
protected:
// Virtual method introduced to allow unit testing.
virtual bool ImplGetCandidateAdapterNames(
std::set<std::string>* adapter_names);
private:
// This is constructed on the originating thread, then used on the
// worker thread, then used again on the originating thread only when
// the task has completed on the worker thread. No locking required.
std::set<std::string> adapter_names_;
DISALLOW_COPY_AND_ASSIGN(AdapterQuery);
};
// Virtual methods introduced to allow unit testing.
virtual DhcpProxyScriptAdapterFetcher* ImplCreateAdapterFetcher();
virtual AdapterQuery* ImplCreateAdapterQuery();
virtual base::TimeDelta ImplGetMaxWait();
virtual void ImplOnGetCandidateAdapterNamesDone() {}
private:
// Event/state transition handlers
void CancelImpl();
void OnGetCandidateAdapterNamesDone(scoped_refptr<AdapterQuery> query);
void OnFetcherDone(int result);
void OnWaitTimer();
void TransitionToDone();
// This is the outer state machine for fetching PAC configuration from
// DHCP. It relies for sub-states on the state machine of the
// DhcpProxyScriptAdapterFetcher class.
//
// The goal of the implementation is to the following work in parallel
// for all network adapters that are using DHCP:
// a) Try to get the PAC URL configured in DHCP;
// b) If one is configured, try to fetch the PAC URL.
// c) Once this is done for all adapters, or a timeout has passed after
// it has completed for the fastest adapter, return the PAC file
// available for the most preferred network adapter, if any.
//
// The state machine goes from START->WAIT_ADAPTERS when it starts a
// worker thread to get the list of adapters with DHCP enabled.
// It then goes from WAIT_ADAPTERS->NO_RESULTS when it creates
// and starts an DhcpProxyScriptAdapterFetcher for each adapter. It goes
// from NO_RESULTS->SOME_RESULTS when it gets the first result; at this
// point a wait timer is started. It goes from SOME_RESULTS->DONE in
// two cases: All results are known, or the wait timer expired. A call
// to Cancel() will also go straight to DONE from any state. Any
// way the DONE state is entered, we will at that point cancel any
// outstanding work and return the best known PAC script or the empty
// string.
//
// The state machine is reset for each Fetch(), a call to which is
// only valid in states START and DONE, as only one Fetch() is
// allowed to be outstanding at any given time.
enum State {
STATE_START,
STATE_WAIT_ADAPTERS,
STATE_NO_RESULTS,
STATE_SOME_RESULTS,
STATE_DONE,
};
// Current state of this state machine.
State state_;
// Vector, in Windows' network adapter preference order, of
// DhcpProxyScriptAdapterFetcher objects that are or were attempting
// to fetch a PAC file based on DHCP configuration.
typedef ScopedVector<DhcpProxyScriptAdapterFetcher> FetcherVector;
FetcherVector fetchers_;
// Number of fetchers we are waiting for.
int num_pending_fetchers_;
// Lets our client know we're done. Not valid in states START or DONE.
CompletionCallback callback_;
// Pointer to string we will write results to. Not valid in states
// START and DONE.
base::string16* destination_string_;
// PAC URL retrieved from DHCP, if any. Valid only in state STATE_DONE.
GURL pac_url_;
base::OneShotTimer<DhcpProxyScriptFetcherWin> wait_timer_;
URLRequestContext* const url_request_context_;
// NULL or the AdapterQuery currently in flight.
scoped_refptr<AdapterQuery> last_query_;
// Time |Fetch()| was last called, 0 if never.
base::TimeTicks fetch_start_time_;
// Worker pool we use for all DHCP lookup tasks.
scoped_refptr<base::SequencedWorkerPool> worker_pool_;
DISALLOW_IMPLICIT_CONSTRUCTORS(DhcpProxyScriptFetcherWin);
};
} // namespace net
#endif // NET_PROXY_DHCP_PROXY_SCRIPT_FETCHER_WIN_H_
|
