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

net/quic/crypto/crypto_server_test.cc

 // Copyright (c) 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 <ostream>
 #include <vector>
 
 #include "base/strings/string_number_conversions.h"
 #include "crypto/secure_hash.h"
 #include "net/quic/crypto/cert_compressor.h"
@@ skipping 235 matching lines @@
     server_hello.GetTaglist(kVER, &versions, &num_versions);
     ASSERT_EQ(supported_versions_.size(), num_versions);
     for (size_t i = 0; i < num_versions; ++i) {
       EXPECT_EQ(QuicVersionToQuicTag(supported_versions_[i]), versions[i]);
     }
 
     StringPiece address;
     ASSERT_TRUE(server_hello.GetStringPiece(kCADR, &address));
     QuicSocketAddressCoder decoder;
     ASSERT_TRUE(decoder.Decode(address.data(), address.size()));
-    EXPECT_EQ(client_address_.address(), decoder.ip());
+    EXPECT_EQ(client_address_.address_number(), decoder.ip());
     EXPECT_EQ(client_address_.port(), decoder.port());
   }
 
   void ShouldSucceed(const CryptoHandshakeMessage& message) {
     bool called = false;
     IPAddressNumber server_ip;
-    config_.ValidateClientHello(message, client_address_.address(), server_ip,
-                                supported_versions_.front(), &clock_,
+    config_.ValidateClientHello(message, client_address_.address_number(),
+                                server_ip, supported_versions_.front(), &clock_,
                                 &crypto_proof_,
                                 new ValidateCallback(this, true, "", &called));
     EXPECT_TRUE(called);
   }
 
   void ShouldFailMentioning(const char* error_substr,
                             const CryptoHandshakeMessage& message) {
     bool called = false;
     ShouldFailMentioning(error_substr, message, &called);
     EXPECT_TRUE(called);
   }
 
   void ShouldFailMentioning(const char* error_substr,
                             const CryptoHandshakeMessage& message,
                             bool* called) {
     IPAddressNumber server_ip;
     config_.ValidateClientHello(
-        message, client_address_.address(), server_ip,
+        message, client_address_.address_number(), server_ip,
         supported_versions_.front(), &clock_, &crypto_proof_,
         new ValidateCallback(this, false, error_substr, called));
   }
 
   void ProcessValidationResult(const CryptoHandshakeMessage& message,
                                const ValidateCallback::Result& result,
                                bool should_succeed,
                                const char* error_substr) {
     IPAddressNumber server_ip;
     string error_details;
@@ skipping 839 matching lines @@
       "VER\0", client_version_string_.c_str(),
       "$padding", static_cast<int>(kClientHelloMinimumSize),
       nullptr);
   // clang-format on
 
   // Clear the message tag.
   out_.set_tag(0);
 
   bool called = false;
   IPAddressNumber server_ip;
-  config_.ValidateClientHello(msg, client_address_.address(), server_ip,
+  config_.ValidateClientHello(msg, client_address_.address_number(), server_ip,
                               client_version_, &clock_, &crypto_proof_,
                               new ValidateCallback(this, true, "", &called));
   // The verification request was queued.
   ASSERT_FALSE(called);
   EXPECT_EQ(0u, out_.tag());
   EXPECT_EQ(1, strike_register_client_->PendingVerifications());
 
   // Continue processing the verification request.
   strike_register_client_->RunPendingVerifications();
   ASSERT_TRUE(called);
   EXPECT_EQ(0, strike_register_client_->PendingVerifications());
   // The message should be accepted now.
   EXPECT_EQ(kSHLO, out_.tag());
 
   // Rejected if replayed.
-  config_.ValidateClientHello(msg, client_address_.address(), server_ip,
+  config_.ValidateClientHello(msg, client_address_.address_number(), server_ip,
                               client_version_, &clock_, &crypto_proof_,
                               new ValidateCallback(this, true, "", &called));
   // The verification request was queued.
   ASSERT_FALSE(called);
   EXPECT_EQ(1, strike_register_client_->PendingVerifications());
 
   strike_register_client_->RunPendingVerifications();
   ASSERT_TRUE(called);
   EXPECT_EQ(0, strike_register_client_->PendingVerifications());
   // The message should be rejected now.
   CheckRejectTag();
 }
 
 }  // namespace test
 }  // namespace net