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 59 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);
 
   // 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();
   }
 
   // Returns the context where the rules registry lives.
   content::BrowserContext* browser_context() const { return browser_context_; }
 
   // Returns the ID of the thread on which the rules registry lives.
   // It is safe to call this function from any thread.
   content::BrowserThread::ID owner_thread() const { return owner_thread_; }
 
   // The name of the event with which rules are registered.
   const std::string& event_name() const { return event_name_; }
 
   // The unique identifier for this RulesRegistry object.
   int id() const { return id_; }
 
  protected:
   virtual ~RulesRegistry();
 
-  // 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);
-
   // 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(
@@ skipping 17 matching lines @@
     // to schedule one.
     NOT_SCHEDULED_FOR_PROCESSING
   };
   typedef std::map<ExtensionId, ProcessChangedRulesState> ProcessStateMap;
 
   base::WeakPtr<RulesRegistry> GetWeakPtr() {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     return weak_ptr_factory_.GetWeakPtr();
   }
 
+  // Internal implementation of the AddRules interface which adds
+  // |from_manifest| which is true when the source is the manifest.
+  std::string AddRulesInternal(
+      const std::string& extension_id,
+      const std::vector<linked_ptr<RulesRegistry::Rule>>& rules,
+      RulesDictionary* out);
+
+  // 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,
+      RulesDictionary* out);
+
+  // Same as GetRules but returns all rules owned by |extension_id| for a given
+  // |rules| dictionary.
+  void GetRules(const std::string& extension_id,
+                RulesDictionary& rules,
+                std::vector<linked_ptr<RulesRegistry::Rule>>* out);
+
   // Common processing after extension's rules have changed.
   void ProcessChangedRules(const std::string& extension_id);
 
   // Calls ProcessChangedRules if
   // |process_changed_rules_requested_(extension_id)| ==
   // NOT_SCHEDULED_FOR_PROCESSING.
   void MaybeProcessChangedRules(const std::string& extension_id);
 
   // This method implements the functionality of RemoveAllRules, except for not
   // calling MaybeProcessChangedRules. That way updating the rules store and
   // extension prefs is avoided. This method is called when an extension is
   // uninstalled, that way there is no clash with the preferences being wiped.
-  std::string RemoveAllRulesNoStoreUpdate(const std::string& extension_id);
+  // Set |remove_manifest_rules| to true if |manifest_rules_| should be cleared
+  // along with |rules_|.
+  std::string RemoveAllRulesNoStoreUpdate(const std::string& extension_id,
+                                          bool remove_manifest_rules);
 
   void MarkReady(base::Time storage_init_time);
 
   // Deserialize the rules from the given Value object and add them to the
   // RulesRegistry.
   void DeserializeAndAddRules(const std::string& extension_id,
                               scoped_ptr<base::Value> rules);
 
   // The context to which this rules registry belongs.
   content::BrowserContext* browser_context_;
 
   // The ID of the thread on which the rules registry lives.
   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__