Revert "Support replacement of IP address resolutions via command line flag"

net/base/ip_mapping_rules.cc

-// Copyright 2014 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/ip_mapping_rules.h"
-
-#include <vector>
-
-#include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/stl_util.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_split.h"
-#include "base/strings/string_tokenizer.h"
-#include "base/strings/string_util.h"
-#include "net/base/address_list.h"
-#include "net/base/ip_pattern.h"
-
-namespace net {
-
-class IPMappingRules::Rule {
- public:
-  Rule(const IPAddressNumber& address, IPPattern* pattern)
-      : pattern_(pattern),
-        replacement_address_(address) {
-  }
-
-  bool Match(const IPAddressNumber& address) const {
-    return pattern_->Match(address);
-  }
-
-  const IPAddressNumber& replacement_address() const {
-    return replacement_address_;
-  }
-
- private:
-  scoped_ptr<IPPattern> pattern_;        // The pattern we can match.
-  IPAddressNumber replacement_address_;  // The replacement address we provide.
-  DISALLOW_COPY_AND_ASSIGN(Rule);
-};
-
-IPMappingRules::IPMappingRules() {}
-
-IPMappingRules::~IPMappingRules() {
-  STLDeleteElements(&rules_);
-}
-
-bool IPMappingRules::RewriteAddresses(AddressList* addresses) const {
-  // Last rule pushed into the list has the highest priority, and is tested
-  // first.
-  for (RuleList::const_reverse_iterator rule_it = rules_.rbegin();
-       rule_it != rules_.rend(); ++rule_it) {
-    for (AddressList::iterator address_it = addresses->begin();
-        address_it != addresses->end(); ++address_it) {
-      if (!(*rule_it)->Match(address_it->address()))
-        continue;
-      // We have a match.
-      int port = address_it->port();
-      addresses->insert(addresses->begin(),
-                        IPEndPoint((*rule_it)->replacement_address(), port));
-      return true;
-    }
-  }
-  return false;
-}
-
-bool IPMappingRules::AddRuleFromString(const std::string& rule_string) {
-  std::string trimmed;
-  base::TrimWhitespaceASCII(rule_string, base::TRIM_ALL, &trimmed);
-  if (trimmed.empty())
-    return true;  // Allow empty rules.
-
-  std::vector<std::string> parts;
-  base::SplitString(trimmed, ' ', &parts);
-
-  if (parts.size() != 3) {
-    DVLOG(1) << "Rule has wrong number of parts: " << rule_string;
-    return false;
-  }
-
-  if (!LowerCaseEqualsASCII(parts[0], "preface")) {
-    DVLOG(1) << "Unknown directive: " << rule_string;
-    return false;
-  }
-
-  scoped_ptr<IPPattern> pattern(new IPPattern);
-  if (!pattern->ParsePattern(parts[1])) {
-    DVLOG(1) << "Unacceptable pattern: " << rule_string;
-    return false;
-  }
-
-  IPAddressNumber address;
-  if (!ParseIPLiteralToNumber(parts[2], &address)) {
-    DVLOG(1) << "Invalid replacement address: " << rule_string;
-    return false;
-  }
-
-  if (pattern->is_ipv4() != (address.size() == kIPv4AddressSize)) {
-    DVLOG(1) << "Mixture of IPv4 and IPv6: " << rule_string;
-    return false;
-  }
-  rules_.push_back(new Rule(address, pattern.release()));
-  return true;
-}
-
-bool IPMappingRules::SetRulesFromString(const std::string& rules_string) {
-  STLDeleteElements(&rules_);
-
-  base::StringTokenizer rules(rules_string, ";");
-  while (rules.GetNext()) {
-    if (!AddRuleFromString(rules.token())) {
-      DVLOG(1) << "Failed parsing rule: " << rules.token();
-      STLDeleteElements(&rules_);
-      return false;
-    }
-  }
-  return true;
-}
-
-}  // namespace net