Declarative Web Request: firstPartyForCookiesUrl

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/logging.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
@@ skipping 27 matching lines @@
 namespace extensions {
 
 namespace keys = declarative_webrequest_constants;
 
 //
 // WebRequestCondition
 //
 
 WebRequestCondition::WebRequestCondition(
     scoped_refptr<URLMatcherConditionSet> url_matcher_conditions,
+    scoped_refptr<URLMatcherConditionSet> first_party_url_matcher_conditions,
     const WebRequestConditionAttributes& condition_attributes)
     : url_matcher_conditions_(url_matcher_conditions),
+      first_party_url_matcher_conditions_(first_party_url_matcher_conditions),
       condition_attributes_(condition_attributes),
       applicable_request_stages_(~0) {
   for (WebRequestConditionAttributes::const_iterator i =
        condition_attributes_.begin(); i != condition_attributes_.end(); ++i) {
     applicable_request_stages_ &= (*i)->GetStages();
   }
 }
 
 WebRequestCondition::~WebRequestCondition() {}
 
 bool WebRequestCondition::IsFulfilled(
     const std::set<URLMatcherConditionSet::ID>& url_matches,
     const DeclarativeWebRequestData& request_data) const {
   if (!(request_data.stage & applicable_request_stages_)) {
     // A condition that cannot be evaluated is considered as violated.
     return false;
   }
 
-  // Check a UrlFilter attribute if present.
-  if (url_matcher_conditions_.get() &&
-      !ContainsKey(url_matches, url_matcher_conditions_->id()))
+  // Check URL attributes if present.
+  if ((url_matcher_conditions_.get() &&
+       !ContainsKey(url_matches, url_matcher_conditions_->id())) ||
+      (first_party_url_matcher_conditions_.get() &&
+       !ContainsKey(url_matches, first_party_url_matcher_conditions_->id())))
     return false;
 
   // All condition attributes must be fulfilled for a fulfilled condition.
   for (WebRequestConditionAttributes::const_iterator i =
-       condition_attributes_.begin(); i != condition_attributes_.end(); ++i) {
+           condition_attributes_.begin();
+       i != condition_attributes_.end(); ++i) {
     if (!(*i)->IsFulfilled(request_data))
       return false;
   }
   return true;
 }
 
+int WebRequestCondition::GetURLMatcherConditionSets(
+    URLMatcherConditionSet::Vector* condition_sets,
+    int index) const {
+  switch (index) {
+    case 0:
+      if (url_matcher_conditions_)
+        condition_sets->push_back(url_matcher_conditions_);
+      return 1;
+    case 1:
+      if (first_party_url_matcher_conditions_)
+        condition_sets->push_back(first_party_url_matcher_conditions_);
+      return -1;
+    default:

[battre, 2013/01/21 17:32:08]

nit: I would add a NOTREACHED(); here.

[vabr (Chromium), 2013/01/21 18:39:29]

Done.

+      return -1;
+  }
+}
+
 // static
 scoped_ptr<WebRequestCondition> WebRequestCondition::Create(
-    URLMatcherConditionFactory* url_matcher_condition_factory,
+    const std::vector<URLMatcherConditionFactory*>&
+        url_matcher_condition_factories,
     const base::Value& condition,
     std::string* error) {
+  CHECK_EQ(2u, url_matcher_condition_factories.size());
   const base::DictionaryValue* condition_dict = NULL;
   if (!condition.GetAsDictionary(&condition_dict)) {
     *error = kExpectedDictionary;
     return scoped_ptr<WebRequestCondition>(NULL);
   }
 
   // Verify that we are dealing with a Condition whose type we understand.
   std::string instance_type;
   if (!condition_dict->GetString(keys::kInstanceTypeKey, &instance_type)) {
     *error = kConditionWithoutInstanceType;
     return scoped_ptr<WebRequestCondition>(NULL);
   }
   if (instance_type != keys::kRequestMatcherType) {
     *error = kExpectedOtherConditionType;
     return scoped_ptr<WebRequestCondition>(NULL);
   }
 
   WebRequestConditionAttributes attributes;
   scoped_refptr<URLMatcherConditionSet> url_matcher_condition_set;
+  scoped_refptr<URLMatcherConditionSet> first_party_url_matcher_condition_set;
 
   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();
+    const bool name_is_url = condition_attribute_name == keys::kUrlKey;
     if (condition_attribute_name == keys::kInstanceTypeKey) {
       // Skip this.
-    } else if (condition_attribute_name == keys::kUrlKey) {
+    } else if (name_is_url ||
+               condition_attribute_name == keys::kFirstPartyForCookiesUrlKey) {
       const base::DictionaryValue* dict = NULL;
       if (!condition_attribute_value.GetAsDictionary(&dict)) {
         *error = base::StringPrintf(kInvalidTypeOfParamter,
                                     condition_attribute_name.c_str());
       } else {
-        url_matcher_condition_set =
-            URLMatcherFactory::CreateFromURLFilterDictionary(
-                url_matcher_condition_factory, dict, ++g_next_id, error);
+        if (!name_is_url) {
+          first_party_url_matcher_condition_set =
+              URLMatcherFactory::CreateFromURLFilterDictionary(
+                  url_matcher_condition_factories[1], dict, ++g_next_id, error);
+        } else {
+          url_matcher_condition_set =
+              URLMatcherFactory::CreateFromURLFilterDictionary(
+                  url_matcher_condition_factories[0], dict, ++g_next_id, error);
+        }
       }
     } else if (WebRequestConditionAttribute::IsKnownType(
         condition_attribute_name)) {
       scoped_ptr<WebRequestConditionAttribute> attribute =
           WebRequestConditionAttribute::Create(
               condition_attribute_name,
               &condition_attribute_value,
               error);
       if (attribute.get())
         attributes.push_back(make_linked_ptr(attribute.release()));
     } else {
       *error = base::StringPrintf(kUnknownConditionAttribute,
                                   condition_attribute_name.c_str());
     }
     if (!error->empty())
       return scoped_ptr<WebRequestCondition>(NULL);
   }
 
   scoped_ptr<WebRequestCondition> result(
-      new WebRequestCondition(url_matcher_condition_set, attributes));
+      new WebRequestCondition(url_matcher_condition_set,
+                              first_party_url_matcher_condition_set,
+                              attributes));
 
   if (!result->stages()) {
     *error = kConditionCannotBeFulfilled;
     return scoped_ptr<WebRequestCondition>(NULL);
   }
 
   return result.Pass();
 }
 
 }  // namespace extensions