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

net/dns/address_sorter_posix.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/dns/address_sorter_posix.h"
 
 #include <netinet/in.h>
 #include <utility>
 
 #if defined(OS_MACOSX) || defined(OS_BSD)
@@ skipping 245 matching lines @@
   NetworkChangeNotifier::RemoveIPAddressObserver(this);
 }
 
 void AddressSorterPosix::Sort(const AddressList& list,
                               const CallbackType& callback) const {
   DCHECK(CalledOnValidThread());
   std::vector<scoped_ptr<DestinationInfo>> sort_list;
 
   for (size_t i = 0; i < list.size(); ++i) {
     scoped_ptr<DestinationInfo> info(new DestinationInfo());
-    info->address = list[i].address();
+    info->address = list[i].address().bytes();
     info->scope = GetScope(ipv4_scope_table_, info->address);
     info->precedence = GetPolicyValue(precedence_table_, info->address);
     info->label = GetPolicyValue(label_table_, info->address);
 
     // Each socket can only be bound once.
     scoped_ptr<DatagramClientSocket> socket(
         socket_factory_->CreateDatagramClientSocket(
             DatagramSocket::DEFAULT_BIND,
             RandIntCallback(),
             NULL /* NetLog */,
             NetLog::Source()));
 
     // Even though no packets are sent, cannot use port 0 in Connect.
     IPEndPoint dest(info->address, 80 /* port */);
     int rv = socket->Connect(dest);
     if (rv != OK) {
       VLOG(1) << "Could not connect to " << dest.ToStringWithoutPort()
               << " reason " << rv;
       continue;
     }
     // Filter out unusable destinations.
     IPEndPoint src;
     rv = socket->GetLocalAddress(&src);
     if (rv != OK) {
       LOG(WARNING) << "Could not get local address for "
                    << dest.ToStringWithoutPort() << " reason " << rv;
       continue;
     }
 
-    SourceAddressInfo& src_info = source_map_[src.address()];
+    SourceAddressInfo& src_info = source_map_[src.address().bytes()];
     if (src_info.scope == SCOPE_UNDEFINED) {
       // If |source_info_| is out of date, |src| might be missing, but we still
       // want to sort, even though the HostCache will be cleared soon.
-      FillPolicy(src.address(), &src_info);
+      FillPolicy(src.address().bytes(), &src_info);
     }
     info->src = &src_info;
 
     if (info->address.size() == src.address().size()) {
-      info->common_prefix_length = std::min(
-          CommonPrefixLength(info->address, src.address()),
-          info->src->prefix_length);
+      info->common_prefix_length =
+          std::min(CommonPrefixLength(info->address, src.address().bytes()),
+                   info->src->prefix_length);
     }
     sort_list.push_back(std::move(info));
   }
 
   std::stable_sort(sort_list.begin(), sort_list.end(), CompareDestinations);
 
   AddressList result;
   for (size_t i = 0; i < sort_list.size(); ++i)
     result.push_back(IPEndPoint(sort_list[i]->address, 0 /* port */));
 
@@ skipping 32 matching lines @@
   if (rv < 0) {
     LOG(WARNING) << "getifaddrs failed " << rv;
     close(ioctl_socket);
     return;
   }
 
   for (struct ifaddrs* ifa = addrs; ifa != NULL; ifa = ifa->ifa_next) {
     IPEndPoint src;
     if (!src.FromSockAddr(ifa->ifa_addr, ifa->ifa_addr->sa_len))
       continue;
-    SourceAddressInfo& info = source_map_[src.address()];
+    SourceAddressInfo& info = source_map_[src.address().bytes()];
     // Note: no known way to fill in |native| and |home|.
     info.native = info.home = info.deprecated = false;
     if (ifa->ifa_addr->sa_family == AF_INET6) {
       struct in6_ifreq ifr = {};
       strncpy(ifr.ifr_name, ifa->ifa_name, sizeof(ifr.ifr_name) - 1);
       DCHECK_LE(ifa->ifa_addr->sa_len, sizeof(ifr.ifr_ifru.ifru_addr));
       memcpy(&ifr.ifr_ifru.ifru_addr, ifa->ifa_addr, ifa->ifa_addr->sa_len);
       int rv = ioctl(ioctl_socket, SIOCGIFAFLAG_IN6, &ifr);
       if (rv >= 0) {
         info.deprecated = ifr.ifr_ifru.ifru_flags & IN6_IFF_DEPRECATED;
       } else {
         LOG(WARNING) << "SIOCGIFAFLAG_IN6 failed " << rv;
       }
     }
     if (ifa->ifa_netmask) {
       IPEndPoint netmask;
       if (netmask.FromSockAddr(ifa->ifa_netmask, ifa->ifa_addr->sa_len)) {
-        info.prefix_length = MaskPrefixLength(netmask.address());
+        info.prefix_length = MaskPrefixLength(netmask.address().bytes());
       } else {
         LOG(WARNING) << "FromSockAddr failed on netmask";
       }
     }
-    FillPolicy(src.address(), &info);
+    FillPolicy(src.address().bytes(), &info);
   }
   freeifaddrs(addrs);
   close(ioctl_socket);
 #endif
 }
 
 void AddressSorterPosix::FillPolicy(const IPAddressNumber& address,
                                     SourceAddressInfo* info) const {
   DCHECK(CalledOnValidThread());
   info->scope = GetScope(ipv4_scope_table_, address);
   info->label = GetPolicyValue(label_table_, address);
 }
 
 // static
 scoped_ptr<AddressSorter> AddressSorter::CreateAddressSorter() {
   return scoped_ptr<AddressSorter>(
       new AddressSorterPosix(ClientSocketFactory::GetDefaultFactory()));
 }
 
 }  // namespace net