Implement declarativeContent API.

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"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/declarative_webrequest/request_stage.h"
+#include "chrome/browser/extensions/api/declarative_webrequest/webrequest_condition.h"
 #include "chrome/browser/extensions/api/declarative_webrequest/webrequest_constants.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api_helpers.h"
 #include "content/public/browser/resource_request_info.h"
 #include "extensions/common/error_utils.h"
 #include "net/base/net_errors.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/base/static_cookie_policy.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
@@ skipping 120 matching lines @@
       new WebRequestConditionAttributeResourceType(passed_types));
 }
 
 int WebRequestConditionAttributeResourceType::GetStages() const {
   return ON_BEFORE_REQUEST | ON_BEFORE_SEND_HEADERS | ON_SEND_HEADERS |
       ON_HEADERS_RECEIVED | ON_AUTH_REQUIRED | ON_BEFORE_REDIRECT |
       ON_RESPONSE_STARTED | ON_COMPLETED | ON_ERROR;
 }
 
 bool WebRequestConditionAttributeResourceType::IsFulfilled(
-    const WebRequestRule::RequestData& request_data) const {
+    const DeclarativeWebRequestData& request_data) const {
   if (!(request_data.stage & GetStages()))
     return false;
   const content::ResourceRequestInfo* info =
       content::ResourceRequestInfo::ForRequest(request_data.request);
   if (!info)
     return false;
   return std::find(types_.begin(), types_.end(), info->GetResourceType()) !=
       types_.end();
 }
 
@@ skipping 50 matching lines @@
   return scoped_ptr<WebRequestConditionAttribute>(
       new WebRequestConditionAttributeContentType(
           content_types, name == keys::kContentTypeKey));
 }
 
 int WebRequestConditionAttributeContentType::GetStages() const {
   return ON_HEADERS_RECEIVED;
 }
 
 bool WebRequestConditionAttributeContentType::IsFulfilled(
-    const WebRequestRule::RequestData& request_data) const {
+    const DeclarativeWebRequestData& request_data) const {
   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);
@@ skipping 324 matching lines @@
 
 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 {
+    const DeclarativeWebRequestData& 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());
@@ skipping 43 matching lines @@
   return scoped_ptr<WebRequestConditionAttribute>(
       new WebRequestConditionAttributeResponseHeaders(
           header_matcher.Pass(), name == keys::kResponseHeadersKey));
 }
 
 int WebRequestConditionAttributeResponseHeaders::GetStages() const {
   return ON_HEADERS_RECEIVED;
 }
 
 bool WebRequestConditionAttributeResponseHeaders::IsFulfilled(
-    const WebRequestRule::RequestData& request_data) const {
+    const DeclarativeWebRequestData& request_data) const {
   if (!(request_data.stage & GetStages()))
     return false;
 
   const net::HttpResponseHeaders* headers =
       request_data.original_response_headers;
   if (headers == NULL) {
     // Each header of an empty set satisfies (the negation of) everything;
     // OTOH, there is no header to satisfy even the most permissive test.
     return !positive_;
   }
@@ skipping 50 matching lines @@
       new WebRequestConditionAttributeThirdParty(third_party));
 }
 
 int WebRequestConditionAttributeThirdParty::GetStages() const {
   return ON_BEFORE_REQUEST | ON_BEFORE_SEND_HEADERS | ON_SEND_HEADERS |
       ON_HEADERS_RECEIVED | ON_AUTH_REQUIRED | ON_BEFORE_REDIRECT |
       ON_RESPONSE_STARTED | ON_COMPLETED | ON_ERROR;
 }
 
 bool WebRequestConditionAttributeThirdParty::IsFulfilled(
-    const WebRequestRule::RequestData& request_data) const {
+    const DeclarativeWebRequestData& request_data) const {
   if (!(request_data.stage & GetStages()))
     return false;
 
   // Request is "1st party" if it gets cookies under 3rd party-blocking policy.
   const net::StaticCookiePolicy block_third_party_policy(
       net::StaticCookiePolicy::BLOCK_ALL_THIRD_PARTY_COOKIES);
   const int can_get_cookies = block_third_party_policy.CanGetCookies(
           request_data.request->url(),
           request_data.request->first_party_for_cookies());
   const bool is_first_party = (can_get_cookies == net::OK);
@@ skipping 74 matching lines @@
 
   return scoped_ptr<WebRequestConditionAttribute>(
       new WebRequestConditionAttributeStages(allowed_stages));
 }
 
 int WebRequestConditionAttributeStages::GetStages() const {
   return allowed_stages_;
 }
 
 bool WebRequestConditionAttributeStages::IsFulfilled(
-    const WebRequestRule::RequestData& request_data) const {
+    const DeclarativeWebRequestData& request_data) const {
   // Note: removing '!=' triggers warning C4800 on the VS compiler.
   return (request_data.stage & GetStages()) != 0;
 }
 
 WebRequestConditionAttribute::Type
 WebRequestConditionAttributeStages::GetType() const {
   return CONDITION_STAGES;
 }
 
 }  // namespace extensions