Create a mechanism define declarative rules via the extension manifest.

extensions/browser/api/declarative/rules_registry.h

 // 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.
 
 #ifndef EXTENSIONS_BROWSER_API_DECLARATIVE_RULES_REGISTRY_H__
 #define EXTENSIONS_BROWSER_API_DECLARATIVE_RULES_REGISTRY_H__
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 58 matching lines @@
   // registered before, unless it has been removed again.
   // The ownership of rules remains with the caller.
   //
   // Returns an empty string if the function is successful or an error
   // message otherwise.
   //
   // IMPORTANT: This function is atomic. Either all rules that are deemed
   // relevant are added or none.
   std::string AddRules(
       const std::string& extension_id,
-      const std::vector<linked_ptr<RulesRegistry::Rule> >& rules);
+      const std::vector<linked_ptr<RulesRegistry::Rule>>& rules,
+      bool from_manifest = false);

[not at google - send to devlin, 2015/06/04 22:00:51]

default parameters are against style guide

[danduong, 2015/06/04 23:06:37]

Done.

 
   // Unregisters all rules listed in |rule_identifiers| and owned by
   // |extension_id| from this RulesRegistry.
   // Some or all IDs in |rule_identifiers| may not be stored in this
   // RulesRegistry and are ignored.
   //
   // Returns an empty string if the function is successful or an error
   // message otherwise.
   //
   // IMPORTANT: This function is atomic. Either all rules that are deemed
@@ skipping 51 matching lines @@
 
   // The precondition for calling this method is that all rules have unique IDs.
   // AddRules establishes this precondition and calls into this method.
   // Stored rules already meet this precondition and so they avoid calling
   // CheckAndFillInOptionalRules for improved performance.
   //
   // Returns an empty string if the function is successful or an error
   // message otherwise.
   std::string AddRulesNoFill(
       const std::string& extension_id,
-      const std::vector<linked_ptr<RulesRegistry::Rule> >& rules);
+      const std::vector<linked_ptr<RulesRegistry::Rule>>& rules,
+      bool from_manifest);
 
   // These functions need to apply the rules to the browser, while the base
   // class will handle defaulting empty fields before calling *Impl, and will
   // automatically cache the rules and re-call *Impl on browser startup.
   virtual std::string AddRulesImpl(
       const std::string& extension_id,
       const std::vector<linked_ptr<RulesRegistry::Rule> >& rules) = 0;
   virtual std::string RemoveRulesImpl(
       const std::string& extension_id,
       const std::vector<std::string>& rule_identifiers) = 0;
   virtual std::string RemoveAllRulesImpl(
       const std::string& extension_id) = 0;
 
  private:
   friend class base::RefCountedThreadSafe<RulesRegistry>;
   friend class RulesCacheDelegate;
 
   typedef std::string ExtensionId;
   typedef std::string RuleId;
   typedef std::pair<ExtensionId, RuleId> RulesDictionaryKey;
   typedef std::map<RulesDictionaryKey, linked_ptr<RulesRegistry::Rule> >
       RulesDictionary;
+  typedef std::set<RulesDictionaryKey> RuleIdSet;
   enum ProcessChangedRulesState {
     // ProcessChangedRules can never be called, |cache_delegate_| is NULL.
     NEVER_PROCESS,
     // A task to call ProcessChangedRules is scheduled for future execution.
     SCHEDULED_FOR_PROCESSING,
     // No task to call ProcessChangedRules is scheduled yet, but it is possible
     // to schedule one.
     NOT_SCHEDULED_FOR_PROCESSING
   };
   typedef std::map<ExtensionId, ProcessChangedRulesState> ProcessStateMap;
@@ skipping 31 matching lines @@
   const content::BrowserThread::ID owner_thread_;
 
   // The name of the event with which rules are registered.
   const std::string event_name_;
 
   // The key that identifies the context in which these rules apply.
   int id_;
 
   RulesDictionary rules_;
 
+  RuleIdSet manifest_rule_ids_;
+
   // Signaled when we have finished reading from storage for all extensions that
   // are loaded on startup.
   OneShotEvent ready_;
 
   ProcessStateMap process_changed_rules_requested_;
 
   // Returns whether any existing rule is registered with identifier |rule_id|
   // for extension |extension_id|.
   bool IsUniqueId(const std::string& extension_id,
                   const std::string& rule_id) const;
@@ skipping 35 matching lines @@
   base::WeakPtr<RulesCacheDelegate> cache_delegate_;
 
   base::WeakPtrFactory<RulesRegistry> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RulesRegistry);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_API_DECLARATIVE_RULES_REGISTRY_H__