Change IPEndpoint::address() to return a net::IPAddress

net/socket/tcp_socket_unittest.cc

 // Copyright 2013 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/socket/tcp_socket.h"
 
 #include <string.h>
 
 #include <string>
 #include <vector>
@@ skipping 68 matching lines @@
     TCPClientSocket connecting_socket(local_address_list(),
                                       NULL, NetLog::Source());
     connecting_socket.Connect(connect_callback.callback());
 
     EXPECT_EQ(OK, connect_callback.WaitForResult());
     EXPECT_EQ(OK, accept_callback.WaitForResult());
 
     EXPECT_TRUE(accepted_socket.get());
 
     // Both sockets should be on the loopback network interface.
-    EXPECT_EQ(accepted_address.address(), local_address_.address());
+    EXPECT_EQ(accepted_address.address_number(),
+              local_address_.address_number());
   }
 
   AddressList local_address_list() const {
     return AddressList(local_address_);
   }
 
   TCPSocket socket_;
   IPEndPoint local_address_;
 };
 
@@ skipping 13 matching lines @@
   IPEndPoint accepted_address;
   int result = socket_.Accept(&accepted_socket, &accepted_address,
                               accept_callback.callback());
   if (result == ERR_IO_PENDING)
     result = accept_callback.WaitForResult();
   ASSERT_EQ(OK, result);
 
   EXPECT_TRUE(accepted_socket.get());
 
   // Both sockets should be on the loopback network interface.
-  EXPECT_EQ(accepted_address.address(), local_address_.address());
+  EXPECT_EQ(accepted_address.address_number(), local_address_.address_number());
 
   EXPECT_EQ(OK, connect_callback.WaitForResult());
 }
 
 // Test Accept() callback.
 TEST_F(TCPSocketTest, AcceptAsync) {
   ASSERT_NO_FATAL_FAILURE(SetUpListenIPv4());
   TestAcceptAsync();
 }
 
@@ skipping 51 matching lines @@
     result = accept_callback2.WaitForResult();
   ASSERT_EQ(OK, result);
 
   EXPECT_EQ(OK, connect_callback.WaitForResult());
   EXPECT_EQ(OK, connect_callback2.WaitForResult());
 
   EXPECT_TRUE(accepted_socket.get());
   EXPECT_TRUE(accepted_socket2.get());
   EXPECT_NE(accepted_socket.get(), accepted_socket2.get());
 
-  EXPECT_EQ(accepted_address.address(), local_address_.address());
-  EXPECT_EQ(accepted_address2.address(), local_address_.address());
+  EXPECT_EQ(accepted_address.address_number(), local_address_.address_number());
+  EXPECT_EQ(accepted_address2.address_number(),
+            local_address_.address_number());
 }
 
 // Test listening and accepting with a socket bound to an IPv6 address.
 TEST_F(TCPSocketTest, AcceptIPv6) {
   bool initialized = false;
   ASSERT_NO_FATAL_FAILURE(SetUpListenIPv6(&initialized));
   if (!initialized)
     return;
 
   TestCompletionCallback connect_callback;
   TCPClientSocket connecting_socket(local_address_list(),
                                     NULL, NetLog::Source());
   connecting_socket.Connect(connect_callback.callback());
 
   TestCompletionCallback accept_callback;
   scoped_ptr<TCPSocket> accepted_socket;
   IPEndPoint accepted_address;
   int result = socket_.Accept(&accepted_socket, &accepted_address,
                               accept_callback.callback());
   if (result == ERR_IO_PENDING)
     result = accept_callback.WaitForResult();
   ASSERT_EQ(OK, result);
 
   EXPECT_TRUE(accepted_socket.get());
 
   // Both sockets should be on the loopback network interface.
-  EXPECT_EQ(accepted_address.address(), local_address_.address());
+  EXPECT_EQ(accepted_address.address_number(), local_address_.address_number());
 
   EXPECT_EQ(OK, connect_callback.WaitForResult());
 }
 
 TEST_F(TCPSocketTest, ReadWrite) {
   ASSERT_NO_FATAL_FAILURE(SetUpListenIPv4());
 
   TestCompletionCallback connect_callback;
   TCPSocket connecting_socket(NULL, NetLog::Source());
   int result = connecting_socket.Open(ADDRESS_FAMILY_IPV4);
   ASSERT_EQ(OK, result);
   connecting_socket.Connect(local_address_, connect_callback.callback());
 
   TestCompletionCallback accept_callback;
   scoped_ptr<TCPSocket> accepted_socket;
   IPEndPoint accepted_address;
   result = socket_.Accept(&accepted_socket, &accepted_address,
                           accept_callback.callback());
   ASSERT_EQ(OK, accept_callback.GetResult(result));
 
   ASSERT_TRUE(accepted_socket.get());
 
   // Both sockets should be on the loopback network interface.
-  EXPECT_EQ(accepted_address.address(), local_address_.address());
+  EXPECT_EQ(accepted_address.address_number(), local_address_.address_number());
 
   EXPECT_EQ(OK, connect_callback.WaitForResult());
 
   const std::string message("test message");
   std::vector<char> buffer(message.size());
 
   size_t bytes_written = 0;
   while (bytes_written < message.size()) {
     scoped_refptr<IOBufferWithSize> write_buffer(
         new IOBufferWithSize(message.size() - bytes_written));
@@ skipping 22 matching lines @@
     memmove(&buffer[bytes_read], read_buffer->data(), read_result);
     bytes_read += read_result;
   }
 
   std::string received_message(buffer.begin(), buffer.end());
   ASSERT_EQ(message, received_message);
 }
 
 }  // namespace
 }  // namespace net