mock_proxy_host_resolver.cc 4.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142
  1. // Copyright 2019 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 "services/proxy_resolver/mock_proxy_host_resolver.h"
  5. #include "base/callback.h"
  6. #include "base/check.h"
  7. #include "base/location.h"
  8. #include "base/memory/raw_ptr.h"
  9. #include "base/memory/weak_ptr.h"
  10. #include "base/threading/thread_task_runner_handle.h"
  11. #include "net/base/completion_once_callback.h"
  12. #include "net/base/net_errors.h"
  13. #include "net/base/network_isolation_key.h"
  14. namespace proxy_resolver {
  15. class MockProxyHostResolver::RequestImpl
  16. : public Request,
  17. public base::SupportsWeakPtr<RequestImpl> {
  18. public:
  19. RequestImpl(std::vector<net::IPAddress> results, bool synchronous_mode)
  20. : results_(std::move(results)), synchronous_mode_(synchronous_mode) {}
  21. ~RequestImpl() override = default;
  22. int Start(net::CompletionOnceCallback callback) override {
  23. if (!synchronous_mode_) {
  24. callback_ = std::move(callback);
  25. base::ThreadTaskRunnerHandle::Get()->PostTask(
  26. FROM_HERE, base::BindOnce(&RequestImpl::SendResults, AsWeakPtr()));
  27. return net::ERR_IO_PENDING;
  28. }
  29. if (results_.empty())
  30. return net::ERR_NAME_NOT_RESOLVED;
  31. return net::OK;
  32. }
  33. const std::vector<net::IPAddress>& GetResults() const override {
  34. DCHECK(!callback_);
  35. return results_;
  36. }
  37. private:
  38. void SendResults() {
  39. if (results_.empty())
  40. std::move(callback_).Run(net::ERR_NAME_NOT_RESOLVED);
  41. else
  42. std::move(callback_).Run(net::OK);
  43. }
  44. const std::vector<net::IPAddress> results_;
  45. const bool synchronous_mode_;
  46. net::CompletionOnceCallback callback_;
  47. };
  48. MockProxyHostResolver::MockProxyHostResolver(bool synchronous_mode)
  49. : num_resolve_(0), fail_all_(false), synchronous_mode_(synchronous_mode) {}
  50. MockProxyHostResolver::~MockProxyHostResolver() = default;
  51. std::unique_ptr<ProxyHostResolver::Request>
  52. MockProxyHostResolver::CreateRequest(
  53. const std::string& hostname,
  54. net::ProxyResolveDnsOperation operation,
  55. const net::NetworkIsolationKey& network_isolation_key) {
  56. ++num_resolve_;
  57. if (fail_all_)
  58. return std::make_unique<RequestImpl>(std::vector<net::IPAddress>(),
  59. synchronous_mode_);
  60. auto match = results_.find({hostname, operation, network_isolation_key});
  61. if (match == results_.end())
  62. return std::make_unique<RequestImpl>(
  63. std::vector<net::IPAddress>({net::IPAddress(127, 0, 0, 1)}),
  64. synchronous_mode_);
  65. return std::make_unique<RequestImpl>(match->second, synchronous_mode_);
  66. }
  67. void MockProxyHostResolver::SetError(
  68. const std::string& hostname,
  69. net::ProxyResolveDnsOperation operation,
  70. const net::NetworkIsolationKey& network_isolation_key) {
  71. fail_all_ = false;
  72. results_[{hostname, operation, network_isolation_key}].clear();
  73. }
  74. void MockProxyHostResolver::SetResult(
  75. const std::string& hostname,
  76. net::ProxyResolveDnsOperation operation,
  77. const net::NetworkIsolationKey& network_isolation_key,
  78. std::vector<net::IPAddress> result) {
  79. DCHECK(!result.empty());
  80. fail_all_ = false;
  81. results_[{hostname, operation, network_isolation_key}] = std::move(result);
  82. }
  83. void MockProxyHostResolver::FailAll() {
  84. results_.clear();
  85. fail_all_ = true;
  86. }
  87. class HangingProxyHostResolver::RequestImpl : public Request {
  88. public:
  89. explicit RequestImpl(HangingProxyHostResolver* resolver)
  90. : resolver_(resolver) {}
  91. ~RequestImpl() override { ++resolver_->num_cancelled_requests_; }
  92. int Start(net::CompletionOnceCallback callback) override {
  93. if (resolver_->hang_callback_)
  94. resolver_->hang_callback_.Run();
  95. return net::ERR_IO_PENDING;
  96. }
  97. const std::vector<net::IPAddress>& GetResults() const override {
  98. IMMEDIATE_CRASH();
  99. }
  100. private:
  101. raw_ptr<HangingProxyHostResolver> resolver_;
  102. };
  103. HangingProxyHostResolver::HangingProxyHostResolver(
  104. base::RepeatingClosure hang_callback)
  105. : num_cancelled_requests_(0), hang_callback_(std::move(hang_callback)) {}
  106. HangingProxyHostResolver::~HangingProxyHostResolver() = default;
  107. std::unique_ptr<ProxyHostResolver::Request>
  108. HangingProxyHostResolver::CreateRequest(
  109. const std::string& hostname,
  110. net::ProxyResolveDnsOperation operation,
  111. const net::NetworkIsolationKey& network_isolation_key) {
  112. return std::make_unique<RequestImpl>(this);
  113. }
  114. } // namespace proxy_resolver