Remove Windows Vista/XP specific code from net/base

net/base/network_interfaces_win.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/base/network_interfaces_win.h"
 
 #include <algorithm>
 #include <memory>
 
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/windows_version.h"

[mmenke, 2016/05/17 11:25:23]

This header is no longer needed.

 #include "net/base/escape.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "url/gurl.h"
 
 namespace net {
 
 namespace {
 
 // Converts Windows defined types to NetworkInterfaceType.
 NetworkChangeNotifier::ConnectionType GetNetworkInterfaceType(DWORD ifType) {
-  // Bail out for pre-Vista versions of Windows which are documented to give
-  // inaccurate results like returning Ethernet for WiFi.
-  // http://msdn.microsoft.com/en-us/library/windows/desktop/aa366058.aspx
-  if (base::win::GetVersion() < base::win::VERSION_VISTA)
-    return NetworkChangeNotifier::CONNECTION_UNKNOWN;
-
   NetworkChangeNotifier::ConnectionType type =
       NetworkChangeNotifier::CONNECTION_UNKNOWN;
   if (ifType == IF_TYPE_ETHERNET_CSMACD) {
     type = NetworkChangeNotifier::CONNECTION_ETHERNET;
   } else if (ifType == IF_TYPE_IEEE80211) {
     type = NetworkChangeNotifier::CONNECTION_WIFI;
   }
   // TODO(mallinath) - Cellular?
   return type;
 }
@@ skipping 83 matching lines @@
       ::GetProcAddress(module, "WlanFreeMemory"));
   close_handle_func = reinterpret_cast<WlanCloseHandleFunc>(
       ::GetProcAddress(module, "WlanCloseHandle"));
   initialized = open_handle_func && enum_interfaces_func &&
       query_interface_func && set_interface_func &&
       free_memory_func && close_handle_func;
 }
 
 bool GetNetworkListImpl(NetworkInterfaceList* networks,
                         int policy,
-                        bool is_xp,
                         const IP_ADAPTER_ADDRESSES* adapters) {
   for (const IP_ADAPTER_ADDRESSES* adapter = adapters; adapter != NULL;
        adapter = adapter->Next) {
     // Ignore the loopback device.
     if (adapter->IfType == IF_TYPE_SOFTWARE_LOOPBACK) {
       continue;
     }
 
     if (adapter->OperStatus != IfOperStatusUp) {
       continue;
     }
 
     // Ignore any HOST side vmware adapters with a description like:
     // VMware Virtual Ethernet Adapter for VMnet1
     // but don't ignore any GUEST side adapters with a description like:
     // VMware Accelerated AMD PCNet Adapter #2
     if ((policy & EXCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES) &&
         strstr(adapter->AdapterName, "VMnet") != NULL) {
       continue;
     }
 
     for (IP_ADAPTER_UNICAST_ADDRESS* address = adapter->FirstUnicastAddress;
          address; address = address->Next) {
       int family = address->Address.lpSockaddr->sa_family;
       if (family == AF_INET || family == AF_INET6) {
         IPEndPoint endpoint;
         if (endpoint.FromSockAddr(address->Address.lpSockaddr,
                                   address->Address.iSockaddrLength)) {
-          // XP has no OnLinkPrefixLength field.
-          size_t prefix_length = is_xp ? 0 : address->OnLinkPrefixLength;
-          if (is_xp) {
-            // Prior to Windows Vista the FirstPrefix pointed to the list with
-            // single prefix for each IP address assigned to the adapter.
-            // Order of FirstPrefix does not match order of FirstUnicastAddress,
-            // so we need to find corresponding prefix.
-            for (IP_ADAPTER_PREFIX* prefix = adapter->FirstPrefix; prefix;
-                 prefix = prefix->Next) {
-              int prefix_family = prefix->Address.lpSockaddr->sa_family;
-              IPEndPoint network_endpoint;
-              if (prefix_family == family &&
-                  network_endpoint.FromSockAddr(
-                      prefix->Address.lpSockaddr,
-                      prefix->Address.iSockaddrLength) &&
-                  IPAddressMatchesPrefix(endpoint.address(),
-                                         network_endpoint.address(),
-                                         prefix->PrefixLength)) {
-                prefix_length =
-                    std::max<size_t>(prefix_length, prefix->PrefixLength);
-              }
-            }
-          }
+          size_t prefix_length = address->OnLinkPrefixLength;
 
           // If the duplicate address detection (DAD) state is not changed to
           // Preferred, skip this address.
           if (address->DadState != IpDadStatePreferred) {
             continue;
           }
 
           uint32_t index =
               (family == AF_INET) ? adapter->IfIndex : adapter->Ipv6IfIndex;
 
@@ skipping 19 matching lines @@
         }
       }
     }
   }
   return true;
 }
 
 }  // namespace internal
 
 bool GetNetworkList(NetworkInterfaceList* networks, int policy) {
-  bool is_xp = base::win::GetVersion() < base::win::VERSION_VISTA;
   ULONG len = 0;
-  ULONG flags = is_xp ? GAA_FLAG_INCLUDE_PREFIX : 0;
+  ULONG flags = 0;
   // GetAdaptersAddresses() may require IO operations.
   base::ThreadRestrictions::AssertIOAllowed();
   ULONG result = GetAdaptersAddresses(AF_UNSPEC, flags, NULL, NULL, &len);
   if (result != ERROR_BUFFER_OVERFLOW) {
     // There are 0 networks.
     return true;
   }
   std::unique_ptr<char[]> buf(new char[len]);
   IP_ADAPTER_ADDRESSES* adapters =
       reinterpret_cast<IP_ADAPTER_ADDRESSES*>(buf.get());
   result = GetAdaptersAddresses(AF_UNSPEC, flags, NULL, adapters, &len);
   if (result != NO_ERROR) {
     LOG(ERROR) << "GetAdaptersAddresses failed: " << result;
     return false;
   }
 
-  return internal::GetNetworkListImpl(networks, policy, is_xp, adapters);
+  return internal::GetNetworkListImpl(networks, policy, adapters);
 }
 
 WifiPHYLayerProtocol GetWifiPHYLayerProtocol() {
   auto conn_info = GetConnectionAttributes();
 
   if (!conn_info.get())
     return WIFI_PHY_LAYER_PROTOCOL_NONE;
 
   switch (conn_info->wlanAssociationAttributes.dot11PhyType) {
     case dot11_phy_type_fhss:
@@ skipping 76 matching lines @@
 
   if (!conn_info.get())
     return "";
 
   const DOT11_SSID dot11_ssid = conn_info->wlanAssociationAttributes.dot11Ssid;
   return std::string(reinterpret_cast<const char*>(dot11_ssid.ucSSID),
                      dot11_ssid.uSSIDLength);
 }
 
 }  // namespace net