Make the simple QUIC client able to resolve hosts.

net/tools/quic/quic_simple_client_bin.cc

 // Copyright (c) 2012 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.
 
 // A binary wrapper for QuicClient.
 // Connects to a host using QUIC, sends a request to the provided URL, and
 // displays the response.
 //
 // Some usage examples:
 //
@@ skipping 29 matching lines @@
 
 #include <iostream>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "net/base/ip_endpoint.h"
+#include "net/base/net_errors.h"
+#include "net/base/net_log.h"
 #include "net/base/privacy_mode.h"
 #include "net/cert/cert_verifier.h"
 #include "net/http/http_request_info.h"
 #include "net/http/transport_security_state.h"
 #include "net/quic/crypto/proof_verifier_chromium.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_server_id.h"
 #include "net/quic/quic_utils.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/tools/quic/quic_simple_client.h"
+#include "net/tools/quic/synchronous_host_resolver.h"
 #include "url/gurl.h"
 
 using base::StringPiece;
 using net::CertVerifier;
 using net::ProofVerifierChromium;
 using net::TransportSecurityState;
 using std::cout;
 using std::cerr;
 using std::map;
 using std::string;
@@ skipping 93 matching lines @@
   base::AtExitManager exit_manager;
   base::MessageLoopForIO message_loop;
 
   // Determine IP address to connect to from supplied hostname.
   net::IPAddressNumber ip_addr;
 
   // TODO(rtenneti): GURL's doesn't support default_protocol argument, thus
   // protocol is required in the URL.
   GURL url(urls[0]);
   string host = FLAGS_host;
-  // TODO(rtenneti): get ip_addr from hostname by doing host resolution.
   if (host.empty()) {
-    LOG(ERROR) << "--host must be specified\n";
-    return 1;
+    host = url.host();
   }
   if (!net::ParseIPLiteralToNumber(host, &ip_addr)) {
-    LOG(ERROR) << "--host could not be parsed as an IP address\n";
-    return 1;
+    net::AddressList addresses;
+    int rv = net::tools::SynchronousHostResolver::Resolve(host, &addresses);
+    if (rv != net::OK) {
+      LOG(ERROR) << "Unable to resolve '" << host << "' : "
+                 << net::ErrorToString(rv);
+      return 1;
+    }
+    ip_addr = addresses[0].address();
   }
 
   string host_port = net::IPAddressToStringWithPort(ip_addr, FLAGS_port);
   VLOG(1) << "Resolved " << host << " to " << host_port << endl;
 
   // Build the client, and try to connect.
   bool is_https = (FLAGS_port == 443);
   net::QuicServerId server_id(host, FLAGS_port, is_https,
                               net::PRIVACY_MODE_DISABLED);
   net::QuicVersionVector versions = net::QuicSupportedVersions();
@@ skipping 89 matching lines @@
       return 0;
     } else {
       cout << "Request failed (redirect " << response_code << ")." << endl;
       return 1;
     }
   } else {
     cerr << "Request failed (" << response_code << ")." << endl;
     return 1;
   }
 }