Generate all extension schema namespaces as "api" and instead vary the generated bundle names.

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 17 matching lines @@
 namespace base {
 class Value;
 }  // namespace base
 
 namespace extensions {
 
 class Extension;
 class RulesCacheDelegate;
 
 // A base class for RulesRegistries that takes care of storing the
-// core_api::events::Rule objects. It contains all the methods that need to run
+// api::events::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:
   enum Defaults { DEFAULT_PRIORITY = 100 };
   // After the RulesCacheDelegate object (the part of the registry which runs on
   // the UI thread) is created, a pointer to it is passed to |*ui_part|.
   // In tests, |browser_context| and |ui_part| can be NULL (at the same time).
   // In that case the storage functionality disabled (no RulesCacheDelegate
   // object created).
@@ skipping 17 matching lines @@
   // declarative extension APIs. It is guaranteed that each rule in |rules| has
   // a unique name within the scope of |extension_id| that has not been
   // 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<core_api::events::Rule>>& rules);
+  std::string AddRules(const std::string& extension_id,
+                       const std::vector<linked_ptr<api::events::Rule>>& rules);
 
   // 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
   // relevant are removed or none.
   std::string RemoveRules(
       const std::string& extension_id,
       const std::vector<std::string>& rule_identifiers);
 
   // Same as RemoveAllRules but acts on all rules owned by |extension_id|.
   std::string RemoveAllRules(const std::string& extension_id);
 
   // Returns all rules listed in |rule_identifiers| and owned by |extension_id|
   // registered in this RuleRegistry. Entries in |rule_identifiers| that
   // are unknown are ignored.
   //
   // The returned rules are stored in |out|. Ownership is passed to the caller.
   void GetRules(const std::string& extension_id,
                 const std::vector<std::string>& rule_identifiers,
-                std::vector<linked_ptr<core_api::events::Rule>>* out);
+                std::vector<linked_ptr<api::events::Rule>>* out);
 
   // Same as GetRules but returns all rules owned by |extension_id|.
   void GetAllRules(const std::string& extension_id,
-                   std::vector<linked_ptr<core_api::events::Rule>>* out);
+                   std::vector<linked_ptr<api::events::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 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;
@@ skipping 17 matching lines @@
   int id() const { return id_; }
 
  protected:
   virtual ~RulesRegistry();
 
   // 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<core_api::events::Rule>>& rules) = 0;
+      const std::vector<linked_ptr<api::events::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<core_api::events::Rule>>
+  typedef std::map<RulesDictionaryKey, linked_ptr<api::events::Rule>>
       RulesDictionary;
   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;
 
   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<core_api::events::Rule>>& rules,
+      const std::vector<linked_ptr<api::events::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<core_api::events::Rule>>& rules,
+      const std::vector<linked_ptr<api::events::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<core_api::events::Rule>>* out);
+                std::vector<linked_ptr<api::events::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
@@ skipping 45 matching lines @@
                   const std::string& rule_id) const;
 
   // Creates an ID that is unique within the scope of|extension_id|.
   std::string GenerateUniqueId(const std::string& extension_id);
 
   // Verifies that all |rules| have unique IDs or initializes them with
   // unique IDs if they don't have one. In case of duplicate IDs, this function
   // returns a non-empty error message.
   std::string CheckAndFillInOptionalRules(
       const std::string& extension_id,
-      const std::vector<linked_ptr<core_api::events::Rule>>& rules);
+      const std::vector<linked_ptr<api::events::Rule>>& rules);
 
   // Initializes the priority fields in case they have not been set.
   void FillInOptionalPriorities(
-      const std::vector<linked_ptr<core_api::events::Rule>>& rules);
+      const std::vector<linked_ptr<api::events::Rule>>& rules);
 
   // Removes all |identifiers| of |extension_id| from |used_rule_identifiers_|.
   void RemoveUsedRuleIdentifiers(const std::string& extension_id,
                                  const std::vector<std::string>& identifiers);
 
   // Same as RemoveUsedRuleIdentifiers but operates on all rules of
   // |extension_id|.
   void RemoveAllUsedRuleIdentifiers(const std::string& extension_id);
 
   typedef std::string RuleIdentifier;
@@ skipping 11 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__