synchronous_host_resolver.cc 3.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114
  1. // Copyright (c) 2015 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/tools/quic/synchronous_host_resolver.h"
  5. #include <memory>
  6. #include <utility>
  7. #include "base/at_exit.h"
  8. #include "base/bind.h"
  9. #include "base/location.h"
  10. #include "base/memory/weak_ptr.h"
  11. #include "base/message_loop/message_pump_type.h"
  12. #include "base/run_loop.h"
  13. #include "base/task/single_thread_task_executor.h"
  14. #include "base/task/single_thread_task_runner.h"
  15. #include "base/threading/simple_thread.h"
  16. #include "base/threading/thread_task_runner_handle.h"
  17. #include "net/base/host_port_pair.h"
  18. #include "net/base/net_errors.h"
  19. #include "net/base/network_isolation_key.h"
  20. #include "net/dns/host_resolver.h"
  21. #include "net/log/net_log.h"
  22. #include "net/log/net_log_with_source.h"
  23. #include "third_party/abseil-cpp/absl/types/optional.h"
  24. #include "url/scheme_host_port.h"
  25. namespace net {
  26. namespace {
  27. class ResolverThread : public base::SimpleThread {
  28. public:
  29. ResolverThread();
  30. ResolverThread(const ResolverThread&) = delete;
  31. ResolverThread& operator=(const ResolverThread&) = delete;
  32. ~ResolverThread() override;
  33. // Called on the main thread.
  34. int Resolve(url::SchemeHostPort scheme_host_port, AddressList* addresses);
  35. // SimpleThread methods:
  36. void Run() override;
  37. private:
  38. void OnResolutionComplete(base::OnceClosure on_done, int rv);
  39. AddressList* addresses_;
  40. url::SchemeHostPort scheme_host_port_;
  41. int rv_ = ERR_UNEXPECTED;
  42. };
  43. ResolverThread::ResolverThread() : SimpleThread("resolver_thread") {}
  44. ResolverThread::~ResolverThread() = default;
  45. void ResolverThread::Run() {
  46. base::SingleThreadTaskExecutor io_task_executor(base::MessagePumpType::IO);
  47. net::HostResolver::ManagerOptions options;
  48. options.max_concurrent_resolves = 6;
  49. options.max_system_retry_attempts = 3u;
  50. std::unique_ptr<net::HostResolver> resolver =
  51. net::HostResolver::CreateStandaloneResolver(NetLog::Get(), options);
  52. // No need to use a NetworkIsolationKey here, since this is an external tool
  53. // not used by net/ consumers.
  54. std::unique_ptr<net::HostResolver::ResolveHostRequest> request =
  55. resolver->CreateRequest(scheme_host_port_, NetworkIsolationKey(),
  56. NetLogWithSource(), absl::nullopt);
  57. base::RunLoop run_loop;
  58. rv_ = request->Start(base::BindOnce(&ResolverThread::OnResolutionComplete,
  59. base::Unretained(this),
  60. run_loop.QuitClosure()));
  61. if (rv_ == ERR_IO_PENDING) {
  62. // Run the message loop until OnResolutionComplete quits it.
  63. run_loop.Run();
  64. }
  65. if (rv_ == OK) {
  66. *addresses_ = *request->GetAddressResults();
  67. }
  68. }
  69. int ResolverThread::Resolve(url::SchemeHostPort scheme_host_port,
  70. AddressList* addresses) {
  71. scheme_host_port_ = std::move(scheme_host_port);
  72. addresses_ = addresses;
  73. this->Start();
  74. this->Join();
  75. return rv_;
  76. }
  77. void ResolverThread::OnResolutionComplete(base::OnceClosure on_done, int rv) {
  78. rv_ = rv;
  79. std::move(on_done).Run();
  80. }
  81. } // namespace
  82. // static
  83. int SynchronousHostResolver::Resolve(url::SchemeHostPort scheme_host_port,
  84. AddressList* addresses) {
  85. ResolverThread resolver;
  86. return resolver.Resolve(std::move(scheme_host_port), addresses);
  87. }
  88. } // namespace net