Remove some legacy versions of StartsWith and EndsWith.

extensions/browser/api/declarative_webrequest/webrequest_condition_attribute.cc

 // Copyright (c) 2012 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 "extensions/browser/api/declarative_webrequest/webrequest_condition_attribute.h"
 
 #include <algorithm>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 312 matching lines @@
     // Does |str| pass |this| StringMatchTest?
     bool Matches(const std::string& str) const;
 
    private:
     StringMatchTest(const std::string& data,
                     MatchType type,
                     bool case_sensitive);
 
     const std::string data_;
     const MatchType type_;
-    const bool case_sensitive_;
+    const base::CompareCase case_sensitive_;
     DISALLOW_COPY_AND_ASSIGN(StringMatchTest);
   };
 
   // Represents a test group -- a set of string matching tests to be applied to
   // both the header name and value.
   class HeaderMatchTest {
    public:
     ~HeaderMatchTest();
 
     // Gets the test group description in |tests| and creates the corresponding
@@ skipping 71 matching lines @@
   return scoped_ptr<StringMatchTest>(
       new StringMatchTest(str, type, case_sensitive));
 }
 
 HeaderMatcher::StringMatchTest::~StringMatchTest() {}
 
 bool HeaderMatcher::StringMatchTest::Matches(
     const std::string& str) const {
   switch (type_) {
     case kPrefix:
-      return base::StartsWithASCII(str, data_, case_sensitive_);
+      return base::StartsWith(str, data_, case_sensitive_);
     case kSuffix:
       return base::EndsWith(str, data_, case_sensitive_);
     case kEquals:
       return str.size() == data_.size() &&
-             base::StartsWithASCII(str, data_, case_sensitive_);
+             base::StartsWith(str, data_, case_sensitive_);
     case kContains:
-      if (!case_sensitive_) {
+      if (case_sensitive_ == base::CompareCase::INSENSITIVE_ASCII) {
         return std::search(str.begin(), str.end(), data_.begin(), data_.end(),
                            CaseInsensitiveCompareASCII<char>()) != str.end();
       } else {
         return str.find(data_) != std::string::npos;
       }
   }
   // We never get past the "switch", but the compiler worries about no return.
   NOTREACHED();
   return false;
 }
 
 HeaderMatcher::StringMatchTest::StringMatchTest(const std::string& data,
                                                 MatchType type,
                                                 bool case_sensitive)
     : data_(data),
       type_(type),
-      case_sensitive_(case_sensitive) {}
+      case_sensitive_(case_sensitive ? base::CompareCase::SENSITIVE
+                                     : base::CompareCase::INSENSITIVE_ASCII) {}
 
 // HeaderMatcher::HeaderMatchTest implementation.
 
 HeaderMatcher::HeaderMatchTest::HeaderMatchTest(
     ScopedVector<const StringMatchTest>* name_match,
     ScopedVector<const StringMatchTest>* value_match)
     : name_match_(name_match->Pass()),
       value_match_(value_match->Pass()) {}
 
 HeaderMatcher::HeaderMatchTest::~HeaderMatchTest() {}
@@ skipping 409 matching lines @@
 bool WebRequestConditionAttributeStages::Equals(
     const WebRequestConditionAttribute* other) const {
   if (!WebRequestConditionAttribute::Equals(other))
     return false;
   const WebRequestConditionAttributeStages* casted_other =
       static_cast<const WebRequestConditionAttributeStages*>(other);
   return allowed_stages_ == casted_other->allowed_stages_;
 }
 
 }  // namespace extensions