Implemented proper support for checking schemes and requested resource types.

chrome/browser/extensions/api/declarative/url_matcher_unittest.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 "chrome/browser/extensions/api/declarative/url_matcher.h"
 
 #include "base/string_util.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 12 matching lines @@
   URLMatcherCondition m2;
   m2 = m1;
   EXPECT_EQ(URLMatcherCondition::HOST_SUFFIX, m2.criterion());
   EXPECT_EQ(&pattern, m2.substring_pattern());
 
   URLMatcherCondition m3(m1);
   EXPECT_EQ(URLMatcherCondition::HOST_SUFFIX, m3.criterion());
   EXPECT_EQ(&pattern, m3.substring_pattern());
 }
 
+TEST(URLMatcherSchemeFilter, TestMatching) {
+  URLMatcherSchemeFilter filter1("https");
+  std::vector<std::string> filter2_content;
+  filter2_content.push_back("http");
+  filter2_content.push_back("https");
+  URLMatcherSchemeFilter filter2(filter2_content);
+
+  GURL matching_url("https://www.foobar.com");
+  GURL non_matching_url("http://www.foobar.com");
+  EXPECT_TRUE(filter1.IsMatch(matching_url));
+  EXPECT_FALSE(filter1.IsMatch(non_matching_url));
+  EXPECT_TRUE(filter2.IsMatch(matching_url));
+  EXPECT_TRUE(filter2.IsMatch(non_matching_url));
+}
+
 TEST(URLMatcherConditionTest, IsFullURLCondition) {
   SubstringPattern pattern("example.com", 1);
   EXPECT_FALSE(URLMatcherCondition(URLMatcherCondition::HOST_SUFFIX,
       &pattern).IsFullURLCondition());
 
   EXPECT_TRUE(URLMatcherCondition(URLMatcherCondition::HOST_CONTAINS,
       &pattern).IsFullURLCondition());
   EXPECT_TRUE(URLMatcherCondition(URLMatcherCondition::PATH_CONTAINS,
       &pattern).IsFullURLCondition());
   EXPECT_TRUE(URLMatcherCondition(URLMatcherCondition::QUERY_CONTAINS,
@@ skipping 273 matching lines @@
   EXPECT_EQ(1, condition_set->id());
   EXPECT_EQ(2u, condition_set->conditions().size());
 
   std::set<SubstringPattern::ID> matching_substring_patterns;
   matching_substring_patterns.insert(m1.substring_pattern()->id());
   EXPECT_FALSE(condition_set->IsMatch(matching_substring_patterns, url1));
 
   matching_substring_patterns.insert(m2.substring_pattern()->id());
   EXPECT_TRUE(condition_set->IsMatch(matching_substring_patterns, url1));
   EXPECT_FALSE(condition_set->IsMatch(matching_substring_patterns, url2));
+
+
+  // Test scheme filters.
+  scoped_refptr<URLMatcherConditionSet> condition_set2(
+      new URLMatcherConditionSet(1, conditions,
+          scoped_ptr<URLMatcherSchemeFilter>(
+              new URLMatcherSchemeFilter("https"))));
+  EXPECT_FALSE(condition_set2->IsMatch(matching_substring_patterns, url1));
+  scoped_refptr<URLMatcherConditionSet> condition_set3(
+      new URLMatcherConditionSet(1, conditions,
+          scoped_ptr<URLMatcherSchemeFilter>(
+              new URLMatcherSchemeFilter("http"))));
+  EXPECT_TRUE(condition_set3->IsMatch(matching_substring_patterns, url1));
 }
 
 
 //
 // URLMatcher
 //
 
 TEST(URLMatcherTest, FullTest) {
   GURL url1("http://www.example.com/foo?bar=1");
   GURL url2("http://foo.example.com/index.html");
@@ skipping 49 matching lines @@
   // The cached singleton in matcher.condition_factory_ should be destroyed to
   // free memory.
   int patternId2 = factory->CreateHostSuffixCondition(
       "example.com").substring_pattern()->id();
   // If patternId1 and patternId2 are different that indicates that
   // matcher.condition_factory_ does not leak memory.
   EXPECT_NE(patternId1, patternId2);
 }
 
 }  // namespace extensions