Adding thirdParty property to RequestMatcher

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_constants.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api_helpers.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "content/public/browser/resource_request_info.h"
+#include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/http/http_util.h"
 #include "net/http/http_request_headers.h"
 #include "net/url_request/url_request.h"
 
 using base::CaseInsensitiveCompareASCII;
 using base::DictionaryValue;
 using base::ListValue;
 using base::StringValue;
 using base::Value;
 
@@ skipping 17 matching lines @@
 
 WebRequestConditionAttribute::~WebRequestConditionAttribute() {}
 
 // static
 bool WebRequestConditionAttribute::IsKnownType(
     const std::string& instance_type) {
   return
       WebRequestConditionAttributeResourceType::IsMatchingType(instance_type) ||
       WebRequestConditionAttributeContentType::IsMatchingType(instance_type) ||
       WebRequestConditionAttributeResponseHeaders::IsMatchingType(
-          instance_type);
+          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 (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);
   return scoped_ptr<WebRequestConditionAttribute>(NULL);
 }
 
 //
 // WebRequestConditionAttributeResourceType
 //
@@ skipping 474 matching lines @@
   }
 
   return (positive_ ? passed : !passed);
 }
 
 WebRequestConditionAttribute::Type
 WebRequestConditionAttributeResponseHeaders::GetType() const {
   return CONDITION_RESPONSE_HEADERS;
 }
 
+//
+// WebRequestConditionAttributeThirdParty
+//
+
+WebRequestConditionAttributeThirdParty::
+WebRequestConditionAttributeThirdParty(bool match_third_party)
+    : match_third_party_(match_third_party) {}
+
+WebRequestConditionAttributeThirdParty::
+~WebRequestConditionAttributeThirdParty() {}
+
+// static
+bool WebRequestConditionAttributeThirdParty::IsMatchingType(
+    const std::string& instance_type) {
+  return instance_type == keys::kThirdPartyKey;
+}
+
+// static
+scoped_ptr<WebRequestConditionAttribute>
+WebRequestConditionAttributeThirdParty::Create(
+    const std::string& name,
+    const base::Value* value,
+    std::string* error) {
+  DCHECK(IsMatchingType(name));
+
+  bool third_party = false;  // Dummy value, gets overwritten.
+  if (!value->GetAsBoolean(&third_party)) {
+    *error = ExtensionErrorUtils::FormatErrorMessage(kInvalidValue,
+                                                     keys::kThirdPartyKey);
+    return scoped_ptr<WebRequestConditionAttribute>(NULL);
+  }
+
+  return scoped_ptr<WebRequestConditionAttribute>(
+      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 {
+  if (!(request_data.stage & GetStages()))
+    return false;
+
+  const bool is_first_party =
+      net::RegistryControlledDomainService::SameDomainOrHost(
+          request_data.request->url(),
+          request_data.request->first_party_for_cookies());
+  return match_third_party_ ? !is_first_party : is_first_party;
+}
+
+WebRequestConditionAttribute::Type
+WebRequestConditionAttributeThirdParty::GetType() const {
+  return CONDITION_THIRD_PARTY;
+}
+
 }  // namespace extensions