replace OVERRIDE and FINAL with override and final in net/

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/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/net_util.h"
 
 namespace net {
 
 namespace {
 
 class HostnamePatternRule : public ProxyBypassRules::Rule {
  public:
   HostnamePatternRule(const std::string& optional_scheme,
                       const std::string& hostname_pattern,
                       int optional_port)
       : optional_scheme_(base::StringToLowerASCII(optional_scheme)),
         hostname_pattern_(base::StringToLowerASCII(hostname_pattern)),
         optional_port_(optional_port) {
   }
 
-  virtual bool Matches(const GURL& url) const OVERRIDE {
+  virtual bool Matches(const GURL& url) const override {
     if (optional_port_ != -1 && url.EffectiveIntPort() != optional_port_)
       return false;  // Didn't match port expectation.
 
     if (!optional_scheme_.empty() && url.scheme() != optional_scheme_)
       return false;  // Didn't match scheme expectation.
 
     // Note it is necessary to lower-case the host, since GURL uses capital
     // letters for percent-escaped characters.
     return MatchPattern(base::StringToLowerASCII(url.host()),
                         hostname_pattern_);
   }
 
-  virtual std::string ToString() const OVERRIDE {
+  virtual 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;
   }
 
-  virtual Rule* Clone() const OVERRIDE {
+  virtual Rule* Clone() const override {
     return new 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:
-  virtual bool Matches(const GURL& url) const OVERRIDE {
+  virtual 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;
   }
 
-  virtual std::string ToString() const OVERRIDE {
+  virtual std::string ToString() const override {
     return "<local>";
   }
 
-  virtual Rule* Clone() const OVERRIDE {
+  virtual Rule* Clone() const override {
     return new 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,
                     const IPAddressNumber& 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) {
   }
 
-  virtual bool Matches(const GURL& url) const OVERRIDE {
+  virtual 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))
       return false;
 
     // Test if it has the expected prefix.
     return IPNumberMatchesPrefix(ip_number, ip_prefix_,
                                  prefix_length_in_bits_);
   }
 
-  virtual std::string ToString() const OVERRIDE {
+  virtual std::string ToString() const override {
     return description_;
   }
 
-  virtual Rule* Clone() const OVERRIDE {
+  virtual 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_;
@@ skipping 213 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