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 13 matching lines @@
 namespace content {
 class BrowserContext;
 }
 
 namespace base {
 class Value;
 }  // namespace base
 
 namespace extensions {
 
+class Extension;
 class RulesCacheDelegate;
 
 // A base class for RulesRegistries that takes care of storing the
 // RulesRegistry::Rule objects. It contains all the methods that need to run on
 // the registry thread; methods that need to run on the UI thread are separated
 // in the RulesCacheDelegate object.
 class RulesRegistry : public base::RefCountedThreadSafe<RulesRegistry> {
  public:
   typedef extensions::core_api::events::Rule Rule;
 
@@ skipping 25 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);

[not at google - send to devlin, 2015/06/05 16:16:14]

This from_manifest flag shouldn't be part of the public interface. The manifest
rule loading is done in the OnExtensionLoaded event, which is purely internal to
this class. It would be wrong for anybody, other than this class, to pass
anything other than false in here.

[danduong, 2015/06/05 21:35:07]

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 13 matching lines @@
   void GetRules(const std::string& extension_id,
                 const std::vector<std::string>& rule_identifiers,
                 std::vector<linked_ptr<RulesRegistry::Rule> >* out);
 
   // Same as GetRules but returns all rules owned by |extension_id|.
   void GetAllRules(const std::string& extension_id,
                    std::vector<linked_ptr<RulesRegistry::Rule> >* out);
 
   // Called to notify the RulesRegistry that the extension availability has
   // changed, so that the registry can update which rules are active.
-  void OnExtensionUnloaded(const std::string& extension_id);
-  void OnExtensionUninstalled(const std::string& extension_id);
-  void OnExtensionLoaded(const std::string& extension_id);
+  void OnExtensionUnloaded(const Extension* extension);
+  void OnExtensionUninstalled(const Extension* extension);
+  void OnExtensionLoaded(const Extension* extension);

[not at google - send to devlin, 2015/06/05 16:16:14]

Thanks for doing this.

[danduong, 2015/06/05 21:35:07]

Acknowledged.

 
   // Returns the number of entries in used_rule_identifiers_ for leak detection.
   // Every ExtensionId counts as one entry, even if it contains no rules.
   size_t GetNumberOfUsedRuleIdentifiersForTesting() const;
 
   // Returns the RulesCacheDelegate. This is used for testing.
   RulesCacheDelegate* rules_cache_delegate_for_testing() const {
     return cache_delegate_.get();
   }
 
@@ skipping 15 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;
@@ skipping 53 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_;
 
+  RulesDictionary manifest_rules_;
+
   // 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__