| // Copyright 2019 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "net/proxy_resolution/mock_proxy_host_resolver.h" |
| |
| #include "base/callback.h" |
| #include "base/location.h" |
| #include "base/logging.h" |
| #include "base/memory/weak_ptr.h" |
| #include "base/threading/thread_task_runner_handle.h" |
| #include "net/base/completion_once_callback.h" |
| #include "net/base/net_errors.h" |
| |
| namespace net { |
| |
| class MockProxyHostResolver::RequestImpl |
| : public Request, |
| public base::SupportsWeakPtr<RequestImpl> { |
| public: |
| RequestImpl(std::vector<IPAddress> results, bool synchronous_mode) |
| : results_(std::move(results)), synchronous_mode_(synchronous_mode) {} |
| ~RequestImpl() override = default; |
| |
| int Start(CompletionOnceCallback callback) override { |
| if (!synchronous_mode_) { |
| callback_ = std::move(callback); |
| base::ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, base::BindOnce(&RequestImpl::SendResults, AsWeakPtr())); |
| return ERR_IO_PENDING; |
| } |
| |
| if (results_.empty()) |
| return ERR_NAME_NOT_RESOLVED; |
| |
| return OK; |
| } |
| |
| const std::vector<IPAddress>& GetResults() const override { |
| DCHECK(!callback_); |
| return results_; |
| } |
| |
| private: |
| void SendResults() { |
| if (results_.empty()) |
| std::move(callback_).Run(ERR_NAME_NOT_RESOLVED); |
| else |
| std::move(callback_).Run(OK); |
| } |
| |
| const std::vector<IPAddress> results_; |
| const bool synchronous_mode_; |
| |
| CompletionOnceCallback callback_; |
| }; |
| |
| MockProxyHostResolver::MockProxyHostResolver(bool synchronous_mode) |
| : num_resolve_(0), fail_all_(false), synchronous_mode_(synchronous_mode) {} |
| |
| MockProxyHostResolver::~MockProxyHostResolver() = default; |
| |
| std::unique_ptr<ProxyHostResolver::Request> |
| MockProxyHostResolver::CreateRequest(const std::string& hostname, |
| ProxyResolveDnsOperation operation) { |
| ++num_resolve_; |
| |
| if (fail_all_) |
| return std::make_unique<RequestImpl>(std::vector<IPAddress>(), |
| synchronous_mode_); |
| |
| auto match = results_.find({hostname, operation}); |
| if (match == results_.end()) |
| return std::make_unique<RequestImpl>( |
| std::vector<IPAddress>({IPAddress(127, 0, 0, 1)}), synchronous_mode_); |
| |
| return std::make_unique<RequestImpl>(match->second, synchronous_mode_); |
| } |
| |
| void MockProxyHostResolver::SetError(const std::string& hostname, |
| ProxyResolveDnsOperation operation) { |
| fail_all_ = false; |
| results_[{hostname, operation}].clear(); |
| } |
| |
| void MockProxyHostResolver::SetResult(const std::string& hostname, |
| ProxyResolveDnsOperation operation, |
| std::vector<IPAddress> result) { |
| DCHECK(!result.empty()); |
| fail_all_ = false; |
| results_[{hostname, operation}] = std::move(result); |
| } |
| |
| void MockProxyHostResolver::FailAll() { |
| results_.clear(); |
| fail_all_ = true; |
| } |
| |
| class HangingProxyHostResolver::RequestImpl : public Request { |
| public: |
| explicit RequestImpl(HangingProxyHostResolver* resolver) |
| : resolver_(resolver) {} |
| ~RequestImpl() override { ++resolver_->num_cancelled_requests_; } |
| |
| int Start(CompletionOnceCallback callback) override { |
| if (resolver_->hang_callback_) |
| resolver_->hang_callback_.Run(); |
| return ERR_IO_PENDING; |
| } |
| |
| const std::vector<IPAddress>& GetResults() const override { |
| IMMEDIATE_CRASH(); |
| } |
| |
| private: |
| HangingProxyHostResolver* resolver_; |
| }; |
| |
| HangingProxyHostResolver::HangingProxyHostResolver( |
| base::RepeatingClosure hang_callback) |
| : num_cancelled_requests_(0), hang_callback_(std::move(hang_callback)) {} |
| |
| HangingProxyHostResolver::~HangingProxyHostResolver() = default; |
| |
| std::unique_ptr<ProxyHostResolver::Request> |
| HangingProxyHostResolver::CreateRequest(const std::string& hostname, |
| ProxyResolveDnsOperation operation) { |
| return std::make_unique<RequestImpl>(this); |
| } |
| |
| } // namespace net |