Migrate net/proxy/* to net::IPAddress.

net/proxy/proxy_resolver_v8.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/proxy/proxy_resolver_v8.h"
 
 #include <algorithm>
 #include <cstdio>
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/compiler_specific.h"
 #include "base/debug/leak_annotations.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "gin/array_buffer.h"
 #include "gin/public/isolate_holder.h"
 #include "gin/v8_initializer.h"
-#include "net/base/ip_address_number.h"
+#include "net/base/ip_address.h"
 #include "net/base/net_errors.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_resolver_script.h"
 #include "net/proxy/proxy_resolver_script_data.h"
 #include "url/gurl.h"
 #include "url/url_canon.h"
 #include "v8/include/v8.h"
 
 // Notes on the javascript environment:
 //
@@ skipping 202 matching lines @@
   // (We could use UTF16ToASCII() instead, but that requires an extra string
   // copy. Since ASCII is a subset of UTF8 the following is equivalent).
   bool success = base::UTF16ToUTF8(punycode_output.data(),
                              punycode_output.length(),
                              hostname);
   DCHECK(success);
   DCHECK(base::IsStringASCII(*hostname));
   return success;
 }
 
-// Wrapper for passing around IP address strings and IPAddressNumber objects.
-struct IPAddress {
-  IPAddress(const std::string& ip_string, const IPAddressNumber& ip_number)
-      : string_value(ip_string),
-        ip_address_number(ip_number) {
-  }
+// Wrapper for passing around IP address strings and IPAddress objects.
+struct IPAddressInfo {
+  IPAddressInfo(const std::string& ip_string, const IPAddress& ip_address)
+      : string_value(ip_string), ip_address(ip_address) {}
 
   // Used for sorting IP addresses in ascending order in SortIpAddressList().
   // IP6 addresses are placed ahead of IPv4 addresses.
-  bool operator<(const IPAddress& rhs) const {
-    const IPAddressNumber& ip1 = this->ip_address_number;
-    const IPAddressNumber& ip2 = rhs.ip_address_number;
+  bool operator<(const IPAddressInfo& rhs) const {
+    const IPAddress& ip1 = this->ip_address;
+    const IPAddress& ip2 = rhs.ip_address;
     if (ip1.size() != ip2.size())
       return ip1.size() > ip2.size();  // IPv6 before IPv4.
     DCHECK(ip1.size() == ip2.size());
-    return memcmp(&ip1[0], &ip2[0], ip1.size()) < 0;  // Ascending order.
+    return memcmp(ip1.bytes().data(), ip2.bytes().data(), ip1.size()) <

[eroman, 2016/03/18 19:59:45]

Since IPAddress already has an operator<() we can fallback tot that here:

return ip1 < ip2;

[martijnc, 2016/03/18 21:41:11]

Done.

+           0;  // Ascending order.
   }
 
   std::string string_value;
-  IPAddressNumber ip_address_number;
+  IPAddress ip_address;
 };
 
 // Handler for "sortIpAddressList(IpAddressList)". |ip_address_list| is a
 // semi-colon delimited string containing IP addresses.
 // |sorted_ip_address_list| is the resulting list of sorted semi-colon delimited
 // IP addresses or an empty string if unable to sort the IP address list.
 // Returns 'true' if the sorting was successful, and 'false' if the input was an
 // empty string, a string of separators (";" in this case), or if any of the IP
 // addresses in the input list failed to parse.
 bool SortIpAddressList(const std::string& ip_address_list,
                        std::string* sorted_ip_address_list) {
   sorted_ip_address_list->clear();
 
   // Strip all whitespace (mimics IE behavior).
   std::string cleaned_ip_address_list;
   base::RemoveChars(ip_address_list, " \t", &cleaned_ip_address_list);
   if (cleaned_ip_address_list.empty())
     return false;
 
   // Split-up IP addresses and store them in a vector.
-  std::vector<IPAddress> ip_vector;
-  IPAddressNumber ip_num;
+  std::vector<IPAddressInfo> ip_vector;
+  IPAddress ip_address;
   base::StringTokenizer str_tok(cleaned_ip_address_list, ";");
   while (str_tok.GetNext()) {
-    if (!ParseIPLiteralToNumber(str_tok.token(), &ip_num))
+    if (!ip_address.AssignFromIPLiteral(str_tok.token()))
       return false;
-    ip_vector.push_back(IPAddress(str_tok.token(), ip_num));
+    ip_vector.push_back(IPAddressInfo(str_tok.token(), ip_address));
   }
 
   if (ip_vector.empty())  // Can happen if we have something like
     return false;         // sortIpAddressList(";") or sortIpAddressList("; ;")
 
   DCHECK(!ip_vector.empty());
 
   // Sort lists according to ascending numeric value.
   if (ip_vector.size() > 1)
     std::stable_sort(ip_vector.begin(), ip_vector.end());
 
   // Return a semi-colon delimited list of sorted addresses (IPv6 followed by
   // IPv4).
   for (size_t i = 0; i < ip_vector.size(); ++i) {
     if (i > 0)
       *sorted_ip_address_list += ";";
     *sorted_ip_address_list += ip_vector[i].string_value;
   }
   return true;
 }
 
 // Handler for "isInNetEx(ip_address, ip_prefix)". |ip_address| is a string
 // containing an IPv4/IPv6 address, and |ip_prefix| is a string containg a
 // slash-delimited IP prefix with the top 'n' bits specified in the bit
 // field. This returns 'true' if the address is in the same subnet, and
 // 'false' otherwise. Also returns 'false' if the prefix is in an incorrect
 // format, or if an address and prefix of different types are used (e.g. IPv6
 // address and IPv4 prefix).
 bool IsInNetEx(const std::string& ip_address, const std::string& ip_prefix) {
-  IPAddressNumber address;
-  if (!ParseIPLiteralToNumber(ip_address, &address))
+  IPAddress address;
+  if (!address.AssignFromIPLiteral(ip_address))
     return false;
 
-  IPAddressNumber prefix;
+  IPAddress prefix;
   size_t prefix_length_in_bits;
-  if (!ParseCIDRBlock(ip_prefix, &prefix, &prefix_length_in_bits))
+  if (!ParseCIDRBlock(ip_prefix, prefix, prefix_length_in_bits))
     return false;
 
   // Both |address| and |prefix| must be of the same type (IPv4 or IPv6).
   if (address.size() != prefix.size())
     return false;
 
-  DCHECK((address.size() == 4 && prefix.size() == 4) ||
-         (address.size() == 16 && prefix.size() == 16));
+  DCHECK((address.IsIPv4() && prefix.IsIPv4()) ||
+         (address.IsIPv6() && prefix.IsIPv6()));
 
-  return IPNumberMatchesPrefix(address, prefix, prefix_length_in_bits);
+  return IPAddressMatchesPrefix(address, prefix, prefix_length_in_bits);
 }
 
 // Consider only single component domains like 'foo' as plain host names.
 bool IsPlainHostName(const std::string& hostname_utf8) {
   if (hostname_utf8.find('.') != std::string::npos)
     return false;
 
   // IPv6 literals might not contain any periods, however are not considered
   // plain host names.
-  IPAddressNumber unused;
-  return !ParseIPLiteralToNumber(hostname_utf8, &unused);
+  IPAddress unused;
+  return !unused.AssignFromIPLiteral(hostname_utf8);
 }
 
 // All instances of ProxyResolverV8 share the same v8::Isolate. This isolate is
 // created lazily the first time it is needed and lives until process shutdown.
 // This creation might happen from any thread, as ProxyResolverV8 is typically
 // run in a threadpool.
 //
 // TODO(eroman): The lazily created isolate is never freed. Instead it should be
 // disposed once there are no longer any ProxyResolverV8 referencing it.
 class SharedIsolateFactory {
@@ skipping 527 matching lines @@
     return 0;
 
   v8::Locker locked(isolate);
   v8::Isolate::Scope isolate_scope(isolate);
   v8::HeapStatistics heap_statistics;
   isolate->GetHeapStatistics(&heap_statistics);
   return heap_statistics.used_heap_size();
 }
 
 }  // namespace net