mock_proxy_resolver.h 5.3 KB

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