1 // Copyright 2012 The Chromium Authors 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef NET_PROXY_RESOLUTION_MOCK_PROXY_RESOLVER_H_ 6 #define NET_PROXY_RESOLUTION_MOCK_PROXY_RESOLVER_H_ 7 8 #include <memory> 9 #include <vector> 10 11 #include "base/memory/raw_ptr.h" 12 #include "net/base/completion_once_callback.h" 13 #include "net/base/net_errors.h" 14 #include "net/base/network_anonymization_key.h" 15 #include "net/proxy_resolution/proxy_resolver.h" 16 #include "net/proxy_resolution/proxy_resolver_factory.h" 17 #include "url/gurl.h" 18 19 namespace net { 20 21 // Asynchronous mock proxy resolver. All requests complete asynchronously, 22 // user must call Job::CompleteNow() on a pending request to signal it. 23 class MockAsyncProxyResolver : public ProxyResolver { 24 public: 25 class Job { 26 public: 27 Job(MockAsyncProxyResolver* resolver, 28 const GURL& url, 29 ProxyInfo* results, 30 CompletionOnceCallback callback); 31 url()32 const GURL& url() const { return url_; } results()33 ProxyInfo* results() const { return results_; } Resolver()34 MockAsyncProxyResolver* Resolver() const { return resolver_; } 35 36 void CompleteNow(int rv); 37 38 ~Job(); 39 40 private: 41 raw_ptr<MockAsyncProxyResolver> resolver_; 42 const GURL url_; 43 raw_ptr<ProxyInfo, DanglingUntriaged> results_; 44 CompletionOnceCallback callback_; 45 }; 46 47 class RequestImpl : public ProxyResolver::Request { 48 public: 49 explicit RequestImpl(std::unique_ptr<Job> job); 50 51 ~RequestImpl() override; 52 53 LoadState GetLoadState() override; 54 55 private: 56 std::unique_ptr<Job> job_; 57 }; 58 59 MockAsyncProxyResolver(); 60 ~MockAsyncProxyResolver() override; 61 62 // ProxyResolver implementation. 63 int GetProxyForURL(const GURL& url, 64 const NetworkAnonymizationKey& network_anonymization_key, 65 ProxyInfo* results, 66 CompletionOnceCallback callback, 67 std::unique_ptr<Request>* request, 68 const NetLogWithSource& /*net_log*/) override; pending_jobs()69 const std::vector<raw_ptr<Job, VectorExperimental>>& pending_jobs() const { 70 return pending_jobs_; 71 } 72 cancelled_jobs()73 const std::vector<std::unique_ptr<Job>>& cancelled_jobs() const { 74 return cancelled_jobs_; 75 } 76 77 void AddCancelledJob(std::unique_ptr<Job> job); 78 void RemovePendingJob(Job* job); 79 80 private: 81 std::vector<raw_ptr<Job, VectorExperimental>> pending_jobs_; 82 std::vector<std::unique_ptr<Job>> cancelled_jobs_; 83 }; 84 85 // Asynchronous mock proxy resolver factory . All requests complete 86 // asynchronously; the user must call Request::CompleteNow() on a pending 87 // request to signal it. 88 class MockAsyncProxyResolverFactory : public ProxyResolverFactory { 89 public: 90 class Request; 91 using RequestsList = std::vector<scoped_refptr<Request>>; 92 93 explicit MockAsyncProxyResolverFactory(bool resolvers_expect_pac_bytes); 94 ~MockAsyncProxyResolverFactory() override; 95 96 int CreateProxyResolver( 97 const scoped_refptr<PacFileData>& pac_script, 98 std::unique_ptr<ProxyResolver>* resolver, 99 CompletionOnceCallback callback, 100 std::unique_ptr<ProxyResolverFactory::Request>* request) override; 101 pending_requests()102 const RequestsList& pending_requests() const { return pending_requests_; } 103 cancelled_requests()104 const RequestsList& cancelled_requests() const { return cancelled_requests_; } 105 106 void RemovePendingRequest(Request* request); 107 108 private: 109 class Job; 110 RequestsList pending_requests_; 111 RequestsList cancelled_requests_; 112 }; 113 114 class MockAsyncProxyResolverFactory::Request 115 : public base::RefCounted<Request> { 116 public: 117 Request(MockAsyncProxyResolverFactory* factory, 118 const scoped_refptr<PacFileData>& script_data, 119 std::unique_ptr<ProxyResolver>* resolver, 120 CompletionOnceCallback callback); 121 script_data()122 const scoped_refptr<PacFileData>& script_data() const { return script_data_; } 123 124 // Completes this request. A ForwardingProxyResolver that forwards to 125 // |resolver| will be returned to the requester. |resolver| must not be 126 // null and must remain as long as the resolver returned by this request 127 // remains in use. 128 void CompleteNowWithForwarder(int rv, ProxyResolver* resolver); 129 130 void CompleteNow(int rv, std::unique_ptr<ProxyResolver> resolver); 131 132 private: 133 friend class base::RefCounted<Request>; 134 friend class MockAsyncProxyResolverFactory; 135 friend class MockAsyncProxyResolverFactory::Job; 136 137 ~Request(); 138 139 void FactoryDestroyed(); 140 141 raw_ptr<MockAsyncProxyResolverFactory> factory_; 142 const scoped_refptr<PacFileData> script_data_; 143 raw_ptr<std::unique_ptr<ProxyResolver>> resolver_; 144 CompletionOnceCallback callback_; 145 }; 146 147 // ForwardingProxyResolver forwards all requests to |impl|. |impl| must remain 148 // so long as this remains in use. 149 class ForwardingProxyResolver : public ProxyResolver { 150 public: 151 explicit ForwardingProxyResolver(ProxyResolver* impl); 152 153 ForwardingProxyResolver(const ForwardingProxyResolver&) = delete; 154 ForwardingProxyResolver& operator=(const ForwardingProxyResolver&) = delete; 155 156 // ProxyResolver overrides. 157 int GetProxyForURL(const GURL& query_url, 158 const NetworkAnonymizationKey& network_anonymization_key, 159 ProxyInfo* results, 160 CompletionOnceCallback callback, 161 std::unique_ptr<Request>* request, 162 const NetLogWithSource& net_log) override; 163 164 private: 165 raw_ptr<ProxyResolver> impl_; 166 }; 167 168 } // namespace net 169 170 #endif // NET_PROXY_RESOLUTION_MOCK_PROXY_RESOLVER_H_ 171