| // 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_ADAPTER_FETCHER_WIN_H_ |
| #define NET_PROXY_DHCP_PROXY_SCRIPT_ADAPTER_FETCHER_WIN_H_ |
| |
| #include <string> |
| |
| #include "base/memory/ref_counted.h" |
| #include "base/memory/scoped_ptr.h" |
| #include "base/memory/weak_ptr.h" |
| #include "base/strings/string16.h" |
| #include "base/threading/non_thread_safe.h" |
| #include "base/timer/timer.h" |
| #include "net/base/completion_callback.h" |
| #include "net/base/net_export.h" |
| #include "url/gurl.h" |
| |
| namespace base { |
| class TaskRunner; |
| } |
| |
| namespace net { |
| |
| class ProxyScriptFetcher; |
| class URLRequestContext; |
| |
| // For a given adapter, this class takes care of first doing a DHCP lookup |
| // to get the PAC URL, then if there is one, trying to fetch it. |
| class NET_EXPORT_PRIVATE DhcpProxyScriptAdapterFetcher |
| : public base::SupportsWeakPtr<DhcpProxyScriptAdapterFetcher>, |
| NON_EXPORTED_BASE(public base::NonThreadSafe) { |
| public: |
| // |url_request_context| must outlive DhcpProxyScriptAdapterFetcher. |
| // |task_runner| will be used to post tasks to a thread. |
| DhcpProxyScriptAdapterFetcher(URLRequestContext* url_request_context, |
| scoped_refptr<base::TaskRunner> task_runner); |
| virtual ~DhcpProxyScriptAdapterFetcher(); |
| |
| // Starts a fetch. On completion (but not cancellation), |callback| |
| // will be invoked with the network error indicating success or failure |
| // of fetching a DHCP-configured PAC file on this adapter. |
| // |
| // On completion, results can be obtained via |GetPacScript()|, |GetPacURL()|. |
| // |
| // You may only call Fetch() once on a given instance of |
| // DhcpProxyScriptAdapterFetcher. |
| virtual void Fetch(const std::string& adapter_name, |
| const net::CompletionCallback& callback); |
| |
| // Cancels the fetch on this adapter. |
| virtual void Cancel(); |
| |
| // Returns true if in the FINISH state (not CANCEL). |
| virtual bool DidFinish() const; |
| |
| // Returns the network error indicating the result of the fetch. Will |
| // return IO_PENDING until the fetch is complete or cancelled. This is |
| // the same network error passed to the |callback| provided to |Fetch()|. |
| virtual int GetResult() const; |
| |
| // Returns the contents of the PAC file retrieved. Only valid if |
| // |IsComplete()| is true. Returns the empty string if |GetResult()| |
| // returns anything other than OK. |
| virtual base::string16 GetPacScript() const; |
| |
| // Returns the PAC URL retrieved from DHCP. Only guaranteed to be |
| // valid if |IsComplete()| is true. Returns an empty URL if no URL was |
| // configured in DHCP. May return a valid URL even if |result()| does |
| // not return OK (this would indicate that we found a URL configured in |
| // DHCP but failed to download it). |
| virtual GURL GetPacURL() const; |
| |
| // Returns the PAC URL configured in DHCP for the given |adapter_name|, or |
| // the empty string if none is configured. |
| // |
| // This function executes synchronously due to limitations of the Windows |
| // DHCP client API. |
| static std::string GetPacURLFromDhcp(const std::string& adapter_name); |
| |
| // Sanitizes a string returned via the DHCP API. |
| static std::string SanitizeDhcpApiString(const char* data, |
| size_t count_bytes); |
| |
| protected: |
| // This is the state machine for fetching from a given adapter. |
| // |
| // The state machine goes from START->WAIT_DHCP when it starts |
| // a worker thread to fetch the PAC URL from DHCP. |
| // |
| // In state WAIT_DHCP, if the DHCP query finishes and has no URL, it |
| // moves to state FINISH. If there is a URL, it starts a |
| // ProxyScriptFetcher to fetch it and moves to state WAIT_URL. |
| // |
| // It goes from WAIT_URL->FINISH when the ProxyScriptFetcher completes. |
| // |
| // In state FINISH, completion is indicated to the outer class, with |
| // the results of the fetch if a PAC script was successfully fetched. |
| // |
| // In state WAIT_DHCP, our timeout occurring can push us to FINISH. |
| // |
| // In any state except FINISH, a call to Cancel() will move to state |
| // CANCEL and cause all outstanding work to be cancelled or its |
| // results ignored when available. |
| enum State { |
| STATE_START, |
| STATE_WAIT_DHCP, |
| STATE_WAIT_URL, |
| STATE_FINISH, |
| STATE_CANCEL, |
| }; |
| |
| State state() const; |
| |
| // This inner class encapsulates work done on a worker pool thread. |
| // By using a separate object, we can keep the main object completely |
| // thread safe and let it be non-refcounted. |
| class NET_EXPORT_PRIVATE DhcpQuery |
| : public base::RefCountedThreadSafe<DhcpQuery> { |
| public: |
| DhcpQuery(); |
| virtual ~DhcpQuery(); |
| |
| // This method should run on a worker pool thread, via PostTaskAndReply. |
| // After it has run, the |url()| method on this object will return the |
| // URL retrieved. |
| void GetPacURLForAdapter(const std::string& adapter_name); |
| |
| // Returns the URL retrieved for the given adapter, once the task has run. |
| const std::string& url() const; |
| |
| protected: |
| // Virtual method introduced to allow unit testing. |
| virtual std::string ImplGetPacURLFromDhcp(const std::string& adapter_name); |
| |
| private: |
| // The URL retrieved for the given adapter. |
| std::string url_; |
| |
| DISALLOW_COPY_AND_ASSIGN(DhcpQuery); |
| }; |
| |
| // Virtual methods introduced to allow unit testing. |
| virtual ProxyScriptFetcher* ImplCreateScriptFetcher(); |
| virtual DhcpQuery* ImplCreateDhcpQuery(); |
| virtual base::TimeDelta ImplGetTimeout() const; |
| |
| private: |
| // Event/state transition handlers |
| void OnDhcpQueryDone(scoped_refptr<DhcpQuery> dhcp_query); |
| void OnTimeout(); |
| void OnFetcherDone(int result); |
| void TransitionToFinish(); |
| |
| // TaskRunner for posting tasks to a worker thread. |
| scoped_refptr<base::TaskRunner> task_runner_; |
| |
| // Current state of this state machine. |
| State state_; |
| |
| // A network error indicating result of operation. |
| int result_; |
| |
| // Empty string or the PAC script downloaded. |
| base::string16 pac_script_; |
| |
| // Empty URL or the PAC URL configured in DHCP. |
| GURL pac_url_; |
| |
| // Callback to let our client know we're done. Invalid in states |
| // START, FINISH and CANCEL. |
| net::CompletionCallback callback_; |
| |
| // Fetcher to retrieve PAC files once URL is known. |
| scoped_ptr<ProxyScriptFetcher> script_fetcher_; |
| |
| // Implements a timeout on the call to the Win32 DHCP API. |
| base::OneShotTimer<DhcpProxyScriptAdapterFetcher> wait_timer_; |
| |
| URLRequestContext* const url_request_context_; |
| |
| DISALLOW_IMPLICIT_CONSTRUCTORS(DhcpProxyScriptAdapterFetcher); |
| }; |
| |
| } // namespace net |
| |
| #endif // NET_PROXY_DHCP_PROXY_SCRIPT_ADAPTER_FETCHER_WIN_H_ |