RulesRegistry for declarative APIs.

chrome/browser/extensions/api/declarative/test_rules_registry.cc

Index: chrome/browser/extensions/api/declarative/test_rules_registry.cc
diff --git a/chrome/browser/extensions/api/declarative/test_rules_registry.cc b/chrome/browser/extensions/api/declarative/test_rules_registry.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ef24544821948e81d73f39bd2997139996f77f5d
--- /dev/null
+++ b/chrome/browser/extensions/api/declarative/test_rules_registry.cc
@@ -0,0 +1,95 @@
+// 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 "chrome/browser/extensions/api/declarative/test_rules_registry.h"
+
+#include "base/logging.h"
+#include "chrome/browser/extensions/api/declarative/declarative_api_constants.h"
+
+namespace keys = extensions::declarative_api_constants;
+
+namespace {
+
+std::string GetRuleId(DictionaryValue* rule) {
+  std::string rule_id;
+  CHECK(rule->GetString(keys::kId, &rule_id));
+  return rule_id;
+}
+
+}  // namespace
+
+namespace extensions {
+
+TestRulesRegistry::TestRulesRegistry() {}
+
+TestRulesRegistry::~TestRulesRegistry() {}
+
+bool TestRulesRegistry::AddRules(
+    const std::string& extension_id,
+    const std::vector<DictionaryValue*>& rules,
+    std::string* error) {
+  // TODO(battre) this ignores the extension_id but should not.
+  for (std::vector<DictionaryValue*>::const_iterator i =
+      rules.begin(); i != rules.end(); ++i) {
+    std::string rule_id = GetRuleId(*i);
+    // TODO: relax this (check first and abort with returning false).
+    CHECK(rules_.find(rule_id) == rules_.end());
+    rules_[rule_id] = make_linked_ptr((*i)->DeepCopy());
+  }
+  return true;
+}
+
+bool TestRulesRegistry::RemoveRules(
+    const std::string& extension_id,
+    const std::vector<std::string>& rule_identifiers,
+    std::string* error) {
+  // TODO(battre) this ignores the extension_id but should not.
+  for (std::vector<std::string>::const_iterator i =
+      rule_identifiers.begin(); i != rule_identifiers.end(); ++i) {
+    RulesDictionary::iterator entry = rules_.find(*i);
+    // TODO: relax this (check first and abort with returning false).
+    CHECK(entry != rules_.end());
+    rules_.erase(entry);
+  }
+  return true;
+}
+
+bool TestRulesRegistry::RemoveAllRules(
+    const std::string& extension_id,
+    std::string* error) {
+  // TODO(battre) this ignores the extension_id but should not.
+  rules_.clear();
+  return true;
+}
+
+void TestRulesRegistry::GetRules(
+    const std::string& extension_id,
+    const std::vector<std::string>& rule_identifiers,
+    std::vector<DictionaryValue*>* out) {
+  // TODO(battre) this ignores the extension_id but should not.
+  for (std::vector<std::string>::const_iterator i = rule_identifiers.begin();
+      i != rule_identifiers.end(); ++i) {
+    RulesDictionary::iterator entry = rules_.find(*i);
+    CHECK(entry != rules_.end());

[not at google - send to devlin, 2012/02/07 23:54:57]

not sure, similar comment here as to the NOTREACHED thing before, however in
this case it would also crash the browser in Release mode.  We don't want
extensions to be able to crash the browser by requesting rules that don't exist.

Perhaps GetRules needs the ability to report errors.

[battre, 2012/02/08 12:49:54]

Done. (Note though that this is part of the testing framework - this will be
changed completely for the production version.) 

[not at google - send to devlin, 2012/02/08 22:31:18]

Ah, right, of course.

+    out->push_back(entry->second->DeepCopy());
+  }
+}
+
+void TestRulesRegistry::GetAllRules(
+    const std::string& extension_id,
+    std::vector<DictionaryValue*>* out) {
+  // TODO(battre): this ignores the extension_id.
+  for (RulesDictionary::const_iterator i = rules_.begin();
+      i != rules_.end(); ++i)
+    out->push_back(i->second->DeepCopy());
+}
+
+void TestRulesRegistry::OnExtensionUnloaded(const std::string& extension_id) {
+  std::vector<std::string> no_rule_identifiers;
+  std::string error;
+  if (!RemoveRules(extension_id, no_rule_identifiers, &error))
+    LOG(ERROR) << error;
+}
+
+}  // namespace extensions