Make the simple QUIC client able to resolve hosts.

net/tools/quic/synchronous_host_resolver.cc

+#include "net/tools/quic/synchronous_host_resolver.h"

[ramant (doing other things), 2015/03/20 17:46:56]

nit: copyright

[Ryan Hamilton, 2015/03/20 21:38:48]

Done.

+
+#include "base/at_exit.h"
+#include "base/memory/weak_ptr.h"
+#include "base/threading/simple_thread.h"
+#include "net/base/host_port_pair.h"
+#include "net/base/net_errors.h"
+#include "net/dns/host_resolver_impl.h"
+#include "net/dns/single_request_host_resolver.h"
+
+namespace net {
+
+namespace tools {
+
+namespace {
+
+class ResolverThread : public base::SimpleThread {
+ public:
+  ResolverThread();
+
+  ~ResolverThread() override;
+
+  // Called on the main thread.
+  int Resolve(const std::string& host, AddressList* addresses);
+
+  // SimpleThread methods:
+  void Run() override;
+
+ private:
+  void OnResolutionComplete(int rv);
+
+  AddressList* addresses_;
+  std::string host_;
+  int rv_;
+
+  base::WaitableEvent resolved_;  // Notified when the resolution is complete.
+
+  base::WeakPtrFactory<ResolverThread> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(ResolverThread);
+};
+
+ResolverThread::ResolverThread()
+    : SimpleThread("resolver_thread"),
+      rv_(ERR_UNEXPECTED),
+      resolved_(true, false),
+      weak_factory_(this) {}
+
+ResolverThread::~ResolverThread() {}
+
+void ResolverThread::Run() {
+  base::AtExitManager exit_manager;
+  base::MessageLoopForIO loop;
+
+  net::HostResolver::Options options;
+  options.max_concurrent_resolves = 6;
+  options.max_retry_attempts = 3u;
+  net::NetLog net_log;
+  scoped_ptr<net::HostResolverImpl> resolver_impl(
+      new net::HostResolverImpl(options, &net_log));
+  SingleRequestHostResolver resolver(resolver_impl.get());
+
+  HostPortPair host_port_pair(host_, 80);
+
+  rv_ = resolver.Resolve(
+      HostResolver::RequestInfo(host_port_pair), DEFAULT_PRIORITY,
+      addresses_,
+      base::Bind(&ResolverThread::OnResolutionComplete,
+                 weak_factory_.GetWeakPtr()),
+      BoundNetLog());
+
+  if (rv_ != ERR_IO_PENDING) {
+    resolved_.Signal();
+  }
+
+  while (!resolved_.IsSignaled()) {
+    base::MessageLoop::current()->RunUntilIdle();
+  }
+}
+
+int ResolverThread::Resolve(const std::string& host, AddressList* addresses) {
+  host_ = host;
+  addresses_ = addresses;
+  this->Start();
+  resolved_.Wait();
+  this->Join();
+  return rv_;
+}
+
+void ResolverThread::OnResolutionComplete(int rv) {
+  rv_ = rv;
+  resolved_.Signal();
+}
+
+}  // namespace
+
+// static
+int SynchronousHostResolver::Resolve(const std::string& host,
+                                     AddressList* addresses) {
+  ResolverThread resolver;
+  return resolver.Resolve(host, addresses);
+}
+
+}  // namespace tools
+}  // namespace net