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

extensions/browser/api/declarative/rules_registry.cc

 // 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.
 
 #include "extensions/browser/api/declarative/rules_registry.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 21 matching lines @@
 namespace extensions {
 
 namespace {
 
 const char kSuccess[] = "";
 const char kDuplicateRuleId[] = "Duplicate rule ID: %s";
 const char kErrorCannotRemoveManifestRules[] =
     "Rules declared in the 'event_rules' manifest field cannot be removed";
 
 scoped_ptr<base::Value> RulesToValue(
-    const std::vector<linked_ptr<core_api::events::Rule>>& rules) {
+    const std::vector<linked_ptr<api::events::Rule>>& rules) {
   scoped_ptr<base::ListValue> list(new base::ListValue());
   for (size_t i = 0; i < rules.size(); ++i)
     list->Append(rules[i]->ToValue().release());
   return list.Pass();
 }
 
-std::vector<linked_ptr<core_api::events::Rule>> RulesFromValue(
+std::vector<linked_ptr<api::events::Rule>> RulesFromValue(
     const base::Value* value) {
-  std::vector<linked_ptr<core_api::events::Rule>> rules;
+  std::vector<linked_ptr<api::events::Rule>> rules;
 
   const base::ListValue* list = NULL;
   if (!value || !value->GetAsList(&list))
     return rules;
 
   rules.reserve(list->GetSize());
   for (size_t i = 0; i < list->GetSize(); ++i) {
     const base::DictionaryValue* dict = NULL;
     if (!list->GetDictionary(i, &dict))
       continue;
-    linked_ptr<core_api::events::Rule> rule(new core_api::events::Rule());
-    if (core_api::events::Rule::Populate(*dict, rule.get()))
+    linked_ptr<api::events::Rule> rule(new api::events::Rule());
+    if (api::events::Rule::Populate(*dict, rule.get()))
       rules.push_back(rule);
   }
 
   return rules;
 }
 
 std::string ToId(int identifier) {
   return base::StringPrintf("_%d_", identifier);
 }
 
@@ skipping 16 matching lines @@
       last_generated_rule_identifier_id_(0),
       weak_ptr_factory_(browser_context_ ? this : NULL) {
   if (cache_delegate) {
     cache_delegate_ = cache_delegate->GetWeakPtr();
     cache_delegate->Init(this);
   }
 }
 
 std::string RulesRegistry::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) {
   DCHECK_CURRENTLY_ON(owner_thread());
 
   // Verify that all rule IDs are new.
-  for (std::vector<linked_ptr<core_api::events::Rule>>::const_iterator i =
+  for (std::vector<linked_ptr<api::events::Rule>>::const_iterator i =
            rules.begin();
        i != rules.end(); ++i) {
     const RuleId& rule_id = *((*i)->id);
     // Every rule should have a priority assigned.
     DCHECK((*i)->priority);
     RulesDictionaryKey key(extension_id, rule_id);
     if (rules_.find(key) != rules_.end() ||
         manifest_rules_.find(key) != manifest_rules_.end())
       return base::StringPrintf(kDuplicateRuleId, rule_id.c_str());
   }
 
   std::string error = AddRulesImpl(extension_id, rules);
 
   if (!error.empty())
     return error;
 
   // Commit all rules into |rules_| on success.
-  for (std::vector<linked_ptr<core_api::events::Rule>>::const_iterator i =
+  for (std::vector<linked_ptr<api::events::Rule>>::const_iterator i =
            rules.begin();
        i != rules.end(); ++i) {
     const RuleId& rule_id = *((*i)->id);
     RulesDictionaryKey key(extension_id, rule_id);
     (*out)[key] = *i;
   }
 
   MaybeProcessChangedRules(extension_id);
   return kSuccess;
 }
 
 std::string RulesRegistry::AddRules(
     const std::string& extension_id,
-    const std::vector<linked_ptr<core_api::events::Rule>>& rules) {
+    const std::vector<linked_ptr<api::events::Rule>>& rules) {
   return AddRulesInternal(extension_id, rules, &rules_);
 }
 
 std::string RulesRegistry::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) {
   DCHECK_CURRENTLY_ON(owner_thread());
 
   std::string error = CheckAndFillInOptionalRules(extension_id, rules);
   if (!error.empty())
     return error;
   FillInOptionalPriorities(rules);
 
   return AddRulesNoFill(extension_id, rules, out);
 }
@@ skipping 54 matching lines @@
     }
   };
   remove_rules(rules_);
   if (remove_manifest_rules)
     remove_rules(manifest_rules_);
 
   RemoveAllUsedRuleIdentifiers(extension_id);
   return kSuccess;
 }
 
