mock_proxy_resolver.cc 5.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185
  1. // Copyright (c) 2011 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. #include "net/proxy_resolution/mock_proxy_resolver.h"
  5. #include <memory>
  6. #include <utility>
  7. #include "base/check.h"
  8. namespace net {
  9. MockAsyncProxyResolver::RequestImpl::RequestImpl(std::unique_ptr<Job> job)
  10. : job_(std::move(job)) {
  11. DCHECK(job_);
  12. }
  13. MockAsyncProxyResolver::RequestImpl::~RequestImpl() {
  14. MockAsyncProxyResolver* resolver = job_->Resolver();
  15. // AddCancelledJob will check if request is already cancelled
  16. resolver->AddCancelledJob(std::move(job_));
  17. }
  18. LoadState MockAsyncProxyResolver::RequestImpl::GetLoadState() {
  19. return LOAD_STATE_RESOLVING_PROXY_FOR_URL;
  20. }
  21. MockAsyncProxyResolver::Job::Job(MockAsyncProxyResolver* resolver,
  22. const GURL& url,
  23. ProxyInfo* results,
  24. CompletionOnceCallback callback)
  25. : resolver_(resolver),
  26. url_(url),
  27. results_(results),
  28. callback_(std::move(callback)) {}
  29. MockAsyncProxyResolver::Job::~Job() = default;
  30. void MockAsyncProxyResolver::Job::CompleteNow(int rv) {
  31. CompletionOnceCallback callback = std::move(callback_);
  32. resolver_->RemovePendingJob(this);
  33. std::move(callback).Run(rv);
  34. }
  35. MockAsyncProxyResolver::~MockAsyncProxyResolver() = default;
  36. int MockAsyncProxyResolver::GetProxyForURL(
  37. const GURL& url,
  38. const NetworkIsolationKey& network_isolation_key,
  39. ProxyInfo* results,
  40. CompletionOnceCallback callback,
  41. std::unique_ptr<Request>* request,
  42. const NetLogWithSource& /*net_log*/) {
  43. auto job = std::make_unique<Job>(this, url, results, std::move(callback));
  44. pending_jobs_.push_back(job.get());
  45. *request = std::make_unique<RequestImpl>(std::move(job));
  46. // Test code completes the request by calling job->CompleteNow().
  47. return ERR_IO_PENDING;
  48. }
  49. void MockAsyncProxyResolver::AddCancelledJob(std::unique_ptr<Job> job) {
  50. auto it = std::find(pending_jobs_.begin(), pending_jobs_.end(), job.get());
  51. // Because this is called always when RequestImpl is destructed,
  52. // we need to check if it is still in pending jobs.
  53. if (it != pending_jobs_.end()) {
  54. cancelled_jobs_.push_back(std::move(job));
  55. pending_jobs_.erase(it);
  56. }
  57. }
  58. void MockAsyncProxyResolver::RemovePendingJob(Job* job) {
  59. DCHECK(job);
  60. auto it = std::find(pending_jobs_.begin(), pending_jobs_.end(), job);
  61. DCHECK(it != pending_jobs_.end());
  62. pending_jobs_.erase(it);
  63. }
  64. MockAsyncProxyResolver::MockAsyncProxyResolver() = default;
  65. MockAsyncProxyResolverFactory::Request::Request(
  66. MockAsyncProxyResolverFactory* factory,
  67. const scoped_refptr<PacFileData>& script_data,
  68. std::unique_ptr<ProxyResolver>* resolver,
  69. CompletionOnceCallback callback)
  70. : factory_(factory),
  71. script_data_(script_data),
  72. resolver_(resolver),
  73. callback_(std::move(callback)) {}
  74. MockAsyncProxyResolverFactory::Request::~Request() = default;
  75. void MockAsyncProxyResolverFactory::Request::CompleteNow(
  76. int rv,
  77. std::unique_ptr<ProxyResolver> resolver) {
  78. *resolver_ = std::move(resolver);
  79. // RemovePendingRequest may remove the last external reference to |this|.
  80. scoped_refptr<MockAsyncProxyResolverFactory::Request> keep_alive(this);
  81. factory_->RemovePendingRequest(this);
  82. factory_ = nullptr;
  83. std::move(callback_).Run(rv);
  84. }
  85. void MockAsyncProxyResolverFactory::Request::CompleteNowWithForwarder(
  86. int rv,
  87. ProxyResolver* resolver) {
  88. DCHECK(resolver);
  89. CompleteNow(rv, std::make_unique<ForwardingProxyResolver>(resolver));
  90. }
  91. void MockAsyncProxyResolverFactory::Request::FactoryDestroyed() {
  92. factory_ = nullptr;
  93. }
  94. class MockAsyncProxyResolverFactory::Job
  95. : public ProxyResolverFactory::Request {
  96. public:
  97. explicit Job(
  98. const scoped_refptr<MockAsyncProxyResolverFactory::Request>& request)
  99. : request_(request) {}
  100. ~Job() override {
  101. if (request_->factory_) {
  102. request_->factory_->cancelled_requests_.push_back(request_);
  103. request_->factory_->RemovePendingRequest(request_.get());
  104. }
  105. }
  106. private:
  107. scoped_refptr<MockAsyncProxyResolverFactory::Request> request_;
  108. };
  109. MockAsyncProxyResolverFactory::MockAsyncProxyResolverFactory(
  110. bool resolvers_expect_pac_bytes)
  111. : ProxyResolverFactory(resolvers_expect_pac_bytes) {
  112. }
  113. int MockAsyncProxyResolverFactory::CreateProxyResolver(
  114. const scoped_refptr<PacFileData>& pac_script,
  115. std::unique_ptr<ProxyResolver>* resolver,
  116. CompletionOnceCallback callback,
  117. std::unique_ptr<ProxyResolverFactory::Request>* request_handle) {
  118. auto request = base::MakeRefCounted<Request>(this, pac_script, resolver,
  119. std::move(callback));
  120. pending_requests_.push_back(request);
  121. *request_handle = std::make_unique<Job>(request);
  122. // Test code completes the request by calling request->CompleteNow().
  123. return ERR_IO_PENDING;
  124. }
  125. void MockAsyncProxyResolverFactory::RemovePendingRequest(Request* request) {
  126. auto it =
  127. std::find(pending_requests_.begin(), pending_requests_.end(), request);
  128. DCHECK(it != pending_requests_.end());
  129. pending_requests_.erase(it);
  130. }
  131. MockAsyncProxyResolverFactory::~MockAsyncProxyResolverFactory() {
  132. for (auto& request : pending_requests_) {
  133. request->FactoryDestroyed();
  134. }
  135. }
  136. ForwardingProxyResolver::ForwardingProxyResolver(ProxyResolver* impl)
  137. : impl_(impl) {
  138. }
  139. int ForwardingProxyResolver::GetProxyForURL(
  140. const GURL& query_url,
  141. const NetworkIsolationKey& network_isolation_key,
  142. ProxyInfo* results,
  143. CompletionOnceCallback callback,
  144. std::unique_ptr<Request>* request,
  145. const NetLogWithSource& net_log) {
  146. return impl_->GetProxyForURL(query_url, network_isolation_key, results,
  147. std::move(callback), request, net_log);
  148. }
  149. } // namespace net