Create a mechanism define declarative rules via the extension manifest.

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"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "extensions/browser/api/declarative/rules_cache_delegate.h"
 #include "extensions/browser/extension_prefs.h"
+#include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/state_store.h"
 #include "extensions/common/extension.h"
 
 namespace {
 
 const char kSuccess[] = "";
 const char kDuplicateRuleId[] = "Duplicate rule ID: %s";
 
 scoped_ptr<base::Value> RulesToValue(
@@ skipping 183 matching lines @@
     LOG(ERROR) << error;
 }
 
 void RulesRegistry::OnExtensionUninstalled(const std::string& extension_id) {
   DCHECK_CURRENTLY_ON(owner_thread());
   std::string error = RemoveAllRulesNoStoreUpdate(extension_id);
   if (!error.empty())
     LOG(ERROR) << error;
 }
 
 void RulesRegistry::OnExtensionLoaded(const std::string& extension_id) {

[not at google - send to devlin, 2015/06/02 22:44:50]

Could you update OnExtensionUnloaded/Uninstalled/Loaded to pass in an Extension
rather than its ID? It's trivial (call sites just grab the ID out of the
Extension object they already have access to) and it would save needing to do
the extra map lookup + the extensionregistry dependency.

[danduong, 2015/06/05 06:41:57]

Done.

   DCHECK_CURRENTLY_ON(owner_thread());
   std::vector<linked_ptr<Rule> > rules;
   GetAllRules(extension_id, &rules);
-  std::string error = AddRulesImpl(extension_id, rules);
-  if (!error.empty())
-    LOG(ERROR) << error;
+  if (rules.empty()) {
+    // If no rules have been registered yet, check if there are any rules

[not at google - send to devlin, 2015/06/02 22:44:50]

Why only if there are no rules registered yet? It seems a perfectly reasonable
use case to have a set of rules in the manifest, with a dynamic set to add
later.

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

Done.

+    // defined in the extension manifest to add.
+    const Extension* extension =
+        ExtensionRegistry::Get(browser_context())
+            ->GetExtensionById(extension_id, ExtensionRegistry::EVERYTHING);
+    const base::ListValue* value = NULL;
+    if (extension->manifest()->GetList(event_name_, &value)) {
+      AddRules(extension_id, RulesFromValue(value));
+    }
+  } else {
+    std::string error = AddRulesImpl(extension_id, rules);
+    if (!error.empty())
+      LOG(ERROR) << error;
+  }
 }
 
 size_t RulesRegistry::GetNumberOfUsedRuleIdentifiersForTesting() const {
   size_t entry_count = 0u;
   for (RuleIdentifiersMap::const_iterator extension =
            used_rule_identifiers_.begin();
        extension != used_rule_identifiers_.end();
        ++extension) {
     // Each extension is counted as 1 just for being there. Otherwise we miss
     // keys with empty values.
@@ skipping 125 matching lines @@
   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