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

net/proxy/proxy_bypass_rules.h

 // 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.
 
 #ifndef NET_PROXY_PROXY_BYPASS_RULES_H_
 #define NET_PROXY_PROXY_BYPASS_RULES_H_
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "net/base/net_export.h"
 #include "url/gurl.h"
 
 namespace net {
 
 // ProxyBypassRules describes the set of URLs that should bypass the proxy
 // settings, as a list of rules. A URL is said to match the bypass rules
 // if it matches any one of these rules.
 class NET_EXPORT ProxyBypassRules {
  public:
   // Interface for an individual proxy bypass rule.
   class NET_EXPORT Rule {
    public:
     Rule();
     virtual ~Rule();
 
     // Returns true if |url| matches the rule.
     virtual bool Matches(const GURL& url) const = 0;
 
     // Returns a string representation of this rule. This is used both for
     // visualizing the rules, and also to test equality of a rules list.
     virtual std::string ToString() const = 0;
 
-    // Creates a copy of this rule. (Caller is responsible for deleting it)
-    virtual Rule* Clone() const = 0;
+    // Creates a copy of this rule.
+    virtual std::unique_ptr<Rule> Clone() const = 0;
 
     bool Equals(const Rule& rule) const;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Rule);
   };
 
-  typedef std::vector<const Rule*> RuleList;
+  typedef std::vector<std::unique_ptr<Rule>> RuleList;
 
   // Note: This class supports copy constructor and assignment.
   ProxyBypassRules();
   ProxyBypassRules(const ProxyBypassRules& rhs);
   ~ProxyBypassRules();
   ProxyBypassRules& operator=(const ProxyBypassRules& rhs);
 
   // Returns the current list of rules. The rules list contains pointers
   // which are owned by this class, callers should NOT keep references
   // or delete them.
   const RuleList& rules() const { return rules_; }
 
   // Returns true if |url| matches any of the proxy bypass rules.
   bool Matches(const GURL& url) const;
 
   // Returns true if |*this| is equal to |other|; in other words, whether they
   // describe the same set of rules.
   bool Equals(const ProxyBypassRules& other) const;
 
   // Initializes the list of rules by parsing the string |raw|. |raw| is a
   // comma separated list of rules. See AddRuleFromString() to see the list
   // of supported formats.
   void ParseFromString(const std::string& raw);
 
   // This is a variant of ParseFromString, which interprets hostname patterns
   // as suffix tests rather than hostname tests (so "google.com" would actually
   // match "*google.com"). This is only currently used for the linux no_proxy
-  // evironment variable. It is less flexible, since with the suffix matching
+  // environment variable. It is less flexible, since with the suffix matching
   // format you can't match an individual host.
   // NOTE: Use ParseFromString() unless you truly need this behavior.
   void ParseFromStringUsingSuffixMatching(const std::string& raw);
 
   // Adds a rule that matches a URL when all of the following are true:
   //  (a) The URL's scheme matches |optional_scheme|, if
   //      |!optional_scheme.empty()|
   //  (b) The URL's hostname matches |hostname_pattern|.
   //  (c) The URL's (effective) port number matches |optional_port| if
   //      |optional_port != -1|
@@ skipping 88 matching lines @@
                                  bool use_hostname_suffix_matching);
   bool AddRuleFromStringInternalWithLogging(const std::string& raw,
                                             bool use_hostname_suffix_matching);
 
   RuleList rules_;
 };
 
 }  // namespace net
 
 #endif  // NET_PROXY_PROXY_BYPASS_RULES_H_