Refactoring how conditions without URL attributes are handled.

chrome/browser/extensions/api/declarative_webrequest/webrequest_condition_unittest.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 <set>
 
 #include "base/message_loop.h"
 #include "base/values.h"
@@ skipping 91 matching lines @@
   ListValue* https_scheme_list = new ListValue();
   https_scheme_list->Append(Value::CreateStringValue("https"));
   DictionaryValue* https_url_filter = new DictionaryValue();
   https_url_filter->SetString(keys2::kHostSuffixKey, "example.com");
   https_url_filter->SetString(keys2::kHostPrefixKey, "www");
   https_url_filter->Set(keys2::kSchemesKey, https_scheme_list);
   DictionaryValue https_condition;
   https_condition.SetString(keys::kInstanceTypeKey, keys::kRequestMatcherType);
   https_condition.Set(keys::kUrlKey, https_url_filter);
 
+  DictionaryValue empty_condition;
+  empty_condition.SetString(keys::kInstanceTypeKey, keys::kRequestMatcherType);
+
   WebRequestConditionSet::AnyVector conditions;
 
   linked_ptr<json_schema_compiler::any::Any> condition1 = make_linked_ptr(
       new json_schema_compiler::any::Any);
   condition1->Init(http_condition);
   conditions.push_back(condition1);
 
   linked_ptr<json_schema_compiler::any::Any> condition2 = make_linked_ptr(
       new json_schema_compiler::any::Any);
   condition2->Init(https_condition);
   conditions.push_back(condition2);
 
+  linked_ptr<json_schema_compiler::any::Any> condition3 = make_linked_ptr(
+      new json_schema_compiler::any::Any);
+  condition3->Init(empty_condition);
+  conditions.push_back(condition3);
+
   // Test insertion
   std::string error;
   scoped_ptr<WebRequestConditionSet> result =
       WebRequestConditionSet::Create(matcher.condition_factory(),
                                      conditions, &error);
   EXPECT_EQ("", error);
   ASSERT_TRUE(result.get());
-  EXPECT_EQ(2u, result->conditions().size());
+  EXPECT_EQ(3u, result->conditions().size());
 
   // Tell the URLMatcher about our shiny new patterns.
   URLMatcherConditionSet::Vector url_matcher_condition_set;
   result->GetURLMatcherConditionSets(&url_matcher_condition_set);
   matcher.AddConditionSets(url_matcher_condition_set);
 
   std::set<URLMatcherConditionSet::ID> url_match_ids;
   int number_matches = 0;
 
   // Test that the result is correct and matches http://www.example.com and
@@ skipping 28 matching lines @@
   net::TestURLRequest https_foo_request(https_foo_url, NULL, &context);
   number_matches = 0;
   for (std::set<URLMatcherConditionSet::ID>::iterator i = url_match_ids.begin();
        i != url_match_ids.end(); ++i) {
     if (result->IsFulfilled(
             *i, WebRequestRule::RequestData(
                 &https_foo_request, ON_BEFORE_REQUEST)))
       ++number_matches;
   }
   EXPECT_EQ(0, number_matches);
+
+  // Check that the empty condition reports success independently of the URL.

[Jeffrey Yasskin, 2012/12/18 02:24:32]

Please check a non-empty condition that doesn't have a URL too.

If IsFulfilledWithoutURLMatcher is supposed to return false for conditions
_with_ url matchers, please test that too.

Probably put these tests into a separate TEST() so that you don't have to modify
the existing test to add it and so that failures in this part of the
implementation are distinct from failures in the rest.

[vabr (Chromium), 2012/12/18 18:26:42]

Done, as WebRequestConditionTest.IsFulfilledIndependentlyOfURL.

+  // We need to use IsFulfilledWithoutURLMatcher instead of IsFulfilled to
+  // ignore the URL-dependent conditions.
+  number_matches = 0;
+  if (result->IsFulfilledWithoutURLMatcher(
+          WebRequestRule::RequestData(&http_request, ON_BEFORE_REQUEST)))
+    ++number_matches;
+  if (result->IsFulfilledWithoutURLMatcher(
+          WebRequestRule::RequestData(&https_request, ON_BEFORE_REQUEST)))
+    ++number_matches;
+  if (result->IsFulfilledWithoutURLMatcher(
+          WebRequestRule::RequestData(&https_foo_request, ON_BEFORE_REQUEST)))
+    ++number_matches;
+  EXPECT_EQ(3, number_matches);
 }
 
 TEST(WebRequestConditionTest, TestPortFilter) {
   // Necessary for TestURLRequest.
   MessageLoop message_loop(MessageLoop::TYPE_IO);
   URLMatcher matcher;
 
   // Allow 80;1000-1010.
   ListValue* port_range = new ListValue();
   port_range->Append(Value::CreateIntegerValue(1000));
@@ skipping 83 matching lines @@
 
   // Test error on incompatible application stages for involved attributes.
   error.clear();
   result = WebRequestCondition::Create(matcher.condition_factory(),
                                        condition_value, &error);
   EXPECT_FALSE(error.empty());
   EXPECT_FALSE(result.get());
 }
 
 }  // namespace extensions