Support also excluding content types in declarative webrequest conditions.

chrome/browser/extensions/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 "chrome/browser/extensions/api/declarative_webrequest/webrequest_condition_attribute.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/stringprintf.h"
@@ skipping 126 matching lines @@
 WebRequestConditionAttributeResourceType::GetType() const {
   return CONDITION_RESOURCE_TYPE;
 }
 
 //
 // WebRequestConditionAttributeContentType
 //
 
 WebRequestConditionAttributeContentType::
 WebRequestConditionAttributeContentType(
-    const std::vector<std::string>& content_types)
-    : content_types_(content_types) {}
+    const std::vector<std::string>& content_types,
+    bool inclusive)
+    : content_types_(content_types), inclusive_(inclusive) {}

[battre, 2012/08/07 08:45:09]

nit: I think the inclusive_ should go into the next line
(http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Constr...)

[Yoyo Zhou, 2012/08/07 19:32:35]

I think the style guide can be construed either way in this case, but I think
the 2 lines looks better here.

 
 WebRequestConditionAttributeContentType::
 ~WebRequestConditionAttributeContentType() {}
 
 // static
 bool WebRequestConditionAttributeContentType::IsMatchingType(
     const std::string& instance_type) {
-  return instance_type == keys::kContentTypeKey;
+  return instance_type == keys::kContentTypeKey ||
+      instance_type == keys::kExcludeContentTypeKey;
 }
 
 // static
 scoped_ptr<WebRequestConditionAttribute>
 WebRequestConditionAttributeContentType::Create(
       const std::string& name,
       const base::Value* value,
       std::string* error) {
-  std::vector<std::string> content_types;
+  DCHECK(IsMatchingType(name));
 
   const ListValue* value_as_list = NULL;
   if (!value->GetAsList(&value_as_list)) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(kInvalidValue,
-                                                     keys::kContentTypeKey);
+    *error = ExtensionErrorUtils::FormatErrorMessage(kInvalidValue, name);
     return scoped_ptr<WebRequestConditionAttribute>(NULL);
   }
-
+  std::vector<std::string> content_types;
   for (ListValue::const_iterator it = value_as_list->begin();
        it != value_as_list->end(); ++it) {
     std::string content_type;
     if (!(*it)->GetAsString(&content_type)) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(kInvalidValue,
-                                                       keys::kContentTypeKey);
+      *error = ExtensionErrorUtils::FormatErrorMessage(kInvalidValue, name);
       return scoped_ptr<WebRequestConditionAttribute>(NULL);
     }
     content_types.push_back(content_type);
   }
+
   return scoped_ptr<WebRequestConditionAttribute>(
-      new WebRequestConditionAttributeContentType(content_types));
+      new WebRequestConditionAttributeContentType(
+          content_types, name == keys::kContentTypeKey));
 }
 
 int WebRequestConditionAttributeContentType::GetStages() const {
   return ON_HEADERS_RECEIVED;
 }
 
 bool WebRequestConditionAttributeContentType::IsFulfilled(
     const WebRequestRule::RequestData& request_data) {
   if (!(request_data.stage & GetStages()))
     return false;
   std::string content_type;
   request_data.original_response_headers->GetNormalizedHeader(
       net::HttpRequestHeaders::kContentType, &content_type);
   std::string mime_type;
   std::string charset;
   bool had_charset = false;
   net::HttpUtil::ParseContentType(
       content_type, &mime_type, &charset, &had_charset, NULL);
 
-  return std::find(content_types_.begin(), content_types_.end(),
-                   mime_type) != content_types_.end();
+  if (inclusive_) {
+    return std::find(content_types_.begin(), content_types_.end(),
+                     mime_type) != content_types_.end();
+  } else {
+    return std::find(content_types_.begin(), content_types_.end(),
+                     mime_type) == content_types_.end();
+  }
 }
 
 WebRequestConditionAttribute::Type
 WebRequestConditionAttributeContentType::GetType() const {
   return CONDITION_CONTENT_TYPE;
 }
 
 }  // namespace extensions