Adding condition attributes for request headers to Declarative WebRequest

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/string_util.h"
@@ skipping 36 matching lines @@
 WebRequestConditionAttribute::WebRequestConditionAttribute() {}
 
 WebRequestConditionAttribute::~WebRequestConditionAttribute() {}
 
 // static
 bool WebRequestConditionAttribute::IsKnownType(
     const std::string& instance_type) {
   return
       WebRequestConditionAttributeResourceType::IsMatchingType(instance_type) ||
       WebRequestConditionAttributeContentType::IsMatchingType(instance_type) ||
+      WebRequestConditionAttributeRequestHeaders::IsMatchingType(
+          instance_type) ||
       WebRequestConditionAttributeResponseHeaders::IsMatchingType(
           instance_type) ||
       WebRequestConditionAttributeThirdParty::IsMatchingType(instance_type);
 }
 
 // static
 scoped_ptr<WebRequestConditionAttribute>
 WebRequestConditionAttribute::Create(
     const std::string& name,
     const base::Value* value,
     std::string* error) {
   CHECK(value != NULL && error != NULL);
   if (WebRequestConditionAttributeResourceType::IsMatchingType(name)) {
     return WebRequestConditionAttributeResourceType::Create(name, value, error);
   } else if (WebRequestConditionAttributeContentType::IsMatchingType(name)) {
     return WebRequestConditionAttributeContentType::Create(name, value, error);
+  } else if (WebRequestConditionAttributeRequestHeaders::IsMatchingType(
+      name)) {
+    return WebRequestConditionAttributeRequestHeaders::Create(
+        name, value, error);
   } else if (WebRequestConditionAttributeResponseHeaders::IsMatchingType(
       name)) {
     return WebRequestConditionAttributeResponseHeaders::Create(
         name, value, error);
   } else if (WebRequestConditionAttributeThirdParty::IsMatchingType(name)) {
     return WebRequestConditionAttributeThirdParty::Create(name, value, error);
   }
 
   *error = ExtensionErrorUtils::FormatErrorMessage(kUnknownConditionAttribute,
                                                    name);
@@ skipping 400 matching lines @@
 
   for (size_t i = 0; i < value_match_.size(); ++i) {
     if (!value_match_[i]->Matches(value))
       return false;
   }
 
   return true;
 }
 
 //
+// WebRequestConditionAttributeRequestHeaders
+//
+
+WebRequestConditionAttributeRequestHeaders::
+WebRequestConditionAttributeRequestHeaders(
+    scoped_ptr<const HeaderMatcher> header_matcher,
+    bool positive)
+    : header_matcher_(header_matcher.Pass()),
+      positive_(positive) {}
+
+WebRequestConditionAttributeRequestHeaders::
+~WebRequestConditionAttributeRequestHeaders() {}
+
+// static
+bool WebRequestConditionAttributeRequestHeaders::IsMatchingType(
+    const std::string& instance_type) {
+  return instance_type == keys::kRequestHeadersKey ||
+      instance_type == keys::kExcludeRequestHeadersKey;
+}
+
+namespace {
+
+scoped_ptr<const HeaderMatcher> PrepareHeaderMatcher(
+    const std::string& name,
+    const base::Value* value,
+    std::string* error) {
+  const ListValue* value_as_list = NULL;
+  if (!value->GetAsList(&value_as_list)) {
+    *error = ExtensionErrorUtils::FormatErrorMessage(kInvalidValue, name);
+    return scoped_ptr<const HeaderMatcher>(NULL);
+  }
+
+  scoped_ptr<const HeaderMatcher> header_matcher(
+      HeaderMatcher::Create(value_as_list));
+  if (header_matcher.get() == NULL)
+    *error = ExtensionErrorUtils::FormatErrorMessage(kInvalidValue, name);
+  return header_matcher.Pass();
+}
+
+}  // namespace
+
+// static
+scoped_ptr<WebRequestConditionAttribute>
+WebRequestConditionAttributeRequestHeaders::Create(
+    const std::string& name,
+    const base::Value* value,
+    std::string* error) {
+  DCHECK(IsMatchingType(name));
+
+  scoped_ptr<const HeaderMatcher> header_matcher(
+      PrepareHeaderMatcher(name, value, error));
+  if (header_matcher.get() == NULL)
+    return scoped_ptr<WebRequestConditionAttribute>(NULL);
+
+  return scoped_ptr<WebRequestConditionAttribute>(
+      new WebRequestConditionAttributeRequestHeaders(
+          header_matcher.Pass(), name == keys::kRequestHeadersKey));
+}
+
+int WebRequestConditionAttributeRequestHeaders::GetStages() const {
+  // Currently we only allow matching against headers in the before-send-headers
+  // stage. The headers are accessible in other stages as well, but before
+  // allowing to match against them in further stages, we should consider
+  // caching the match result.
+  return ON_BEFORE_SEND_HEADERS;
+}
+
+bool WebRequestConditionAttributeRequestHeaders::IsFulfilled(
+    const WebRequestRule::RequestData& request_data) const {
+  if (!(request_data.stage & GetStages()))
+    return false;
+
+  const net::HttpRequestHeaders& headers =
+      request_data.request->extra_request_headers();
+
+  bool passed = false;  // Did some header pass TestNameValue?
+  net::HttpRequestHeaders::Iterator it(headers);
+  while (!passed && it.GetNext())
+    passed |= header_matcher_->TestNameValue(it.name(), it.value());
+
+  return (positive_ ? passed : !passed);
+}
+
+WebRequestConditionAttribute::Type
+WebRequestConditionAttributeRequestHeaders::GetType() const {
+  return CONDITION_REQUEST_HEADERS;
+}
+
+//
 // WebRequestConditionAttributeResponseHeaders
 //
 
 WebRequestConditionAttributeResponseHeaders::
 WebRequestConditionAttributeResponseHeaders(
-    scoped_ptr<const HeaderMatcher>* header_matcher,
+    scoped_ptr<const HeaderMatcher> header_matcher,
     bool positive)
