Remove last IPAddress::IsReserved() by switching use in blink.

Bug: 755418
Change-Id: I6265cc98f0f70d9387275cb1e346acdc1978f488
Reviewed-on: https://chromium-review.googlesource.com/994276
Commit-Queue: Nathan Parker <nparker@chromium.org>
Reviewed-by: Nico Weber <thakis@chromium.org>
Reviewed-by: Matt Menke <mmenke@chromium.org>
Cr-Commit-Position: refs/heads/master@{#551130}

net/base/ip_address.cc

@@ -82,8 +82,7 @@ bool IsPubliclyRoutableIPv4(const IPAddressBytes& ip_address) {
 // IPv6 ranges, plus the blacklist of reserved IPv4 ranges mapped to IPv6.
 // Sources for info:
 // www.iana.org/assignments/ipv6-address-space/ipv6-address-space.xhtml
-bool IsPubliclyRoutableIPv6(const IPAddressBytes& ip_address,
-                            bool include_mapped_ipv4) {
+bool IsPubliclyRoutableIPv6(const IPAddressBytes& ip_address) {
   DCHECK_EQ(IPAddress::kIPv6AddressSize, ip_address.size());
   struct {
     const uint8_t address_prefix[2];
@@ -100,9 +99,6 @@ bool IsPubliclyRoutableIPv6(const IPAddressBytes& ip_address,
     }
   }
 
-  if (!include_mapped_ipv4)
-    return false;
-
   IPAddress addr(ip_address);
   if (addr.IsIPv4MappedIPv6()) {
     IPAddress ipv4 = ConvertIPv4MappedIPv6ToIPv4(addr);
@@ -234,21 +230,11 @@ bool IPAddress::IsValid() const {
   return IsIPv4() || IsIPv6();
 }
 
-bool IPAddress::IsReserved() const {
-  if (IsIPv4()) {
-    return !IsPubliclyRoutableIPv4(ip_address_);
-  } else if (IsIPv6()) {
-    return !IsPubliclyRoutableIPv6(ip_address_,
-                                   false /* include_mapped_ipv4 */);
-  }
-  return false;
-}
-
 bool IPAddress::IsPubliclyRoutable() const {
   if (IsIPv4()) {
     return IsPubliclyRoutableIPv4(ip_address_);
   } else if (IsIPv6()) {
-    return IsPubliclyRoutableIPv6(ip_address_, true /* include_mapped_ipv4 */);
+    return IsPubliclyRoutableIPv6(ip_address_);
   }
   return true;
 }

net/base/ip_address.h

@@ -152,12 +152,6 @@ class NET_EXPORT IPAddress {
   // only checks the address length.
   bool IsValid() const;
 
-  // Returns true if the IP is in a range reserved by the IANA.
-  // Works with both IPv4 and IPv6 addresses, and only compares against a given
-  // protocols's reserved ranges.
-  // DEPRECATED. Use !IsPubliclyRoutable(). https://crbug.com/755418
-  bool IsReserved() const;
-
   // Returns true if the IP is not in a range reserved by the IANA for
   // local networks. Works with both IPv4 and IPv6 addresses.
   // IPv4-mapped-to-IPv6 addresses are considered publicly routable.

net/base/ip_address_unittest.cc

@@ -108,7 +108,7 @@ enum IPAddressReservedResult : bool { NOT_RESERVED = false, RESERVED = true };
 // The reserved ranges are tested by checking the first and last address of each
 // range. The unreserved blocks are tested similarly. These tests cover the
 // entire IPv4 address range, as well as this range mapped to IPv6.
-TEST(IPAddressTest, IsReservedIPv4) {
+TEST(IPAddressTest, IsPubliclyRoutableIPv4) {
   struct {
     const char* const address;
     IPAddressReservedResult is_reserved;
@@ -217,13 +217,11 @@ TEST(IPAddressTest, IsReservedIPv4) {
   for (const auto& test : tests) {
     EXPECT_TRUE(address.AssignFromIPLiteral(test.address));
     ASSERT_TRUE(address.IsValid());
-    EXPECT_EQ(!!test.is_reserved, address.IsReserved());
     EXPECT_EQ(!test.is_reserved, address.IsPubliclyRoutable());
 
     // Check these IPv4 addresses when mapped to IPv6. This verifies we're
     // properly unpacking mapped addresses.
     IPAddress mapped_address = ConvertIPv4ToIPv4MappedIPv6(address);
-    EXPECT_TRUE(mapped_address.IsReserved());
     EXPECT_EQ(!test.is_reserved, mapped_address.IsPubliclyRoutable());
   }
 }
@@ -232,13 +230,13 @@ TEST(IPAddressTest, IsReservedIPv4) {
 // The reserved ranges are tested by checking the first and last address of each
 // range. The unreserved blocks are tested similarly. These tests cover the
 // entire IPv6 address range.
-TEST(IPAddressTest, IsReservedIPv6) {
+TEST(IPAddressTest, IsPubliclyRoutableIPv6) {
   struct {
     const char* const address;
     IPAddressReservedResult is_reserved;
   } tests[] = {// 0000::/8.
                // Skip testing ::ffff:/96 explicitly since it was tested
-               // in IsReservedIPv4
+               // in IsPubliclyRoutableIPv4
                {"0:0:0:0:0:0:0:0", RESERVED},
                {"ff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
                // 0100::/8
@@ -299,7 +297,6 @@ TEST(IPAddressTest, IsReservedIPv6) {
   IPAddress address;
   for (const auto& test : tests) {
     EXPECT_TRUE(address.AssignFromIPLiteral(test.address));
-    EXPECT_EQ(!!test.is_reserved, address.IsReserved());
     EXPECT_EQ(!test.is_reserved, address.IsPubliclyRoutable());
   }
 }

third_party/blink/renderer/platform/network/network_utils.cc

@@ -49,7 +49,7 @@ bool IsReservedIPAddress(const String& host) {
   StringUTF8Adaptor utf8(host);
   if (!net::ParseURLHostnameToAddress(utf8.AsStringPiece(), &address))
     return false;
-  return address.IsReserved();
+  return !address.IsPubliclyRoutable();
 }
 
 bool IsLocalHostname(const String& host, bool* is_local6) {

third_party/blink/renderer/platform/network/network_utils_test.cc

@@ -32,10 +32,13 @@ TEST(NetworkUtilsTest, IsReservedIPAddress) {
       "[FFC0:ba98:7654:3210:FEDC:BA98:7654:3210]"));
   EXPECT_FALSE(NetworkUtils::IsReservedIPAddress(
       "[2000:ba98:7654:2301:EFCD:BA98:7654:3210]"));
+  // IPv4-mapped to IPv6
+  EXPECT_FALSE(NetworkUtils::IsReservedIPAddress("[::ffff:8.8.8.8]"));
 
   // Reserved IPv6 addresses.
   EXPECT_TRUE(NetworkUtils::IsReservedIPAddress("[::1]"));
   EXPECT_TRUE(NetworkUtils::IsReservedIPAddress("[::192.9.5.5]"));
+  EXPECT_TRUE(NetworkUtils::IsReservedIPAddress("[::ffff:192.168.1.1]"));
   EXPECT_TRUE(NetworkUtils::IsReservedIPAddress("[FEED::BEEF]"));
   EXPECT_TRUE(NetworkUtils::IsReservedIPAddress(
       "[FEC0:ba98:7654:3210:FEDC:BA98:7654:3210]"));