Almost all actions in Declarative Web Request require all_urls host permissions

chrome/browser/extensions/api/declarative/declarative_rule.h

 // 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.
 //
 // DeclarativeRule<>, DeclarativeConditionSet<>, and DeclarativeActionSet<>
 // templates usable with multiple different declarativeFoo systems.  These are
 // templated on the Condition and Action types that define the behavior of a
 // particular declarative event.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_DECLARATIVE_RULE_H__
 #define CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_DECLARATIVE_RULE_H__
 
 #include <limits>
 #include <set>
 #include <string>
 #include <vector>
 
+#include "base/callback.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/stl_util.h"
 #include "base/time.h"
 #include "chrome/common/extensions/api/events.h"
 #include "extensions/common/matcher/url_matcher.h"
 
 namespace base {
 class Time;
 class Value;
@@ skipping 155 matching lines @@
   typedef std::string RuleId;
   typedef std::pair<ExtensionId, RuleId> GlobalRuleId;
   typedef int Priority;
   typedef DeclarativeConditionSet<ConditionT> ConditionSet;
   typedef DeclarativeActionSet<ActionT> ActionSet;
   typedef extensions::api::events::Rule JsonRule;
   typedef std::vector<std::string> Tags;
 
   // Checks whether the set of |conditions| and |actions| are consistent.
   // Returns true in case of consistency and MUST set |error| otherwise.
-  typedef bool (*ConsistencyChecker)(const ConditionSet* conditions,
-                                     const ActionSet* actions,
-                                     std::string* error);
+  typedef base::Callback<bool(const ConditionSet* conditions,

[vabr (Chromium), 2013/04/25 19:08:03]

I switched to callback here from a bare function pointer so that new checker can
be made from methods or functions with additional arguments (the host permission
checker is one instance).

The alternatives I considered were:
1. Change the function pointer to have most generic list of arguments (adding
Extension* in this case).
That seemed wasteful and confusing.
2. Switching to Callback, and make it a Closure instead, binding the conditions,
actions and error in.
I don't like binding the error in particular, since it is not clear the target
string will be alive when the callback gets called. For leaving the conditions
and actions there I don't have a strong preference.

+                              const ActionSet* actions,
+                              std::string* error)> ConsistencyChecker;
 
   DeclarativeRule(const GlobalRuleId& id,
                   const Tags& tags,
                   base::Time extension_installation_time,
                   scoped_ptr<ConditionSet> conditions,
                   scoped_ptr<ActionSet> actions,
                   Priority priority);
 
   // Creates a DeclarativeRule for an extension given a json definition.  The
   // format of each condition and action's json is up to the specific ConditionT
@@ skipping 235 matching lines @@
     // TODO(battre) Export concept of bad_message to caller, the extension
     // should be killed in case it is true.
     *error = "An action of a rule set had an invalid "
         "structure that should have been caught by the JSON validator.";
     return error_result.Pass();
   }
   if (!error->empty() || bad_message)
     return error_result.Pass();
   CHECK(actions.get());
 
-  if (check_consistency &&
-      !check_consistency(conditions.get(), actions.get(), error)) {
+  if (!check_consistency.is_null() &&
+      !check_consistency.Run(conditions.get(), actions.get(), error)) {
     DCHECK(!error->empty());
     return error_result.Pass();
   }
 
   CHECK(rule->priority.get());
   int priority = *(rule->priority);
 
   GlobalRuleId rule_id(extension_id, *(rule->id));
   Tags tags = rule->tags ? *rule->tags : Tags();
   return scoped_ptr<DeclarativeRule>(
@@ skipping 10 matching lines @@
 }
 
 template<typename ConditionT, typename ActionT>
 int DeclarativeRule<ConditionT, ActionT>::GetMinimumPriority() const {
   return actions_->GetMinimumPriority();
 }
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_DECLARATIVE_RULE_H__