Make IP Address related functions return the empty string when used on an invalid address.

net/base/ip_address_number.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.
 
 #include "net/base/ip_address_number.h"
 
 #include <limits.h>
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 84 matching lines @@
 }
 
 std::string IPAddressToString(const uint8_t* address, size_t address_len) {
   std::string str;
   url::StdStringCanonOutput output(&str);
 
   if (address_len == kIPv4AddressSize) {
     url::AppendIPv4Address(address, &output);
   } else if (address_len == kIPv6AddressSize) {
     url::AppendIPv6Address(address, &output);
-  } else {
-    CHECK(false) << "Invalid IP address with length: " << address_len;
   }

[martijnc, 2016/02/17 21:46:55]

Also simplified this. The else clause wasn't necessary.

When the address is invalid, the contents of str will be returned (and will be
the empty string).

 
   output.Complete();
   return str;
 }
 
 std::string IPAddressToStringWithPort(const uint8_t* address,
                                       size_t address_len,
                                       uint16_t port) {
   std::string address_str = IPAddressToString(address, address_len);
+  if (address_str.empty())
+    return address_str;
 
   if (address_len == kIPv6AddressSize) {
     // Need to bracket IPv6 addresses since they contain colons.
     return base::StringPrintf("[%s]:%d", address_str.c_str(), port);
   }
   return base::StringPrintf("%s:%d", address_str.c_str(), port);
 }
 
 std::string IPAddressToString(const IPAddressNumber& addr) {
-  return IPAddressToString(&addr.front(), addr.size());
+  return IPAddressToString(addr.data(), addr.size());
 }
 
 std::string IPAddressToStringWithPort(const IPAddressNumber& addr,
                                       uint16_t port) {
-  return IPAddressToStringWithPort(&addr.front(), addr.size(), port);
+  return IPAddressToStringWithPort(addr.data(), addr.size(), port);
 }
 
 std::string IPAddressToPackedString(const IPAddressNumber& addr) {
-  return std::string(reinterpret_cast<const char *>(&addr.front()),
-                     addr.size());
+  return std::string(reinterpret_cast<const char*>(addr.data()), addr.size());
 }
 
 bool ParseURLHostnameToNumber(const std::string& hostname,
                               IPAddressNumber* ip_number) {
   // |hostname| is an already canoncalized hostname, conforming to RFC 3986.
   // For an IP address, this is defined in Section 3.2.2 of RFC 3986, with
   // the canonical form for IPv6 addresses defined in Section 4 of RFC 5952.
   url::Component host_comp(0, hostname.size());
 
   // If it has a bracket, try parsing it as an IPv6 address.
@@ skipping 143 matching lines @@
   }
   return a1.size() * CHAR_BIT;
 }
 
 unsigned MaskPrefixLength(const IPAddressNumber& mask) {
   IPAddressNumber all_ones(mask.size(), 0xFF);
   return CommonPrefixLength(mask, all_ones);
 }
 
 }  // namespace net