• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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> 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<Job*>& pending_jobs() const { return pending_jobs_; }
70 
cancelled_jobs()71   const std::vector<std::unique_ptr<Job>>& cancelled_jobs() const {
72     return cancelled_jobs_;
73   }
74 
75   void AddCancelledJob(std::unique_ptr<Job> job);
76   void RemovePendingJob(Job* job);
77 
78  private:
79   std::vector<Job*> pending_jobs_;
80   std::vector<std::unique_ptr<Job>> cancelled_jobs_;
81 };
82 
83 // Asynchronous mock proxy resolver factory . All requests complete
84 // asynchronously; the user must call Request::CompleteNow() on a pending
85 // request to signal it.
86 class MockAsyncProxyResolverFactory : public ProxyResolverFactory {
87  public:
88   class Request;
89   using RequestsList = std::vector<scoped_refptr<Request>>;
90 
91   explicit MockAsyncProxyResolverFactory(bool resolvers_expect_pac_bytes);
92   ~MockAsyncProxyResolverFactory() override;
93 
94   int CreateProxyResolver(
95       const scoped_refptr<PacFileData>& pac_script,
96       std::unique_ptr<ProxyResolver>* resolver,
97       CompletionOnceCallback callback,
98       std::unique_ptr<ProxyResolverFactory::Request>* request) override;
99 
pending_requests()100   const RequestsList& pending_requests() const { return pending_requests_; }
101 
cancelled_requests()102   const RequestsList& cancelled_requests() const { return cancelled_requests_; }
103 
104   void RemovePendingRequest(Request* request);
105 
106  private:
107   class Job;
108   RequestsList pending_requests_;
109   RequestsList cancelled_requests_;
110 };
111 
112 class MockAsyncProxyResolverFactory::Request
113     : public base::RefCounted<Request> {
114  public:
115   Request(MockAsyncProxyResolverFactory* factory,
116           const scoped_refptr<PacFileData>& script_data,
117           std::unique_ptr<ProxyResolver>* resolver,
118           CompletionOnceCallback callback);
119 
script_data()120   const scoped_refptr<PacFileData>& script_data() const { return script_data_; }
121 
122   // Completes this request. A ForwardingProxyResolver that forwards to
123   // |resolver| will be returned to the requester. |resolver| must not be
124   // null and must remain as long as the resolver returned by this request
125   // remains in use.
126   void CompleteNowWithForwarder(int rv, ProxyResolver* resolver);
127 
128   void CompleteNow(int rv, std::unique_ptr<ProxyResolver> resolver);
129 
130  private:
131   friend class base::RefCounted<Request>;
132   friend class MockAsyncProxyResolverFactory;
133   friend class MockAsyncProxyResolverFactory::Job;
134 
135   ~Request();
136 
137   void FactoryDestroyed();
138 
139   raw_ptr<MockAsyncProxyResolverFactory> factory_;
140   const scoped_refptr<PacFileData> script_data_;
141   raw_ptr<std::unique_ptr<ProxyResolver>> resolver_;
142   CompletionOnceCallback callback_;
143 };
144 
145 // ForwardingProxyResolver forwards all requests to |impl|. |impl| must remain
146 // so long as this remains in use.
147 class ForwardingProxyResolver : public ProxyResolver {
148  public:
149   explicit ForwardingProxyResolver(ProxyResolver* impl);
150 
151   ForwardingProxyResolver(const ForwardingProxyResolver&) = delete;
152   ForwardingProxyResolver& operator=(const ForwardingProxyResolver&) = delete;
153 
154   // ProxyResolver overrides.
155   int GetProxyForURL(const GURL& query_url,
156                      const NetworkAnonymizationKey& network_anonymization_key,
157                      ProxyInfo* results,
158                      CompletionOnceCallback callback,
159                      std::unique_ptr<Request>* request,
160                      const NetLogWithSource& net_log) override;
161 
162  private:
163   raw_ptr<ProxyResolver> impl_;
164 };
165 
166 }  // namespace net
167 
168 #endif  // NET_PROXY_RESOLUTION_MOCK_PROXY_RESOLVER_H_
169