services/proxy_resolver/mock_proxy_host_resolver.cc

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