Implemented proper support for checking schemes and requested resource types.

chrome/browser/extensions/api/declarative_webrequest/webrequest_condition.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_webrequest/webrequest_condition.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
+#include "chrome/browser/extensions/api/declarative/url_matcher.h"
 #include "chrome/browser/extensions/api/declarative_webrequest/request_stages.h"
 #include "chrome/browser/extensions/api/declarative_webrequest/webrequest_condition_attribute.h"
 #include "chrome/browser/extensions/api/declarative_webrequest/webrequest_constants.h"
+#include "chrome/browser/extensions/api/declarative_webrequest/webrequest_helpers.h"
 #include "net/url_request/url_request.h"
 
+namespace helpers = extensions::declarative_webrequest_helpers;
+
 namespace {
 static extensions::URLMatcherConditionSet::ID g_next_id = 0;
 
 // TODO(battre): improve error messaging to give more meaningful messages
 // to the extension developer.
 // Error messages:
 const char kExpectedDictionary[] = "A condition has to be a dictionary.";
 const char kConditionWithoutInstanceType[] = "A condition had no instanceType";
 const char kExpectedOtherConditionType[] = "Expected a condition of type "
     "experimental.webRequest.RequestMatcher";
-const char kUnknownConditionAttribute[] = "UnKnown condition attribute '%s'";
+const char kUnknownConditionAttribute[] = "Unknown condition attribute '%s'";
 const char kConditionExpectedString[] =
     "Condition '%s' expected a string value";
+const char kVectorOfStringsExpected[] =
+    "Attribute '%s' expected a vector of strings";
 
 // String literals from the JavaScript API:
 const char kHostContainsKey[] = "host_contains";
 const char kHostEqualsKey[] = "host_equals";
 const char kHostPrefixKey[] = "host_prefix";
 const char kHostSuffixKey[] = "host_suffix";
 const char kHostSuffixPathPrefixKey[] = "host_suffix_path_prefix";
 const char kPathContainsKey[] = "path_contains";
 const char kPathEqualsKey[] = "path_equals";
 const char kPathPrefixKey[] = "path_prefix";
@@ skipping 125 matching lines @@
     *error = kConditionWithoutInstanceType;
     return scoped_ptr<WebRequestCondition>(NULL);
   }
   if (instance_type != keys::kRequestMatcherType) {
     *error = kExpectedOtherConditionType;
     return scoped_ptr<WebRequestCondition>(NULL);
   }
 
   WebRequestConditionAttributes attributes;
   URLMatcherConditionSet::Conditions url_matcher_conditions;
+  scoped_ptr<URLMatcherSchemeFilter> url_matcher_schema_filter;
 
   for (base::DictionaryValue::Iterator iter(*condition_dict);
        iter.HasNext(); iter.Advance()) {
     const std::string& condition_attribute_name = iter.key();
     const Value& condition_attribute_value = iter.value();
     if (condition_attribute_name == keys::kInstanceTypeKey) {
       // Skip this.
     } else if (IsURLMatcherConditionAttribute(condition_attribute_name)) {
       URLMatcherCondition url_matcher_condition =
           CreateURLMatcherCondition(
               url_matcher_condition_factory,
               condition_attribute_name,
               &condition_attribute_value,
               error);
       if (!error->empty())
         return scoped_ptr<WebRequestCondition>(NULL);
       url_matcher_conditions.insert(url_matcher_condition);
+    } else if (condition_attribute_name == keys::kSchemesKey) {
+      url_matcher_schema_filter = CreateURLMatcherScheme(
+          &condition_attribute_value, error);
+      if (!error->empty())
+        return scoped_ptr<WebRequestCondition>(NULL);
     } else if (WebRequestConditionAttribute::IsKnownType(
         condition_attribute_name)) {
       scoped_ptr<WebRequestConditionAttribute> attribute =
           WebRequestConditionAttribute::Create(
               condition_attribute_name,
               &condition_attribute_value,
               error);
       if (!error->empty())
         return scoped_ptr<WebRequestCondition>(NULL);
       attributes.push_back(make_linked_ptr(attribute.release()));
     } else {
       *error = base::StringPrintf(kUnknownConditionAttribute,
                                   condition_attribute_name.c_str());
       return scoped_ptr<WebRequestCondition>(NULL);
     }
   }
 
   // As the URL is the preliminary matching criterion that triggers the tests
   // for the remaining condition attributes, we insert an empty URL match if
   // no other url match conditions were specified. Such an empty URL is always
   // matched.
   if (url_matcher_conditions.empty()) {
     url_matcher_conditions.insert(
         url_matcher_condition_factory->CreateHostPrefixCondition(""));
   }
 
   scoped_refptr<URLMatcherConditionSet> url_matcher_condition_set(
-      new URLMatcherConditionSet(++g_next_id, url_matcher_conditions));
+      new URLMatcherConditionSet(++g_next_id, url_matcher_conditions,
+          url_matcher_schema_filter.Pass()));
   return scoped_ptr<WebRequestCondition>(
       new WebRequestCondition(url_matcher_condition_set, attributes));
 }
 
 // static
 bool WebRequestCondition::IsURLMatcherConditionAttribute(
     const std::string& condition_attribute_name) {
   return g_url_matcher_condition_factory_methods.Get().Contains(
       condition_attribute_name);
 }
 
 // static
 URLMatcherCondition WebRequestCondition::CreateURLMatcherCondition(
     URLMatcherConditionFactory* url_matcher_condition_factory,
     const std::string& condition_attribute_name,
     const base::Value* value,
     std::string* error) {
   std::string str_value;
   if (!value->GetAsString(&str_value)) {
     *error = base::StringPrintf(kConditionExpectedString,
                                 condition_attribute_name.c_str());
     return URLMatcherCondition();
   }
   return g_url_matcher_condition_factory_methods.Get().Call(
       url_matcher_condition_factory, condition_attribute_name, str_value);
 }
 
+// static
+scoped_ptr<URLMatcherSchemeFilter> WebRequestCondition::CreateURLMatcherScheme(
+    const base::Value* value,
+    std::string* error) {
+  std::vector<std::string> schemas;
+  if (!helpers::GetAsStringVector(value, &schemas)) {
+    *error = base::StringPrintf(kVectorOfStringsExpected, keys::kSchemesKey);
+    return scoped_ptr<URLMatcherSchemeFilter>(NULL);
+  }
+  return scoped_ptr<URLMatcherSchemeFilter>(
+      new URLMatcherSchemeFilter(schemas));
+}
 
 //
 // WebRequestConditionSet
 //
 
 WebRequestConditionSet::WebRequestConditionSet(
     const std::vector<linked_ptr<WebRequestCondition> >& conditions)
     : conditions_(conditions) {
   for (Conditions::iterator i = conditions_.begin(); i != conditions_.end();
        ++i) {
@@ skipping 38 matching lines @@
                                     (*i)->value(), error);
     if (!error->empty())
       return scoped_ptr<WebRequestConditionSet>(NULL);
     result.push_back(make_linked_ptr(condition.release()));
   }
 
   return scoped_ptr<WebRequestConditionSet>(new WebRequestConditionSet(result));
 }
 
 }  // namespace extensions