Declarative Web Request: firstPartyForCookiesUrl

chrome/browser/extensions/api/declarative/declarative_rule_unittest.cc

 // Copyright (c) 2013 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/declarative_rule.h"
 
 #include "base/message_loop.h"
 #include "base/test/values_test_util.h"
 #include "base/values.h"
 #include "chrome/common/extensions/matcher/url_matcher_constants.h"
@@ skipping 17 matching lines @@
   typedef int MatchData;
 
   URLMatcherConditionFactory* factory;
   scoped_ptr<base::Value> value;
 
   void GetURLMatcherConditionSets(
       URLMatcherConditionSet::Vector* condition_sets) const {
     // No condition sets.
   }
 
-  bool has_url_matcher_condition_set() const {
-    return false;
-  }
-
   static scoped_ptr<RecordingCondition> Create(
       URLMatcherConditionFactory* url_matcher_condition_factory,
       const base::Value& condition,
       std::string* error) {
     const base::DictionaryValue* dict = NULL;
     if (condition.GetAsDictionary(&dict) && dict->HasKey("bad_key")) {
       *error = "Found error key";
       return scoped_ptr<RecordingCondition>();
     }
 
@@ skipping 43 matching lines @@
   typedef int MatchData;
 
   scoped_refptr<URLMatcherConditionSet> condition_set;
   int condition_set_id;
   int max_value;
 
   URLMatcherConditionSet::ID url_matcher_condition_set_id() const {
     return condition_set_id;
   }
 
-  bool has_url_matcher_condition_set() const {
-    return true;
-  }
-
   scoped_refptr<URLMatcherConditionSet> url_matcher_condition_set() const {
     return condition_set;
   }
 
   void GetURLMatcherConditionSets(
       URLMatcherConditionSet::Vector* condition_sets) const {
     if (condition_set)
       condition_sets->push_back(condition_set);
   }
 
   bool IsFulfilled(const std::set<URLMatcherConditionSet::ID>& url_matches,
                    int match_data) const {
     if (condition_set_id != -1 && !ContainsKey(url_matches, condition_set_id))
       return false;
     return match_data <= max_value;
   }
 
   static scoped_ptr<FulfillableCondition> Create(
-      URLMatcherConditionFactory* url_matcher_condition_factory,
+      URLMatcherConditionFactory* /*url_matcher_condition_factory*/,
       const base::Value& condition,
       std::string* error) {
     scoped_ptr<FulfillableCondition> result(new FulfillableCondition());
     const base::DictionaryValue* dict;
     if (!condition.GetAsDictionary(&dict)) {
       *error = "Expected dict";
       return result.Pass();
     }
     if (!dict->GetInteger("url_id", &result->condition_set_id))
       result->condition_set_id = -1;
@@ skipping 247 matching lines @@
                  "  \"priority\": 200 \n"
                  "}"),
       json_rule.get()));
   rule = Rule::Create(matcher.condition_factory(), kExtensionId, base::Time(),
                       json_rule, &AtLeastOneCondition, &error);
   EXPECT_FALSE(rule);
   EXPECT_EQ("No conditions", error);
 }
 
 }  // namespace extensions