RulesRegistry for declarative APIs.

chrome/browser/extensions/api/declarative/declarative_api.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 "chrome/browser/extensions/api/declarative/declarative_api.h"
 
+#include "base/bind.h"
 #include "base/values.h"
+#include "chrome/browser/extensions/api/declarative/rules_registry.h"
+#include "chrome/browser/extensions/api/declarative/rules_registry_service.h"
+#include "chrome/browser/extensions/api/declarative/rules_registry_service_factory.h"
 
 namespace extensions {
 
 bool AddRulesFunction::RunImpl() {
-  // LOG(ERROR) << "AddRulesFunction called";
+  // The name of the event object which had the addRules() function that was
+  // called.

[not at google - send to devlin, 2012/02/02 11:59:16]

This comment isn't entirely accurate, because the API functions can be called
without the presence of an event.

Also I think experimental.declarative.json is descriptive enough to not need it.

[battre, 2012/02/02 19:12:36]

Done.

+  std::string event_name;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &event_name));

[not at google - send to devlin, 2012/02/02 11:59:16]

Note: very soon you'll be able to use json_schema_compiler to avoid all of this
boilerplate.  Chris' (calamity@) generator is now generating the code needed for
the Declarative API on his desktop; support for it should be checked in early
next week.

When it is, you'll need to list the JSON file in
chrome/common/extensions/api/api.gyp to get all the code to be generated. Then
use it; see permissions_api.cc as a guide, but basically

namespace extensions {

using namespace api::experimental_declarative;

bool AddRulesFunction::RunImpl() {
  scoped_ptr<AddRules::Params> params(AddRules::Params::Create(*args_));
  EXTENSION_FUNCTION_VALIDATE(params.get());

  // You now have access to fields like:
  params->event; // std::string
  params->rules; // std::vector<linked_ptr<Rule> >

  // Where Rule is like:
  Rule* rule = params->rules[0];
  rule->id;         // scoped_ptr<std::string>, because it's optional
  rule->conditions; // std::vector<linked_ptr<DictionaryValue> >
  rule->actions;    // std::vector<linked_ptr<DictionaryValue> >
  rule->priority;   // scoped_ptr<int>, because it's optional

  ...
}


I actually wonder if it's worth holding off on this patch until
json_schema_compiler can be used.  It will be massively beneficial; not only
would all of this VALIDATE/looping/GetFoo stuff be unnecessary, but you'd be
able to pass a vector of Rules directly into AddRules rather than a
DictionaryValue.  That's a massive win.  Oh, and you wouldn't need that extra
file for constants.

So you should definitely chat to calamity@ :)

[battre, 2012/02/02 19:12:36]

sounds awesome!!!

 
   ListValue* rules_list;
   EXTENSION_FUNCTION_VALIDATE(args_->GetList(1, &rules_list));
 
-  // TODO(battre): Generate unique IDs and priorities here.
+  std::vector<DictionaryValue*> rules;
+  for (ListValue::iterator i = rules_list->begin();
+       i != rules_list->end();
+       ++i) {
+    DictionaryValue* rule;

[not at google - send to devlin, 2012/02/02 11:59:16]

= NULL

etc

[battre, 2012/02/02 19:12:36]

Done.

+    EXTENSION_FUNCTION_VALIDATE((*i)->GetAsDictionary(&rule));
+    rules.push_back(rule);
+  }
+
+  RulesRegistryService* rules_registry =
+      RulesRegistryServiceFactory::GetInstance()->GetForProfile(profile_);
+
+  EXTENSION_FUNCTION_VALIDATE(
+      rules_registry->AddRules(

[not at google - send to devlin, 2012/02/02 11:59:16]

EXTENSION_FUNCTION_VALIDATE is for validating that the messages from the
renderer are structured correctly, as in, the same validation that the schema
validation is doing on the renderer.  If it fails, the renderer is killed.

From what I can tell, a false return value from AddRules is due to an extension
making a bad call; it shouldn't result in it being killed.  That seems harsh.

[battre, 2012/02/02 19:12:36]

Valid points. I have promoted this to graceful failures.

Done.

+          event_name,
+          extension_id(),
+          rules,
+          base::Bind(&AddRulesFunction::SetError, this)));
 
   result_.reset(rules_list->DeepCopy());
   return true;
 }
 
 bool RemoveRulesFunction::RunImpl() {
-  // LOG(ERROR) << "RemoveRulesFunction called";
+  std::string event_name;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &event_name));
+
+  ListValue* rule_identifiers_list;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetList(1, &rule_identifiers_list));
+
+  std::vector<std::string> rule_identifiers;
+  for (ListValue::iterator i = rule_identifiers_list->begin();
+       i != rule_identifiers_list->end();
+       ++i) {
+    std::string rule_id;
+    EXTENSION_FUNCTION_VALIDATE((*i)->GetAsString(&rule_id));
+    rule_identifiers.push_back(rule_id);
+  }
+
+  RulesRegistryService* rules_registry =
+      RulesRegistryServiceFactory::GetInstance()->GetForProfile(profile_);
+
+  EXTENSION_FUNCTION_VALIDATE(
+      rules_registry->RemoveRules(
+          event_name,
+          extension_id(),
+          rule_identifiers,
+          base::Bind(&AddRulesFunction::SetError, this)));
+
   return true;
 }
 
 bool GetRulesFunction::RunImpl() {
-  // LOG(ERROR) << "GetRulesFunction called";
-  result_.reset(new ListValue());
+  std::string event_name;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &event_name));
+
+  ListValue* rule_identifiers_list;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetList(1, &rule_identifiers_list));
+
+  std::vector<std::string> rule_identifiers;
+  for (ListValue::iterator i = rule_identifiers_list->begin();

[Aaron Boodman, 2012/02/02 16:28:51]

If you don't end up waiting on calamity@, you could pull this out into a helper
for now.

+       i != rule_identifiers_list->end();
+       ++i) {
+    std::string rule_id;
+    EXTENSION_FUNCTION_VALIDATE((*i)->GetAsString(&rule_id));
+    rule_identifiers.push_back(rule_id);
+  }
+
+  RulesRegistryService* rules_registry =
+      RulesRegistryServiceFactory::GetInstance()->GetForProfile(profile_);
+
+  typedef std::vector<DictionaryValue*> RulesList;
+
+  RulesList rules;
+  rules_registry->GetRules(
+      event_name, extension_id(), rule_identifiers, &rules);
+
+  scoped_ptr<ListValue> result(new ListValue);
+  for (RulesList::iterator i = rules.begin(); i != rules.end(); ++i)
+    result->Append(*i);
+
+  result_.reset(result.release());
   return true;
 }
 
 }  // namespace extensions