Update some callers to use more direct ways of constructing IPAddress from well known literals.

BUG=496258

Review URL: https://codereview.chromium.org/1809863002

Cr-Commit-Position: refs/heads/master@{#381655}

15 files changed, 47 insertions, 40 deletions

diff --git a/net/base/ip_address.cc b/net/base/ip_address.cc
index 075d4d0..606483b 100644
--- a/net/base/ip_address.cc
+++ b/net/base/ip_address.cc
@@ -89,6 +89,16 @@ IPAddress IPAddress::AllZeros(size_t num_zero_bytes) {
   return IPAddress(std::vector<uint8_t>(num_zero_bytes));
 }
 
+// static
+IPAddress IPAddress::IPv4AllZeros() {
+  return AllZeros(kIPv4AddressSize);
+}
+
+// static
+IPAddress IPAddress::IPv6AllZeros() {
+  return AllZeros(kIPv6AddressSize);
+}
+
 bool IPAddress::operator==(const IPAddress& that) const {
   return ip_address_ == that.ip_address_;
 }
diff --git a/net/base/ip_address.h b/net/base/ip_address.h
index ed76a76..f1f244e 100644
--- a/net/base/ip_address.h
+++ b/net/base/ip_address.h
@@ -95,6 +95,12 @@ class NET_EXPORT IPAddress {
   // Returns an IPAddress made up of |num_zero_bytes| zeros.
   static IPAddress AllZeros(size_t num_zero_bytes);
 
+  // Returns an IPAddress instance representing the 0.0.0.0 address.
+  static IPAddress IPv4AllZeros();
+
+  // Returns an IPAddress instance representing the :: address.
+  static IPAddress IPv6AllZeros();
+
   bool operator==(const IPAddress& that) const;
   bool operator!=(const IPAddress& that) const;
   bool operator<(const IPAddress& that) const;
diff --git a/net/base/ip_address_unittest.cc b/net/base/ip_address_unittest.cc
index dffb905..2863c6b 100644
--- a/net/base/ip_address_unittest.cc
+++ b/net/base/ip_address_unittest.cc
@@ -82,6 +82,16 @@ TEST(IPAddressTest, IsZero) {
   EXPECT_FALSE(empty_address.IsZero());
 }
 
+TEST(IPAddressTest, AllZeros) {
+  EXPECT_TRUE(IPAddress::AllZeros(0).empty());
+
+  EXPECT_EQ(3u, IPAddress::AllZeros(3).size());
+  EXPECT_TRUE(IPAddress::AllZeros(3).IsZero());
+
+  EXPECT_EQ("0.0.0.0", IPAddress::IPv4AllZeros().ToString());
+  EXPECT_EQ("::", IPAddress::IPv6AllZeros().ToString());
+}
+
 TEST(IPAddressTest, ToString) {
   uint8_t addr1[4] = {0, 0, 0, 0};
   IPAddress ip_address1(addr1);
diff --git a/net/http/http_network_transaction_unittest.cc b/net/http/http_network_transaction_unittest.cc
index bc7f7b3..5e6833c 100644
--- a/net/http/http_network_transaction_unittest.cc
+++ b/net/http/http_network_transaction_unittest.cc
@@ -12912,9 +12912,7 @@ TEST_P(HttpNetworkTransactionTest, UseIPConnectionPooling) {
       MockRead(ASYNC, 0, 6),
   };
 
-  IPAddress ip;
-  ASSERT_TRUE(ip.AssignFromIPLiteral("127.0.0.1"));
-  IPEndPoint peer_addr = IPEndPoint(ip, 443);
+  IPEndPoint peer_addr(IPAddress::IPv4Localhost(), 443);
   MockConnect connect(ASYNC, OK, peer_addr);
   SequencedSocketData spdy_data(connect, spdy_reads, arraysize(spdy_reads),
                                 spdy_writes, arraysize(spdy_writes));
@@ -13012,9 +13010,7 @@ TEST_P(HttpNetworkTransactionTest, UseIPConnectionPoolingAfterResolution) {
       MockRead(ASYNC, 0, 6),
   };
 
-  IPAddress ip;
-  ASSERT_TRUE(ip.AssignFromIPLiteral("127.0.0.1"));
-  IPEndPoint peer_addr = IPEndPoint(ip, 443);
+  IPEndPoint peer_addr(IPAddress::IPv4Localhost(), 443);
   MockConnect connect(ASYNC, OK, peer_addr);
   SequencedSocketData spdy_data(connect, spdy_reads, arraysize(spdy_reads),
                                 spdy_writes, arraysize(spdy_writes));
@@ -13143,9 +13139,7 @@ TEST_P(HttpNetworkTransactionTest,
       MockRead(ASYNC, 0, 6),
   };
 
-  IPAddress ip;
-  ASSERT_TRUE(ip.AssignFromIPLiteral("127.0.0.1"));
-  IPEndPoint peer_addr = IPEndPoint(ip, 443);
+  IPEndPoint peer_addr(IPAddress::IPv4Localhost(), 443);
   MockConnect connect(ASYNC, OK, peer_addr);
   SequencedSocketData spdy_data(connect, spdy_reads, arraysize(spdy_reads),
                                 spdy_writes, arraysize(spdy_writes));
diff --git a/net/http/http_server_properties_impl_unittest.cc b/net/http/http_server_properties_impl_unittest.cc
index d06574f..f48289e 100644
--- a/net/http/http_server_properties_impl_unittest.cc
+++ b/net/http/http_server_properties_impl_unittest.cc
@@ -1271,7 +1271,7 @@ TEST_F(SupportsQuicServerPropertiesTest, Initialize) {
   EXPECT_TRUE(address.empty());
 
   // Check by initializing with a valid address.
-  CHECK(initial_address.AssignFromIPLiteral("127.0.0.1"));
+  initial_address = IPAddress::IPv4Localhost();
   impl_.InitializeSupportsQuic(&initial_address);
 
   EXPECT_TRUE(impl_.GetSupportsQuic(&address));
diff --git a/net/quic/p2p/quic_p2p_session.cc b/net/quic/p2p/quic_p2p_session.cc
index ba7298d..6bd17d6 100644
--- a/net/quic/p2p/quic_p2p_session.cc
+++ b/net/quic/p2p/quic_p2p_session.cc
@@ -31,7 +31,7 @@ QuicP2PSession::QuicP2PSession(const QuicConfig& config,
   // ToString() to format addresses for logging and ToString() is not allowed
   // for empty addresses.
   // TODO(sergeyu): Fix QuicConnection and remove SetSelfAddress() call below.
-  this->connection()->SetSelfAddress(IPEndPoint(IPAddress(0, 0, 0, 0), 0));
+  this->connection()->SetSelfAddress(IPEndPoint(IPAddress::IPv4AllZeros(), 0));
 }
 
 QuicP2PSession::~QuicP2PSession() {}
diff --git a/net/quic/p2p/quic_p2p_session_test.cc b/net/quic/p2p/quic_p2p_session_test.cc
index 6df1dd1..fb9cfff 100644
--- a/net/quic/p2p/quic_p2p_session_test.cc
+++ b/net/quic/p2p/quic_p2p_session_test.cc
@@ -229,7 +229,7 @@ class QuicP2PSessionTest : public ::testing::Test {
     QuicChromiumPacketWriter* writer =
         new QuicChromiumPacketWriter(socket.get());
     scoped_ptr<QuicConnection> quic_connection1(new QuicConnection(
-        0, IPEndPoint(IPAddress(0, 0, 0, 0), 0), &quic_helper_, writer,
+        0, IPEndPoint(IPAddress::IPv4AllZeros(), 0), &quic_helper_, writer,
         true /* owns_writer */, perspective, QuicSupportedVersions()));
     writer->SetConnection(quic_connection1.get());
 
diff --git a/net/quic/quic_chromium_client_session_test.cc b/net/quic/quic_chromium_client_session_test.cc
index 2de5d3c..40f40e2 100644
--- a/net/quic/quic_chromium_client_session_test.cc
+++ b/net/quic/quic_chromium_client_session_test.cc
@@ -48,8 +48,7 @@ namespace net {
 namespace test {
 namespace {
 
-const IPEndPoint kIpEndPoint =
-    IPEndPoint(IPAddress(std::vector<uint8_t>(kIPv4AddressSize, 0)), 0);
+const IPEndPoint kIpEndPoint = IPEndPoint(IPAddress::IPv4AllZeros(), 0);
 const char kServerHostname[] = "test.example.com";
 const uint16_t kServerPort = 443;
 const size_t kMaxReadersPerQuicSession = 5;
diff --git a/net/quic/quic_connection_test.cc b/net/quic/quic_connection_test.cc
index 969fcf2..275cb43 100644
--- a/net/quic/quic_connection_test.cc
+++ b/net/quic/quic_connection_test.cc
@@ -1027,9 +1027,7 @@ TEST_P(QuicConnectionTest, SelfAddressChangeAtClient) {
   ProcessFramePacketWithAddresses(QuicFrame(&stream_frame), kSelfAddress,
                                   kPeerAddress);
   // Cause change in self_address.
-  IPAddress address;
-  ASSERT_TRUE(address.AssignFromIPLiteral("1.1.1.1"));
-  IPEndPoint self_address(address, 123);
+  IPEndPoint self_address(IPAddress(1, 1, 1, 1), 123);
   EXPECT_CALL(visitor_, OnStreamFrame(_));
   ProcessFramePacketWithAddresses(QuicFrame(&stream_frame), self_address,
                                   kPeerAddress);
@@ -1050,9 +1048,7 @@ TEST_P(QuicConnectionTest, SelfAddressChangeAtServer) {
   ProcessFramePacketWithAddresses(QuicFrame(&stream_frame), kSelfAddress,
                                   kPeerAddress);
   // Cause change in self_address.
-  IPAddress address;
-  ASSERT_TRUE(address.AssignFromIPLiteral("1.1.1.1"));
-  IPEndPoint self_address(address, 123);
+  IPEndPoint self_address(IPAddress(1, 1, 1, 1), 123);
   EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_ERROR_MIGRATING_ADDRESS, _));
   ProcessFramePacketWithAddresses(QuicFrame(&stream_frame), self_address,
                                   kPeerAddress);
diff --git a/net/quic/test_tools/quic_test_utils.cc b/net/quic/test_tools/quic_test_utils.cc
index 1041569..bc9fbc4 100644
--- a/net/quic/test_tools/quic_test_utils.cc
+++ b/net/quic/test_tools/quic_test_utils.cc
@@ -456,17 +456,15 @@ QuicVersion QuicVersionMin() {
 }
 
 IPAddress Loopback4() {
-  return IPAddress(127, 0, 0, 1);
+  return IPAddress::IPv4Localhost();
 }
 
 IPAddress Loopback6() {
-  IPAddress addr;
-  CHECK(addr.AssignFromIPLiteral("::1"));
-  return addr;
+  return IPAddress::IPv6Localhost();
 }
 
 IPAddress Any4() {
-  return IPAddress(0, 0, 0, 0);
+  return IPAddress::IPv4AllZeros();
 }
 
 void GenerateBody(string* body, int length) {
diff --git a/net/tools/quic/end_to_end_test.cc b/net/tools/quic/end_to_end_test.cc
index 441a5d9..923808b 100644
--- a/net/tools/quic/end_to_end_test.cc
+++ b/net/tools/quic/end_to_end_test.cc
@@ -547,12 +547,11 @@ TEST_P(EndToEndTest, SimpleRequestResponseWithLargeReject) {
   EXPECT_EQ(3, client_->client()->GetNumSentClientHellos());
 }
 
-// TODO(rch): figure out how to detect missing v6 supprt (like on the linux
+// TODO(rch): figure out how to detect missing v6 support (like on the linux
 // try bots) and selectively disable this test.
 TEST_P(EndToEndTest, DISABLED_SimpleRequestResponsev6) {
-  IPAddress ip;
-  CHECK(ip.AssignFromIPLiteral("::1"));
-  server_address_ = IPEndPoint(ip, server_address_.port());
+  server_address_ =
+      IPEndPoint(IPAddress::IPv6Localhost(), server_address_.port());
   ASSERT_TRUE(Initialize());
 
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
diff --git a/net/tools/quic/quic_client.cc b/net/tools/quic/quic_client.cc
index 04b7d2f..8f9da4f 100644
--- a/net/tools/quic/quic_client.cc
+++ b/net/tools/quic/quic_client.cc
@@ -149,10 +149,9 @@ bool QuicClient::CreateUDPSocketAndBind() {
   if (bind_to_address_.size() != 0) {
     client_address = IPEndPoint(bind_to_address_, local_port_);
   } else if (server_address_.GetSockAddrFamily() == AF_INET) {
-    client_address = IPEndPoint(IPAddress(0, 0, 0, 0), local_port_);
+    client_address = IPEndPoint(IPAddress::IPv4AllZeros(), local_port_);
   } else {
-    IPAddress any6;
-    CHECK(any6.AssignFromIPLiteral("::"));
+    IPAddress any6 = IPAddress::IPv6AllZeros();
     client_address = IPEndPoint(any6, local_port_);
   }
 
diff --git a/net/tools/quic/quic_server_bin.cc b/net/tools/quic/quic_server_bin.cc
index a6a3341..983c584 100644
--- a/net/tools/quic/quic_server_bin.cc
+++ b/net/tools/quic/quic_server_bin.cc
@@ -77,8 +77,7 @@ int main(int argc, char* argv[]) {
     return 1;
   }
 
-  net::IPAddress ip;
-  CHECK(ip.AssignFromIPLiteral("::"));
+  auto ip = net::IPAddress::IPv6AllZeros();
 
   net::QuicConfig config;
   net::QuicServer server(
diff --git a/net/tools/quic/quic_simple_client.cc b/net/tools/quic/quic_simple_client.cc
index 4c2b221..b1dcf19 100644
--- a/net/tools/quic/quic_simple_client.cc
+++ b/net/tools/quic/quic_simple_client.cc
@@ -107,11 +107,9 @@ bool QuicSimpleClient::CreateUDPSocket() {
   if (bind_to_address_.size() != 0) {
     client_address_ = IPEndPoint(bind_to_address_, local_port_);
   } else if (address_family == AF_INET) {
-    client_address_ = IPEndPoint(IPAddress(0, 0, 0, 0), local_port_);
+    client_address_ = IPEndPoint(IPAddress::IPv4AllZeros(), local_port_);
   } else {
-    IPAddress any6;
-    CHECK(any6.AssignFromIPLiteral("::"));
-    client_address_ = IPEndPoint(any6, local_port_);
+    client_address_ = IPEndPoint(IPAddress::IPv6AllZeros(), local_port_);
   }
 
   int rc = socket->Connect(server_address_);
diff --git a/net/tools/quic/quic_simple_server_bin.cc b/net/tools/quic/quic_simple_server_bin.cc
index b92a926..b04bf15 100644
--- a/net/tools/quic/quic_simple_server_bin.cc
+++ b/net/tools/quic/quic_simple_server_bin.cc
@@ -77,8 +77,7 @@ int main(int argc, char* argv[]) {
     return 1;
   }
 
-  net::IPAddress ip;
-  CHECK(ip.AssignFromIPLiteral("::"));
+  net::IPAddress ip = net::IPAddress::IPv6AllZeros();
 
   net::QuicConfig config;
   net::QuicSimpleServer server(