Changes the UI for HTTP/FTP auth challenges to include the server's port. So instead of "www.foo.com" it will say "www.foo.com:80". We need to include the port number since otherwise it can be ambiguous what the actual target server is.

This change also introduces utility function "GetHostAnd[Optional]Port()" to help with forming <host> [":" <port>] strings.

BUG=12073
Review URL: http://codereview.chromium.org/112041

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@16672 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 79 insertions, 20 deletions

diff --git a/net/base/auth.h b/net/base/auth.h
index b404f7a..ec31bfc 100644
--- a/net/base/auth.h
+++ b/net/base/auth.h
@@ -17,8 +17,8 @@ class AuthChallengeInfo :
     public base::RefCountedThreadSafe<AuthChallengeInfo> {
  public:
   bool is_proxy;  // true for Proxy-Authenticate, false for WWW-Authenticate.
-  std::wstring host;  // the domain name of the server asking for auth
-                      // (could be the proxy).
+  std::wstring host_and_port;  // <host>:<port> of the server asking for auth
+                               // (could be the proxy).
   std::wstring scheme;  // "Basic", "Digest", or whatever other method is used.
   std::wstring realm;  // the realm provided by the server, if there is one.
 
diff --git a/net/base/net_util.cc b/net/base/net_util.cc
index c309653..06b43be 100644
--- a/net/base/net_util.cc
+++ b/net/base/net_util.cc
@@ -944,10 +944,10 @@ int SetNonBlocking(int fd) {
 #endif
 }
 
-bool GetHostAndPort(std::string::const_iterator host_and_port_begin,
-                    std::string::const_iterator host_and_port_end,
-                    std::string* host,
-                    int* port) {
+bool ParseHostAndPort(std::string::const_iterator host_and_port_begin,
+                      std::string::const_iterator host_and_port_end,
+                      std::string* host,
+                      int* port) {
   if (host_and_port_begin >= host_and_port_end)
     return false;
 
@@ -991,10 +991,25 @@ bool GetHostAndPort(std::string::const_iterator host_and_port_begin,
   return true;  // Success.
 }
 
-bool GetHostAndPort(const std::string& host_and_port,
-                    std::string* host,
-                    int* port) {
-  return GetHostAndPort(host_and_port.begin(), host_and_port.end(), host, port);
+bool ParseHostAndPort(const std::string& host_and_port,
+                      std::string* host,
+                      int* port) {
+  return ParseHostAndPort(
+      host_and_port.begin(), host_and_port.end(), host, port);
+}
+
+std::string GetHostAndPort(const GURL& url) {
+  // For IPv6 literals, GURL::host() already includes the brackets so it is
+  // safe to just append a colon.
+  return StringPrintf("%s:%d", url.host().c_str(), url.EffectiveIntPort());
+}
+
+std::string GetHostAndOptionalPort(const GURL& url) {
+  // For IPv6 literals, GURL::host() already includes the brackets
+  // so it is safe to just append a colon.
+  if (url.has_port())
+    return StringPrintf("%s:%s", url.host().c_str(), url.port().c_str());
+  return url.host();
 }
 
 std::string NetAddressToString(const struct addrinfo* net_address) {
diff --git a/net/base/net_util.h b/net/base/net_util.h
index 9c59b90..e64cb88 100644
--- a/net/base/net_util.h
+++ b/net/base/net_util.h
@@ -35,19 +35,26 @@ GURL FilePathToFileURL(const FilePath& path);
 // valid file URL. On failure, *file_path will be empty.
 bool FileURLToFilePath(const GURL& url, FilePath* file_path);
 
-// Split an input of the form <host>[":"<port>] into its consitituent parts.
+// Splits an input of the form <host>[":"<port>] into its consitituent parts.
 // Saves the result into |*host| and |*port|. If the input did not have
 // the optional port, sets |*port| to -1.
 // Returns true if the parsing was successful, false otherwise.
 // The returned host is NOT canonicalized, and may be invalid. If <host> is
 // an IPv6 literal address, the returned host includes the square brackets.
-bool GetHostAndPort(std::string::const_iterator host_and_port_begin,
-                    std::string::const_iterator host_and_port_end,
-                    std::string* host,
-                    int* port);
-bool GetHostAndPort(const std::string& host_and_port,
-                    std::string* host,
-                    int* port);
+bool ParseHostAndPort(std::string::const_iterator host_and_port_begin,
+                      std::string::const_iterator host_and_port_end,
+                      std::string* host,
+                      int* port);
+bool ParseHostAndPort(const std::string& host_and_port,
+                      std::string* host,
+                      int* port);
+
+// Returns a host:port string for the given URL.
+std::string GetHostAndPort(const GURL& url);
+
+// Returns a host[:port] string for the given URL, where the port is omitted
+// if it is the default for the URL's scheme.
+std::string GetHostAndOptionalPort(const GURL& url);
 
 // Returns the string representation of an address, like "192.168.0.1".
 // Returns empty string on failure.
diff --git a/net/base/net_util_unittest.cc b/net/base/net_util_unittest.cc
index 57b74d7..79c1138 100644
--- a/net/base/net_util_unittest.cc
+++ b/net/base/net_util_unittest.cc
@@ -884,7 +884,7 @@ TEST(NetUtilTest, GetDirectoryListingEntry) {
 
 #endif
 
-TEST(NetUtilTest, GetHostAndPort) {
+TEST(NetUtilTest, ParseHostAndPort) {
   const struct {
     const char* input;
     bool success;
@@ -918,7 +918,7 @@ TEST(NetUtilTest, GetHostAndPort) {
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     std::string host;
     int port;
-    bool ok = net::GetHostAndPort(tests[i].input, &host, &port);
+    bool ok = net::ParseHostAndPort(tests[i].input, &host, &port);
 
     EXPECT_EQ(tests[i].success, ok);
 
@@ -929,6 +929,43 @@ TEST(NetUtilTest, GetHostAndPort) {
   }
 }
 
+TEST(NetUtilTest, GetHostAndPort) {
+  const struct {
+    GURL url;
+    const char* expected_host_and_port;
+  } tests[] = {
+    { GURL("http://www.foo.com/x"), "www.foo.com:80"},
+    { GURL("http://www.foo.com:21/x"), "www.foo.com:21"},
+
+    // For IPv6 literals should always include the brackets.
+    { GURL("http://[1::2]/x"), "[1::2]:80"},
+    { GURL("http://[::a]:33/x"), "[::a]:33"},
+  };
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+    std::string host_and_port = net::GetHostAndPort(tests[i].url);
+    EXPECT_EQ(std::string(tests[i].expected_host_and_port), host_and_port);
+  }
+}
+
+TEST(NetUtilTest, GetHostAndOptionalPort) {
+  const struct {
+    GURL url;
+    const char* expected_host_and_port;
+  } tests[] = {
+    { GURL("http://www.foo.com/x"), "www.foo.com"},
+    { GURL("http://www.foo.com:21/x"), "www.foo.com:21"},
+
+    // For IPv6 literals should always include the brackets.
+    { GURL("http://[1::2]/x"), "[1::2]"},
+    { GURL("http://[::a]:33/x"), "[::a]:33"},
+  };
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+    std::string host_and_port = net::GetHostAndOptionalPort(tests[i].url);
+    EXPECT_EQ(std::string(tests[i].expected_host_and_port), host_and_port);
+  }
+}
+
+
 TEST(NetUtilTest, NetAddressToString_IPv4) {
   const struct {
     uint8 addr[4];