Implemented port filter for URLMatcher

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"
@@ skipping 15 matching lines @@
 // 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 kConditionExpectedString[] =
     "Condition '%s' expected a string value";
 const char kVectorOfStringsExpected[] =
     "Attribute '%s' expected a vector of strings";
+const char kInvalidPortRanges[] = "Invalid port ranges";
 
 // 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 126 matching lines @@
     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;
+  scoped_ptr<URLMatcherPortFilter> url_matcher_port_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 (condition_attribute_name == keys::kPortsKey) {
+      url_matcher_port_filter = CreateURLMatcherPorts(
+          &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,
-          url_matcher_schema_filter.Pass()));
+          url_matcher_schema_filter.Pass(), url_matcher_port_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);
 }
@@ skipping 20 matching lines @@
     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));
 }
 
+// static
+scoped_ptr<URLMatcherPortFilter> WebRequestCondition::CreateURLMatcherPorts(
+    const base::Value* value,
+    std::string* error) {
+  std::vector<URLMatcherPortFilter::Range> ranges;
+  const base::ListValue* value_list = NULL;
+  if (!value->GetAsList(&value_list)) {
+    *error = kInvalidPortRanges;
+    return scoped_ptr<URLMatcherPortFilter>(NULL);
+  }
+
+  for (ListValue::const_iterator i = value_list->begin();
+       i != value_list->end(); ++i) {
+    Value* entry = *i;
+    int port = 0;
+    base::ListValue* range = NULL;
+    if (entry->GetAsInteger(&port)) {
+      ranges.push_back(URLMatcherPortFilter::CreateRange(port));
+    } else if (entry->GetAsList(&range)) {
+      int from = 0, to = 0;
+      if (range->GetSize() != 2u ||
+          !range->GetInteger(0, &from) ||
+          !range->GetInteger(1, &to)) {
+        *error = kInvalidPortRanges;
+        return scoped_ptr<URLMatcherPortFilter>(NULL);
+      }
+      ranges.push_back(URLMatcherPortFilter::CreateRange(from, to));
+    } else {
+      *error = kInvalidPortRanges;
+      return scoped_ptr<URLMatcherPortFilter>(NULL);
+    }
+  }
+
+  return scoped_ptr<URLMatcherPortFilter>(new URLMatcherPortFilter(ranges));
+}
+
 //
 // WebRequestConditionSet
 //
 
 WebRequestConditionSet::WebRequestConditionSet(
     const std::vector<linked_ptr<WebRequestCondition> >& conditions)
     : conditions_(conditions) {
   for (Conditions::iterator i = conditions_.begin(); i != conditions_.end();
        ++i) {
     URLMatcherConditionSet::ID trigger_id =
@@ skipping 37 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