| // Copyright 2017 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 IOS_COMPONENTS_IO_THREAD_IOS_IO_THREAD_H_ |
| #define IOS_COMPONENTS_IO_THREAD_IOS_IO_THREAD_H_ |
| |
| #include <stddef.h> |
| #include <stdint.h> |
| |
| #include <map> |
| #include <memory> |
| #include <set> |
| #include <string> |
| #include <vector> |
| |
| #include "base/compiler_specific.h" |
| #include "base/macros.h" |
| #include "base/memory/ref_counted.h" |
| #include "base/memory/weak_ptr.h" |
| #include "components/prefs/pref_member.h" |
| #include "ios/web/public/web_thread_delegate.h" |
| #include "net/base/network_change_notifier.h" |
| #include "net/http/http_network_session.h" |
| |
| class PrefProxyConfigTracker; |
| class PrefService; |
| |
| namespace net { |
| class CTPolicyEnforcer; |
| class CertVerifier; |
| class ChannelIDService; |
| class CookieStore; |
| class CTVerifier; |
| class HostResolver; |
| class HttpAuthHandlerFactory; |
| class HttpAuthPreferences; |
| class HttpServerProperties; |
| class HttpTransactionFactory; |
| class HttpUserAgentSettings; |
| class LoggingNetworkChangeObserver; |
| class NetworkDelegate; |
| class ProxyConfigService; |
| class ProxyResolutionService; |
| class SSLConfigService; |
| class TransportSecurityState; |
| class URLRequestContext; |
| class URLRequestContextGetter; |
| class URLRequestJobFactory; |
| } // namespace net |
| |
| namespace net_log { |
| class ChromeNetLog; |
| } // namespace net_log |
| |
| namespace io_thread { |
| |
| class SystemURLRequestContextGetter; |
| |
| // Contains state associated with, initialized and cleaned up on, and |
| // primarily used on, the IO thread. |
| // |
| // If you are looking to interact with the IO thread (e.g. post tasks |
| // to it or check if it is the current thread), see web::WebThread. |
| class IOSIOThread : public web::WebThreadDelegate { |
| public: |
| struct Globals { |
| template <typename T> |
| class Optional { |
| public: |
| Optional() : set_(false) {} |
| |
| void set(T value) { |
| set_ = true; |
| value_ = value; |
| } |
| void CopyToIfSet(T* value) const { |
| if (set_) { |
| *value = value_; |
| } |
| } |
| |
| private: |
| bool set_; |
| T value_; |
| }; |
| |
| class SystemRequestContextLeakChecker { |
| public: |
| explicit SystemRequestContextLeakChecker(Globals* globals); |
| ~SystemRequestContextLeakChecker(); |
| |
| private: |
| Globals* const globals_; |
| }; |
| |
| Globals(); |
| ~Globals(); |
| |
| // The "system" NetworkDelegate, used for BrowserState-agnostic network |
| // events. |
| std::unique_ptr<net::NetworkDelegate> system_network_delegate; |
| std::unique_ptr<net::HostResolver> host_resolver; |
| std::unique_ptr<net::CertVerifier> cert_verifier; |
| // The ChannelIDService must outlive the HttpTransactionFactory. |
| std::unique_ptr<net::ChannelIDService> system_channel_id_service; |
| // This TransportSecurityState doesn't load or save any state. It's only |
| // used to enforce pinning for system requests and will only use built-in |
| // pins. |
| std::unique_ptr<net::TransportSecurityState> transport_security_state; |
| std::unique_ptr<net::CTVerifier> cert_transparency_verifier; |
| std::unique_ptr<net::SSLConfigService> ssl_config_service; |
| std::unique_ptr<net::HttpAuthPreferences> http_auth_preferences; |
| std::unique_ptr<net::HttpAuthHandlerFactory> http_auth_handler_factory; |
| std::unique_ptr<net::HttpServerProperties> http_server_properties; |
| std::unique_ptr<net::ProxyResolutionService> system_proxy_resolution_service; |
| std::unique_ptr<net::HttpNetworkSession> system_http_network_session; |
| std::unique_ptr<net::HttpTransactionFactory> |
| system_http_transaction_factory; |
| std::unique_ptr<net::URLRequestJobFactory> system_url_request_job_factory; |
| std::unique_ptr<net::URLRequestContext> system_request_context; |
| SystemRequestContextLeakChecker system_request_context_leak_checker; |
| std::unique_ptr<net::CookieStore> system_cookie_store; |
| std::unique_ptr<net::HttpUserAgentSettings> http_user_agent_settings; |
| std::unique_ptr<net::CTPolicyEnforcer> ct_policy_enforcer; |
| }; |
| |
| // |net_log| must either outlive the IOSIOThread or be NULL. |
| IOSIOThread(PrefService* local_state, net_log::ChromeNetLog* net_log); |
| ~IOSIOThread() override; |
| |
| // Can only be called on the IO thread. |
| Globals* globals(); |
| |
| // Allows overriding Globals in tests where IOSIOThread::Init() and |
| // IOSIOThread::CleanUp() are not called. This allows for injecting mocks |
| // into IOSIOThread global objects. |
| void SetGlobalsForTesting(Globals* globals); |
| |
| net_log::ChromeNetLog* net_log(); |
| |
| // Handles changing to On The Record mode, discarding confidential data. |
| void ChangedToOnTheRecord(); |
| |
| // Returns a getter for the URLRequestContext. Only called on the UI thread. |
| net::URLRequestContextGetter* system_url_request_context_getter(); |
| |
| // Clears the host cache. Intended to be used to prevent exposing recently |
| // visited sites on about:net-internals/#dns and about:dns pages. Must be |
| // called on the IO thread. |
| void ClearHostCache(); |
| |
| const net::HttpNetworkSession::Params& NetworkSessionParams() const; |
| |
| protected: |
| // A string describing the current application version. For example: "stable" |
| // or "dev". An empty string is an acceptable value. This string is used to |
| // build the user agent id for QUIC. |
| virtual std::string GetChannelString() const = 0; |
| |
| // Subclasses must return a NetworkDelegate to be used for |
| // BrowserState-agnostic network events. |
| virtual std::unique_ptr<net::NetworkDelegate> |
| CreateSystemNetworkDelegate() = 0; |
| |
| private: |
| // Provide SystemURLRequestContextGetter with access to |
| // InitSystemRequestContext(). |
| friend class SystemURLRequestContextGetter; |
| |
| // WebThreadDelegate implementation, runs on the IO thread. |
| // This handles initialization and destruction of state that must |
| // live on the IO thread. |
| void Init() override; |
| void CleanUp() override; |
| |
| // Sets up HttpAuthPreferences and HttpAuthHandlerFactory on Globals. |
| void CreateDefaultAuthHandlerFactory(); |
| |
| // Discards confidential data. To be called on IO thread only. |
| void ChangedToOnTheRecordOnIOThread(); |
| |
| static net::URLRequestContext* ConstructSystemRequestContext( |
| Globals* globals, |
| const net::HttpNetworkSession::Params& params, |
| net::NetLog* net_log); |
| |
| // The NetLog is owned by the application context, to allow logging from other |
| // threads during shutdown, but is used most frequently on the IO thread. |
| net_log::ChromeNetLog* net_log_; |
| |
| // These member variables are basically global, but their lifetimes are tied |
| // to the IOSIOThread. IOSIOThread owns them all, despite not using |
| // scoped_ptr. This is because the destructor of IOSIOThread runs on the |
| // wrong thread. All member variables should be deleted in CleanUp(). |
| |
| // These member variables are initialized in Init() and do not change for the |
| // lifetime of the IO thread. |
| |
| Globals* globals_; |
| |
| net::HttpNetworkSession::Params params_; |
| |
| // Observer that logs network changes to the ChromeNetLog. |
| std::unique_ptr<net::LoggingNetworkChangeObserver> network_change_observer_; |
| |
| // These member variables are initialized by a task posted to the IO thread, |
| // which gets posted by calling certain member functions of IOSIOThread. |
| std::unique_ptr<net::ProxyConfigService> system_proxy_config_service_; |
| |
| std::unique_ptr<PrefProxyConfigTracker> pref_proxy_config_tracker_; |
| |
| scoped_refptr<SystemURLRequestContextGetter> |
| system_url_request_context_getter_; |
| |
| base::WeakPtrFactory<IOSIOThread> weak_factory_; |
| |
| DISALLOW_COPY_AND_ASSIGN(IOSIOThread); |
| }; |
| |
| } // namespace io_thread |
| |
| #endif // IOS_COMPONENTS_IO_THREAD_IO_THREAD_H_ |