Remove stl_util's deletion functions from net/proxy/.

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/memory/ptr_util.h"
 #include "base/strings/pattern.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.h"
 #include "net/base/parse_number.h"
 #include "net/base/url_util.h"
 
@@ skipping 25 matching lines @@
   std::string ToString() const override {
     std::string str;
     if (!optional_scheme_.empty())
       base::StringAppendF(&str, "%s://", optional_scheme_.c_str());
     str += hostname_pattern_;
     if (optional_port_ != -1)
       base::StringAppendF(&str, ":%d", optional_port_);
     return str;
   }
 
-  Rule* Clone() const override {
-    return new HostnamePatternRule(optional_scheme_,
-                                   hostname_pattern_,
-                                   optional_port_);
+  std::unique_ptr<Rule> Clone() const override {
+    return base::MakeUnique<HostnamePatternRule>(
+        optional_scheme_, hostname_pattern_, optional_port_);
   }
 
  private:
   const std::string optional_scheme_;
   const std::string hostname_pattern_;
   const int optional_port_;
 };
 
 class BypassLocalRule : public ProxyBypassRules::Rule {
  public:
   bool Matches(const GURL& url) const override {
     const std::string& host = url.host();
     if (host == "127.0.0.1" || host == "[::1]")
       return true;
     return host.find('.') == std::string::npos;
   }
 
   std::string ToString() const override { return "<local>"; }
 
-  Rule* Clone() const override { return new BypassLocalRule(); }
+  std::unique_ptr<Rule> Clone() const override {
+    return base::MakeUnique<BypassLocalRule>();
+  }
 };
 
 // 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,
@@ skipping 16 matching lines @@
     if (!ip_address.AssignFromIPLiteral(url.HostNoBrackets()))
       return false;
 
     // Test if it has the expected prefix.
     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_);
+  std::unique_ptr<Rule> Clone() const override {
+    return base::MakeUnique<BypassIPBlockRule>(
+        description_, optional_scheme_, ip_prefix_, prefix_length_in_bits_);
   }
 
  private:
   const std::string description_;
   const std::string optional_scheme_;
   const IPAddress ip_prefix_;
   const size_t prefix_length_in_bits_;
 };
 
 // Returns true if the given string represents an IP address.
@@ skipping 63 matching lines @@
     const std::string& raw) {
   ParseFromStringInternal(raw, true);
 }
 
 bool ProxyBypassRules::AddRuleForHostname(const std::string& optional_scheme,
                                           const std::string& hostname_pattern,
                                           int optional_port) {
   if (hostname_pattern.empty())
     return false;
 
-  rules_.push_back(new HostnamePatternRule(optional_scheme,
-                                           hostname_pattern,
-                                           optional_port));
+  rules_.push_back(base::MakeUnique<HostnamePatternRule>(
+      optional_scheme, hostname_pattern, optional_port));
   return true;
 }
 
 void ProxyBypassRules::AddRuleToBypassLocal() {
-  rules_.push_back(new BypassLocalRule);
+  rules_.push_back(base::MakeUnique<BypassLocalRule>());
 }
 
 bool ProxyBypassRules::AddRuleFromString(const std::string& raw) {
   return AddRuleFromStringInternalWithLogging(raw, false);
 }
 
 bool ProxyBypassRules::AddRuleFromStringUsingSuffixMatching(
     const std::string& raw) {
   return AddRuleFromStringInternalWithLogging(raw, true);
 }
 
 std::string ProxyBypassRules::ToString() const {
   std::string result;
   for (RuleList::const_iterator rule(rules_.begin());
        rule != rules_.end();
        ++rule) {
     result += (*rule)->ToString();
     result += ";";
   }
   return result;
 }
 
 void ProxyBypassRules::Clear() {
-  base::STLDeleteElements(&rules_);
+  rules_.clear();
 }
 
 void ProxyBypassRules::AssignFrom(const ProxyBypassRules& other) {
   Clear();
 
   // Make a copy of the rules list.
   for (RuleList::const_iterator it = other.rules_.begin();
        it != other.rules_.end(); ++it) {
     rules_.push_back((*it)->Clone());
   }
@@ skipping 39 matching lines @@
 
   // If there is a forward slash in the input, it is probably a CIDR style
   // mask.
   if (raw.find('/') != std::string::npos) {
     IPAddress ip_prefix;
     size_t 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));
+    rules_.push_back(base::MakeUnique<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.
   std::string host;
   int port;
   if (ParseHostAndPort(raw, &host, &port)) {
     // TODO(eroman): HostForURL() below DCHECKs() when |host| contains an
@@ skipping 37 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