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

net/proxy/proxy_bypass_rules.cc

 // Copyright (c) 2011 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_bypass_rules.h"
 
 #include "base/stl_util.h"
 #include "base/strings/pattern.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/host_port_pair.h"
-#include "net/base/ip_address_number.h"
+#include "net/base/ip_address.h"
 #include "net/base/url_util.h"
 
 namespace net {
 
 namespace {
 
 class HostnamePatternRule : public ProxyBypassRules::Rule {
  public:
   HostnamePatternRule(const std::string& optional_scheme,
                       const std::string& hostname_pattern,
@@ skipping 51 matching lines @@
 };
 
 // Rule for matching a URL that is an IP address, if that IP address falls
 // within a certain numeric range. For example, you could use this rule to
 // match all the IPs in the CIDR block 10.10.3.4/24.
 class BypassIPBlockRule : public ProxyBypassRules::Rule {
  public:
   // |ip_prefix| + |prefix_length| define the IP block to match.
   BypassIPBlockRule(const std::string& description,
                     const std::string& optional_scheme,
-                    const IPAddressNumber& ip_prefix,
+                    const IPAddress& ip_prefix,
                     size_t prefix_length_in_bits)
       : description_(description),
         optional_scheme_(optional_scheme),
         ip_prefix_(ip_prefix),
-        prefix_length_in_bits_(prefix_length_in_bits) {
-  }
+        prefix_length_in_bits_(prefix_length_in_bits) {}
 
   bool Matches(const GURL& url) const override {
     if (!url.HostIsIPAddress())
       return false;
 
     if (!optional_scheme_.empty() && url.scheme() != optional_scheme_)
       return false;  // Didn't match scheme expectation.
 
     // Parse the input IP literal to a number.
-    IPAddressNumber ip_number;
-    if (!ParseIPLiteralToNumber(url.HostNoBrackets(), &ip_number))
+    IPAddress ip_address;
+    if (!ip_address.AssignFromIPLiteral(url.HostNoBrackets()))
       return false;
 
     // Test if it has the expected prefix.
-    return IPNumberMatchesPrefix(ip_number, ip_prefix_,
-                                 prefix_length_in_bits_);
+    return IPAddressMatchesPrefix(ip_address, ip_prefix_,
+                                  prefix_length_in_bits_);
   }
 
   std::string ToString() const override { return description_; }
 
   Rule* Clone() const override {
     return new BypassIPBlockRule(description_,
                                  optional_scheme_,
                                  ip_prefix_,
                                  prefix_length_in_bits_);
   }
 
  private:
   const std::string description_;
   const std::string optional_scheme_;
-  const IPAddressNumber ip_prefix_;
+  const IPAddress ip_prefix_;
   const size_t prefix_length_in_bits_;
 };
 
 // Returns true if the given string represents an IP address.
 // IPv6 addresses are expected to be bracketed.
 bool IsIPAddress(const std::string& domain) {
   // From GURL::HostIsIPAddress()
   url::RawCanonOutputT<char, 128> ignored_output;
   url::CanonHostInfo host_info;
   url::Component domain_comp(0, domain.size());
@@ skipping 142 matching lines @@
     if (scheme.empty())
       return false;
   }
 
   if (raw.empty())
     return false;
 
   // If there is a forward slash in the input, it is probably a CIDR style
   // mask.
   if (raw.find('/') != std::string::npos) {
-    IPAddressNumber ip_prefix;
+    IPAddress ip_prefix;
     size_t prefix_length_in_bits;
 
-    if (!ParseCIDRBlock(raw, &ip_prefix, &prefix_length_in_bits))
+    if (!ParseCIDRBlock(raw, ip_prefix, prefix_length_in_bits))
       return false;
 
     rules_.push_back(
         new BypassIPBlockRule(raw, scheme, ip_prefix, prefix_length_in_bits));
 
     return true;
   }
 
   // Check if we have an <ip-address>[:port] input. We need to treat this
   // separately since the IP literal may not be in a canonical form.
@@ skipping 43 matching lines @@
   return AddRuleForHostname(scheme, raw, port);
 }
 
 bool ProxyBypassRules::AddRuleFromStringInternalWithLogging(
     const std::string& raw,
     bool use_hostname_suffix_matching) {
   return AddRuleFromStringInternal(raw, use_hostname_suffix_matching);
 }
 
 }  // namespace net