-    : header_matcher_(header_matcher->Pass()),
+    : header_matcher_(header_matcher.Pass()),
       positive_(positive) {}
 
 WebRequestConditionAttributeResponseHeaders::
 ~WebRequestConditionAttributeResponseHeaders() {}
 
 // static
 bool WebRequestConditionAttributeResponseHeaders::IsMatchingType(
     const std::string& instance_type) {
   return instance_type == keys::kResponseHeadersKey ||
       instance_type == keys::kExcludeResponseHeadersKey;
 }
 
 // static
 scoped_ptr<WebRequestConditionAttribute>
 WebRequestConditionAttributeResponseHeaders::Create(
     const std::string& name,
     const base::Value* value,
     std::string* error) {
   DCHECK(IsMatchingType(name));
 
-  const ListValue* value_as_list = NULL;
-  if (!value->GetAsList(&value_as_list)) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(kInvalidValue, name);
+  scoped_ptr<const HeaderMatcher> header_matcher(
+      PrepareHeaderMatcher(name, value, error));
+  if (header_matcher.get() == NULL)
     return scoped_ptr<WebRequestConditionAttribute>(NULL);
-  }
 
-  scoped_ptr<const HeaderMatcher> header_matcher(
-      HeaderMatcher::Create(value_as_list));
-  if (header_matcher.get() == NULL) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(kInvalidValue, name);
-    return scoped_ptr<WebRequestConditionAttribute>(NULL);
-  }
-
-  const bool positive = name == keys::kResponseHeadersKey;
   return scoped_ptr<WebRequestConditionAttribute>(
       new WebRequestConditionAttributeResponseHeaders(
-          &header_matcher, positive));
+          header_matcher.Pass(), name == keys::kResponseHeadersKey));
 }
 
 int WebRequestConditionAttributeResponseHeaders::GetStages() const {
   return ON_HEADERS_RECEIVED;
 }
 
 bool WebRequestConditionAttributeResponseHeaders::IsFulfilled(
     const WebRequestRule::RequestData& request_data) const {
   if (!(request_data.stage & GetStages()))
     return false;
@@ skipping 79 matching lines @@
 
   return match_third_party_ ? !is_first_party : is_first_party;
 }
 
 WebRequestConditionAttribute::Type
 WebRequestConditionAttributeThirdParty::GetType() const {
   return CONDITION_THIRD_PARTY;
 }
 
 }  // namespace extensions