RulesRegistry for declarative APIs.

chrome/browser/extensions/api/declarative/declarative_apitest.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 "base/command_line.h"
+#include "base/memory/scoped_ptr.h"
+#include "chrome/browser/extensions/api/declarative/rules_registry_service.h"
+#include "chrome/browser/extensions/api/declarative/test_rules_registry.h"
+#include "chrome/browser/extensions/extension_apitest.h"
+#include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/common/chrome_switches.h"
+#include "chrome/common/extensions/extension.h"
+
+namespace {
+const char kTestEvent[] = "webRequest.onRequest";
+}  // namespace
+
+class DeclarativeApiTest : public ExtensionApiTest {
+ public:
+  DeclarativeApiTest() : test_rules_registry_(NULL) {}
+  virtual ~DeclarativeApiTest() {}
+
+  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+    ExtensionApiTest::SetUpCommandLine(command_line);
+    command_line->AppendSwitch(switches::kEnableExperimentalExtensionApis);

[not at google - send to devlin, 2012/02/07 03:25:10]

other tests seem to do

CommandLine::ForCurrentProcess()->AppendSwitch(
    switches::kEnableExperimentalExtensionApis);

in tests. Perhaps that would also work in the constructor, rather than needing
to override a method for this.

[battre, 2012/02/07 18:45:33]

There are several examples of using it this way: download_extension_apitest.cc,
dns_apitest, permissions_apitest.cc serial_apitest.cc ...

+  }
+
+  void RegisterTestRuleRegistry() {
+    using namespace extensions;

[not at google - send to devlin, 2012/02/07 03:25:10]

put at top of file

[battre, 2012/02/07 18:45:33]

There was some discussion on chrome-team that kind of discouraged this, but I
think there was no clear consensus, so I have done it.

Done.

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

oh really?

Well like many things it's a judgement call I guess, but IIRC that discussion
the same arguments applied to why to not have "using namespace extensions" would
apply here as well?  Maybe not.

Either case it's pretty fair to have extensions code that doesn't live in the
extensions namespace to "using" it.

+    Profile* profile = browser()->profile();
+    RulesRegistryService* rules_registry =
+        profile->GetExtensionService()->GetRulesRegistryService();
+    scoped_ptr<RulesRegistry> test_rules_registry(new TestRulesRegistry());
+    test_rules_registry_ = test_rules_registry.get();
+    rules_registry->UnregisterAllRulesRegistries();

[not at google - send to devlin, 2012/02/07 03:25:10]

Why this? Is it so that the previous test's registered rules get cleared, or is
to clear the already-registered rules (e.g. webRequest)?

If the former, then it should be unnecessary, since it's a new browser instance
for each test. And don't the rules get unloaded anyway (I can see that you're
testing that below)?

If the latter, then hopefully it's unnecessary because it would work without it.

[battre, 2012/02/07 18:45:33]

The idea here is,that the webRequest implementation my represent rules
internally in a different way. It could be possible that getRules() does not
return exactly the same representation of rules as was passed to addRules().
This would break the apitests. I have removed this, as we can introduce it back
in case we decide that we need it.

Done.

+    rules_registry->RegisterRulesRegistry(kTestEvent,
+                                          test_rules_registry.Pass());
+  }
+
+  // Weak pointer that is deleted when the profile is destroyed.
+  extensions::RulesRegistry* test_rules_registry_;
+};
+
+IN_PROC_BROWSER_TEST_F(DeclarativeApiTest, DeclarativeApi) {
+  RegisterTestRuleRegistry();
+  ASSERT_TRUE(RunExtensionTest("declarative/api")) << message_;
+
+  // Check that unloading the page has removed all rules.
+  std::string extension_id = GetSingleLoadedExtension()->id();
+  UnloadExtension(extension_id);
+
+  std::vector<std::string> rule_identifiers;  // Empty to get all rules.
+  std::vector<DictionaryValue*> known_rules;
+  test_rules_registry_->GetRules(extension_id,
+                                 rule_identifiers,
+                                 &known_rules);
+  EXPECT_TRUE(known_rules.empty());
+}