-void RulesRegistry::GetRules(
-    const std::string& extension_id,
-    const std::vector<std::string>& rule_identifiers,
-    std::vector<linked_ptr<core_api::events::Rule>>* out) {
+void RulesRegistry::GetRules(const std::string& extension_id,
+                             const std::vector<std::string>& rule_identifiers,
+                             std::vector<linked_ptr<api::events::Rule>>* out) {
   DCHECK_CURRENTLY_ON(owner_thread());
 
   for (const auto& i : rule_identifiers) {
     RulesDictionaryKey lookup_key(extension_id, i);
     RulesDictionary::iterator entry = rules_.find(lookup_key);
     if (entry != rules_.end())
       out->push_back(entry->second);
     entry = manifest_rules_.find(lookup_key);
     if (entry != manifest_rules_.end())
       out->push_back(entry->second);
   }
 }
 
-void RulesRegistry::GetRules(
-    const std::string& extension_id,
-    RulesDictionary& rules,
-    std::vector<linked_ptr<core_api::events::Rule>>* out) {
+void RulesRegistry::GetRules(const std::string& extension_id,
+                             RulesDictionary& rules,
+                             std::vector<linked_ptr<api::events::Rule>>* out) {
   for (const auto& i : rules) {
     const RulesDictionaryKey& key = i.first;
     if (key.first == extension_id)
       out->push_back(i.second);
   }
 }
 
 void RulesRegistry::GetAllRules(
     const std::string& extension_id,
-    std::vector<linked_ptr<core_api::events::Rule>>* out) {
+    std::vector<linked_ptr<api::events::Rule>>* out) {
   DCHECK_CURRENTLY_ON(owner_thread());
   GetRules(extension_id, manifest_rules_, out);
   GetRules(extension_id, rules_, out);
 }
 
 void RulesRegistry::OnExtensionUnloaded(const Extension* extension) {
   DCHECK_CURRENTLY_ON(owner_thread());
   std::string error = RemoveAllRulesImpl(extension->id());
   if (!error.empty())
     ReportInternalError(extension->id(), error);
 }
 
 void RulesRegistry::OnExtensionUninstalled(const Extension* extension) {
   DCHECK_CURRENTLY_ON(owner_thread());
   std::string error = RemoveAllRulesNoStoreUpdate(extension->id(), true);
   if (!error.empty())
     ReportInternalError(extension->id(), error);
 }
 
 void RulesRegistry::OnExtensionLoaded(const Extension* extension) {
   DCHECK_CURRENTLY_ON(owner_thread());
-  std::vector<linked_ptr<core_api::events::Rule>> rules;
+  std::vector<linked_ptr<api::events::Rule>> rules;
   GetAllRules(extension->id(), &rules);
   DeclarativeManifestData* declarative_data =
       DeclarativeManifestData::Get(extension);
   if (declarative_data) {
-    std::vector<linked_ptr<core_api::events::Rule>>& manifest_rules =
+    std::vector<linked_ptr<api::events::Rule>>& manifest_rules =
         declarative_data->RulesForEvent(event_name_);
     if (manifest_rules.size()) {
       std::string error =
           AddRulesInternal(extension->id(), manifest_rules, &manifest_rules_);
       if (!error.empty())
         ReportInternalError(extension->id(), error);
     }
   }
   std::string error = AddRulesImpl(extension->id(), rules);
   if (!error.empty())
@@ skipping 45 matching lines @@
 
   ready_.Signal();
 }
 
 void RulesRegistry::ProcessChangedRules(const std::string& extension_id) {
   DCHECK_CURRENTLY_ON(owner_thread());
 
   DCHECK(ContainsKey(process_changed_rules_requested_, extension_id));
   process_changed_rules_requested_[extension_id] = NOT_SCHEDULED_FOR_PROCESSING;
 
-  std::vector<linked_ptr<core_api::events::Rule>> new_rules;
+  std::vector<linked_ptr<api::events::Rule>> new_rules;
   GetRules(extension_id, rules_, &new_rules);
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::Bind(&RulesCacheDelegate::WriteToStorage, cache_delegate_,
                  extension_id, base::Passed(RulesToValue(new_rules))));
 }
 
 void RulesRegistry::MaybeProcessChangedRules(const std::string& extension_id) {
   // Read and initialize |process_changed_rules_requested_[extension_id]| if
   // necessary. (Note that the insertion below will not overwrite
@@ skipping 22 matching lines @@
 }
 
 std::string RulesRegistry::GenerateUniqueId(const std::string& extension_id) {
   while (!IsUniqueId(extension_id, ToId(last_generated_rule_identifier_id_)))
     ++last_generated_rule_identifier_id_;
   return ToId(last_generated_rule_identifier_id_);
 }
 
 std::string RulesRegistry::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) {
   // IDs we have inserted, in case we need to rollback this operation.
   std::vector<std::string> rollback_log;
 
   // First we insert all rules with existing identifier, so that generated
   // identifiers cannot collide with identifiers passed by the caller.
-  for (std::vector<linked_ptr<core_api::events::Rule>>::const_iterator i =
+  for (std::vector<linked_ptr<api::events::Rule>>::const_iterator i =
            rules.begin();
        i != rules.end(); ++i) {
-    core_api::events::Rule* rule = i->get();
+    api::events::Rule* rule = i->get();
     if (rule->id.get()) {
       std::string id = *(rule->id);
       if (!IsUniqueId(extension_id, id)) {
         RemoveUsedRuleIdentifiers(extension_id, rollback_log);
         return "Id " + id + " was used multiple times.";
       }
       used_rule_identifiers_[extension_id].insert(id);
     }
   }
   // Now we generate IDs in case they were not specified in the rules. This
   // cannot fail so we do not need to keep track of a rollback log.
-  for (std::vector<linked_ptr<core_api::events::Rule>>::const_iterator i =
+  for (std::vector<linked_ptr<api::events::Rule>>::const_iterator i =
            rules.begin();
        i != rules.end(); ++i) {
-    core_api::events::Rule* rule = i->get();
+    api::events::Rule* rule = i->get();
     if (!rule->id.get()) {
       rule->id.reset(new std::string(GenerateUniqueId(extension_id)));
       used_rule_identifiers_[extension_id].insert(*(rule->id));
     }
   }
   return std::string();
 }
 
 void RulesRegistry::FillInOptionalPriorities(
-    const std::vector<linked_ptr<core_api::events::Rule>>& rules) {
-  std::vector<linked_ptr<core_api::events::Rule>>::const_iterator i;
+    const std::vector<linked_ptr<api::events::Rule>>& rules) {
+  std::vector<linked_ptr<api::events::Rule>>::const_iterator i;
   for (i = rules.begin(); i != rules.end(); ++i) {
     if (!(*i)->priority.get())
       (*i)->priority.reset(new int(DEFAULT_PRIORITY));
   }
 }
 
 void RulesRegistry::RemoveUsedRuleIdentifiers(
     const std::string& extension_id,
     const std::vector<std::string>& identifiers) {
   std::vector<std::string>::const_iterator i;
   for (i = identifiers.begin(); i != identifiers.end(); ++i)
     used_rule_identifiers_[extension_id].erase(*i);
 }
 
 void RulesRegistry::RemoveAllUsedRuleIdentifiers(
     const std::string& extension_id) {
   used_rule_identifiers_.erase(extension_id);
 }
 
 }  // namespace extensions