Remove //net (except for Android test stuff) and sdch

net/base/ip_pattern.cc

Index: net/base/ip_pattern.cc
diff --git a/net/base/ip_pattern.cc b/net/base/ip_pattern.cc
deleted file mode 100644
index f67d3a0ba64b9d590cc7dcd57800290b3d356e14..0000000000000000000000000000000000000000
--- a/net/base/ip_pattern.cc
+++ /dev/null
@@ -1,188 +0,0 @@
-// 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_pattern.h"
-
-#include <string>
-
-#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"
-
-namespace net {
-
-class IPPattern::ComponentPattern {
- public:
-  ComponentPattern();
-  void AppendRange(uint32 min, uint32 max);
-  bool Match(uint32 value) const;
-
- private:
-  struct Range {
-   public:
-    Range(uint32 min, uint32 max) : minimum(min), maximum(max) {}
-    uint32 minimum;
-    uint32 maximum;
-  };
-  typedef std::vector<Range> RangeVector;
-
-  RangeVector ranges_;
-
-  DISALLOW_COPY_AND_ASSIGN(ComponentPattern);
-};
-
-IPPattern::ComponentPattern::ComponentPattern() {}
-
-void IPPattern::ComponentPattern::AppendRange(uint32 min, uint32 max) {
-  ranges_.push_back(Range(min, max));
-}
-
-bool IPPattern::ComponentPattern::Match(uint32 value) const {
-  // Simple linear search should be fine, as we usually only have very few
-  // distinct ranges to test.
-  for (RangeVector::const_iterator range_it = ranges_.begin();
-       range_it != ranges_.end(); ++range_it) {
-    if (range_it->maximum >= value && range_it->minimum <= value)
-      return true;
-  }
-  return false;
-}
-
-IPPattern::IPPattern() : is_ipv4_(true) {}
-
-IPPattern::~IPPattern() {
-  STLDeleteElements(&component_patterns_);
-}
-
-bool IPPattern::Match(const IPAddressNumber& address) const {
-  if (ip_mask_.empty())
-    return false;
-  bool address_is_ipv4 = address.size() == kIPv4AddressSize;
-  if (address_is_ipv4 != is_ipv4_)
-    return false;
-
-  ComponentPatternList::const_iterator pattern_it(component_patterns_.begin());
-  int fixed_value_index = 0;
-  // IPv6 |address| vectors have 16 pieces, while our  |ip_mask_| has only
-  // 8, so it is easier to count separately.
-  int address_index = 0;
-  for (size_t i = 0; i < ip_mask_.size(); ++i) {
-    uint32 value_to_test = address[address_index++];
-    if (!is_ipv4_) {
-      value_to_test = (value_to_test << 8) + address[address_index++];
-    }
-    if (ip_mask_[i]) {
-      if (component_values_[fixed_value_index++] != value_to_test)
-        return false;
-      continue;
-    }
-    if (!(*pattern_it)->Match(value_to_test))
-      return false;
-    ++pattern_it;
-  }
-  return true;
-}
-
-bool IPPattern::ParsePattern(const std::string& ip_pattern) {
-  DCHECK(ip_mask_.empty());
-  if (ip_pattern.find(':') != std::string::npos) {
-    is_ipv4_ = false;
-  }
-  Strings components;
-  base::SplitString(ip_pattern, is_ipv4_ ? '.' : ':', &components);
-  if (components.size() != (is_ipv4_ ? 4u : 8u)) {
-    DVLOG(1) << "Invalid component count: " << ip_pattern;
-    return false;
-  }
-  for (Strings::iterator component_it = components.begin();
-       component_it != components.end(); ++component_it) {
-    if (component_it->empty()) {
-      DVLOG(1) << "Empty component: " << ip_pattern;
-      return false;
-    }
-    if (*component_it == "*") {
-      // Let standard code handle this below.
-      *component_it = is_ipv4_ ? "[0-255]" : "[0-FFFF]";
-    } else if ((*component_it)[0] != '[') {
-      // This value will just have a specific integer to match.
-      uint32 value;
-      if (!ValueTextToInt(*component_it, &value))
-        return false;
-      ip_mask_.push_back(true);
-      component_values_.push_back(value);
-      continue;
-    }
-    if ((*component_it)[component_it->size() - 1] != ']') {
-      DVLOG(1) << "Missing close bracket: " << ip_pattern;
-      return false;
-    }
-    // Now we know the size() is at least 2.
-    if (component_it->size() == 2) {
-      DVLOG(1) << "Empty bracket: " << ip_pattern;
-      return false;
-    }
-    // We'll need a pattern to match this bracketed component.
-    scoped_ptr<ComponentPattern> component_pattern(new ComponentPattern);
-    // Trim leading and trailing bracket before calling for parsing.
-    if (!ParseComponentPattern(base::StringPiece(component_it->data() + 1,
-        component_it->size() - 2), component_pattern.get())) {
-      return false;
-    }
-    ip_mask_.push_back(false);
-    component_patterns_.push_back(component_pattern.release());
-  }
-  return true;
-}
-
-bool IPPattern::ParseComponentPattern(const base::StringPiece& text,
-                                      ComponentPattern* pattern) const {
-  // We're given a comma separated set of ranges, some of which may be simple
-  // constants.
-  Strings ranges;
-  base::SplitString(text.as_string(), ',', &ranges);
-  for (Strings::iterator range_it = ranges.begin();
-        range_it != ranges.end(); ++range_it) {
-    base::StringTokenizer range_pair(*range_it, "-");
-    uint32 min = 0;
-    range_pair.GetNext();
-    if (!ValueTextToInt(range_pair.token(), &min))
-      return false;
-    uint32 max = min;  // Sometimes we have no distinct max.
-    if (range_pair.GetNext()) {
-      if (!ValueTextToInt(range_pair.token(), &max))
-        return false;
-    }
-    if (range_pair.GetNext()) {
-      // Too many "-" in this range specifier.
-      DVLOG(1) << "Too many hyphens in range: ";
-      return false;
-    }
-    pattern->AppendRange(min, max);
-  }
-  return true;
-}
-
-bool IPPattern::ValueTextToInt(const base::StringPiece& input,
-                               uint32* output) const {
-  bool ok = is_ipv4_ ? base::StringToUint(input, output) :
-                       base::HexStringToUInt(input, output);
-  if (!ok) {
-    DVLOG(1) << "Could not convert value to number: " << input;
-    return false;
-  }
-  if (is_ipv4_ && *output > 255u) {
-    DVLOG(1) << "IPv4 component greater than 255";
-    return false;
-  }
-  if (!is_ipv4_ && *output > 0xFFFFu) {
-    DVLOG(1) << "IPv6 component greater than 0xFFFF";
-    return false;
-  }
-  return ok;
-}
-
-}  // namespace net