DNR: Introduce getEnabledRulesets.

Introduce getEnabledRulesets extension function which returns the IDs
for the set of enabled static rulesets.

BUG=754526

Change-Id: Ie7647c718b96953a7ba2fbb0e2322443b9a18fec
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2189692
Commit-Queue: Karan Bhatia <karandeepb@chromium.org>
Reviewed-by: Kelvin Jiang <kelvinjiang@chromium.org>
Reviewed-by: Devlin <rdevlin.cronin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#768546}

chrome/browser/extensions/api/declarative_net_request/declarative_net_request_unittest.cc

@@ -23,6 +23,7 @@
 #include "base/test/metrics/histogram_tester.h"
 #include "base/test/scoped_run_loop_timeout.h"
 #include "base/test/test_timeouts.h"
+#include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/api/declarative_net_request/dnr_test_base.h"
 #include "chrome/browser/extensions/chrome_test_extension_loader.h"
@@ -240,6 +241,29 @@ class DeclarativeNetRequestUnittest : public DNRTestBase {
                   function.get(), json_args, browser_context()));
   }
 
+  void VerifyGetEnabledRulesetsFunction(
+      const Extension& extension,
+      const std::vector<std::string>& expected_ids) {
+    auto function =
+        base::MakeRefCounted<DeclarativeNetRequestGetEnabledRulesetsFunction>();
+    function->set_extension(&extension);
+    function->set_has_callback(true);
+
+    std::unique_ptr<base::Value> result =
+        api_test_utils::RunFunctionAndReturnSingleResult(
+            function.get(), "[]" /* args */, browser_context());
+    ASSERT_TRUE(result);
+    ASSERT_TRUE(result->is_list());
+    const base::ListValue& ids_value = base::Value::AsListValue(*result);
+
+    base::string16 error;
+    std::vector<std::string> actual_ids;
+    for (const auto& val : ids_value)
+      actual_ids.push_back(val.GetString());
+
+    EXPECT_THAT(expected_ids, UnorderedElementsAreArray(actual_ids));
+  }
+
   void VerifyPublicRulesetIDs(
       const Extension& extension,
       const std::vector<std::string>& expected_public_ruleset_ids) {
@@ -917,6 +941,7 @@ TEST_P(MultipleRulesetsTest, Success) {
 // Tests an extension with no static rulesets.
 TEST_P(MultipleRulesetsTest, ZeroRulesets) {
   LoadAndExpectSuccess();
+  VerifyGetEnabledRulesetsFunction(*extension(), {});
 }
 
 // Tests an extension with multiple empty rulesets.
@@ -1232,7 +1257,7 @@ TEST_P(MultipleRulesetsTest, UpdateEnabledRulesets_InternalError) {
   }
 }
 
-TEST_P(MultipleRulesetsTest, UpdateEnabledRulesets_Success) {
+TEST_P(MultipleRulesetsTest, UpdateAndGetEnabledRulesets_Success) {
   AddRuleset(CreateRuleset(kId1, 10, 10, true));
   AddRuleset(CreateRuleset(kId2, 10, 10, false));
   AddRuleset(CreateRuleset(kId3, 10, 10, true));
@@ -1245,32 +1270,39 @@ TEST_P(MultipleRulesetsTest, UpdateEnabledRulesets_Success) {
   RunUpdateEnabledRulesetsFunction(*extension(), {kId1, kId3}, {kId2},
                                    base::nullopt /* expected_error */);
   VerifyPublicRulesetIDs(*extension(), {kId2});
+  VerifyGetEnabledRulesetsFunction(*extension(), {kId2});
 
   RunUpdateEnabledRulesetsFunction(*extension(), {}, {kId3, kId3},
                                    base::nullopt /* expected_error */);
   VerifyPublicRulesetIDs(*extension(), {kId2, kId3});
+  VerifyGetEnabledRulesetsFunction(*extension(), {kId2, kId3});
 
   // Ensure no-op calls succeed.
   RunUpdateEnabledRulesetsFunction(*extension(), {}, {kId2, kId3},
                                    base::nullopt /* expected_error */);
   VerifyPublicRulesetIDs(*extension(), {kId2, kId3});
+  VerifyGetEnabledRulesetsFunction(*extension(), {kId2, kId3});
 
   RunUpdateEnabledRulesetsFunction(*extension(), {kId1}, {},
                                    base::nullopt /* expected_error */);
   VerifyPublicRulesetIDs(*extension(), {kId2, kId3});
+  VerifyGetEnabledRulesetsFunction(*extension(), {kId2, kId3});
 
   // Add dynamic rules and ensure that the setEnabledRulesets call doesn't have
-  // any effect on the dynamic ruleset.
+  // any effect on the dynamic ruleset. Also ensure that the getEnabledRulesets
+  // call excludes the dynamic ruleset ID.
   ASSERT_TRUE(
       RunDynamicRuleUpdateFunction(*extension(), {}, {CreateGenericRule()}));
   VerifyPublicRulesetIDs(*extension(),
                          {kId2, kId3, dnr_api::DYNAMIC_RULESET_ID});
+  VerifyGetEnabledRulesetsFunction(*extension(), {kId2, kId3});
 
   // Ensure enabling a ruleset takes priority over disabling.
   RunUpdateEnabledRulesetsFunction(*extension(), {kId1}, {kId1},
                                    base::nullopt /* expected_error */);
   VerifyPublicRulesetIDs(*extension(),
                          {kId1, kId2, kId3, dnr_api::DYNAMIC_RULESET_ID});
+  VerifyGetEnabledRulesetsFunction(*extension(), {kId1, kId2, kId3});
 }
 
 INSTANTIATE_TEST_SUITE_P(All,

extensions/browser/api/declarative_net_request/declarative_net_request_api.cc

@@ -218,6 +218,34 @@ void DeclarativeNetRequestUpdateEnabledRulesetsFunction::
     Respond(NoArguments());
 }
 
+DeclarativeNetRequestGetEnabledRulesetsFunction::
+    DeclarativeNetRequestGetEnabledRulesetsFunction() = default;
+DeclarativeNetRequestGetEnabledRulesetsFunction::
+    ~DeclarativeNetRequestGetEnabledRulesetsFunction() = default;
+
+ExtensionFunction::ResponseAction
+DeclarativeNetRequestGetEnabledRulesetsFunction::Run() {
+  auto* rules_monitor_service =
+      declarative_net_request::RulesMonitorService::Get(browser_context());
+  DCHECK(rules_monitor_service);
+
+  std::vector<std::string> public_ids;
+  declarative_net_request::CompositeMatcher* matcher =
+      rules_monitor_service->ruleset_manager()->GetMatcherForExtension(
+          extension_id());
+  if (matcher) {
+    DCHECK(extension());
+    public_ids = GetPublicRulesetIDs(*extension(), *matcher);
+
+    // Exclude the dynamic ruleset ID if present, as expected by the API
+    // function.
+    base::Erase(public_ids, dnr_api::DYNAMIC_RULESET_ID);
+  }
+
+  return RespondNow(
+      ArgumentList(dnr_api::GetEnabledRulesets::Results::Create(public_ids)));
+}
+
 // static
 bool
     DeclarativeNetRequestGetMatchedRulesFunction::disable_throttling_for_test_ =

extensions/browser/api/declarative_net_request/declarative_net_request_api.h

@@ -67,6 +67,21 @@ class DeclarativeNetRequestUpdateEnabledRulesetsFunction
   ExtensionFunction::ResponseAction Run() override;
 };
 
+class DeclarativeNetRequestGetEnabledRulesetsFunction
+    : public ExtensionFunction {
+ public:
+  DeclarativeNetRequestGetEnabledRulesetsFunction();
+  DECLARE_EXTENSION_FUNCTION("declarativeNetRequest.getEnabledRulesets",
+                             DECLARATIVENETREQUEST_GETENABLEDRULESETS)
+
+ protected:
+  ~DeclarativeNetRequestGetEnabledRulesetsFunction() override;
+
+ private:
+  // ExtensionFunction override:
+  ExtensionFunction::ResponseAction Run() override;
+};
+
 class DeclarativeNetRequestGetMatchedRulesFunction : public ExtensionFunction {
  public:
   DeclarativeNetRequestGetMatchedRulesFunction();

extensions/browser/api/declarative_net_request/test_utils.cc

@@ -12,7 +12,6 @@
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_file_value_serializer.h"
-#include "extensions/browser/api/declarative_net_request/composite_matcher.h"
 #include "extensions/browser/api/declarative_net_request/indexed_rule.h"
 #include "extensions/browser/api/declarative_net_request/ruleset_matcher.h"
 #include "extensions/browser/api/declarative_net_request/ruleset_source.h"
@@ -372,15 +371,6 @@ bool EqualsForTesting(const dnr_api::ModifyHeaderInfo& lhs,
   return lhs.operation == rhs.operation && lhs.header == rhs.header;
 }
 
-std::vector<std::string> GetPublicRulesetIDs(const Extension& extension,
-                                             const CompositeMatcher& matcher) {
-  std::vector<std::string> ids;
-  for (const std::unique_ptr<RulesetMatcher>& matcher : matcher.matchers())
-    ids.push_back(GetPublicRulesetID(extension, matcher->id()));
-
-  return ids;
-}
-
 RulesetManagerObserver::RulesetManagerObserver(RulesetManager* manager)
     : manager_(manager), current_count_(manager_->GetMatcherCountForTest()) {
   manager_->SetObserverForTest(this);

extensions/browser/api/declarative_net_request/test_utils.h

@@ -31,7 +31,6 @@ class Extension;
 
 namespace declarative_net_request {
 
-class CompositeMatcher;
 class RulesetSource;
 class RulesetMatcher;
 struct TestRule;
@@ -84,11 +83,6 @@ bool EqualsForTesting(
     const api::declarative_net_request::ModifyHeaderInfo& lhs,
     const api::declarative_net_request::ModifyHeaderInfo& rhs);
 
-// Returns the public ruleset IDs corresponding to the given |extension| and
-// |matcher|.
-std::vector<std::string> GetPublicRulesetIDs(const Extension& extension,
-                                             const CompositeMatcher& matcher);
-
 // Test observer for RulesetManager. This is a multi-use observer i.e.
 // WaitForExtensionsWithRulesetsCount can be called multiple times per lifetime
 // of an observer.

extensions/browser/api/declarative_net_request/utils.cc

@@ -19,8 +19,10 @@
 #include "components/url_pattern_index/url_pattern_index.h"
 #include "components/web_cache/browser/web_cache_manager.h"
 #include "content/public/browser/browser_thread.h"
+#include "extensions/browser/api/declarative_net_request/composite_matcher.h"
 #include "extensions/browser/api/declarative_net_request/constants.h"
 #include "extensions/browser/api/declarative_net_request/flat/extension_ruleset_generated.h"
+#include "extensions/browser/api/declarative_net_request/ruleset_matcher.h"
 #include "extensions/browser/api/web_request/web_request_info.h"
 #include "extensions/common/api/declarative_net_request/constants.h"
 #include "extensions/common/api/declarative_net_request/dnr_manifest_data.h"
@@ -277,5 +279,15 @@ std::string GetPublicRulesetID(const Extension& extension,
   return DNRManifestData::GetRuleset(extension, ruleset_id).manifest_id;
 }
 
+std::vector<std::string> GetPublicRulesetIDs(const Extension& extension,
+                                             const CompositeMatcher& matcher) {
+  std::vector<std::string> ids;
+  ids.reserve(matcher.matchers().size());
+  for (const std::unique_ptr<RulesetMatcher>& matcher : matcher.matchers())
+    ids.push_back(GetPublicRulesetID(extension, matcher->id()));
+
+  return ids;
+}
+
 }  // namespace declarative_net_request
 }  // namespace extensions

extensions/browser/api/declarative_net_request/utils.h

@@ -29,6 +29,7 @@ namespace extensions {
 struct WebRequestInfo;
 
 namespace declarative_net_request {
+class CompositeMatcher;
 
 // Returns true if |data| represents a valid data buffer containing indexed
 // ruleset data with |expected_checksum|.
@@ -93,6 +94,11 @@ flat::ActionType ConvertToFlatActionType(
 std::string GetPublicRulesetID(const Extension& extension,
                                RulesetID ruleset_id);
 
+// Returns the public ruleset IDs corresponding to the given |extension| and
+// |matcher|.
+std::vector<std::string> GetPublicRulesetIDs(const Extension& extension,
+                                             const CompositeMatcher& matcher);
+
 // Helper to convert a flatbufffers::String to a string-like object with type T.
 template <typename T>
 T CreateString(const flatbuffers::String& str) {

extensions/browser/extension_function_histogram_value.h

@@ -1532,6 +1532,7 @@ enum HistogramValue {
   ACCESSIBILITY_PRIVATE_UPDATESWITCHACCESSBUBBLE = 1469,
   TERMINALPRIVATE_OPENOPTIONSPAGE = 1470,
   DECLARATIVENETREQUEST_UPDATEENABLEDRULESETS = 1471,
+  DECLARATIVENETREQUEST_GETENABLEDRULESETS = 1472,
   // Last entry: Add new entries above, then run:
   // python tools/metrics/histograms/update_extension_histograms.py
   ENUM_BOUNDARY

extensions/common/api/declarative_net_request.idl

@@ -368,6 +368,7 @@ namespace declarativeNetRequest {
   callback GetAllowedPagesCallback = void(DOMString[] result);
   callback GetRulesCallback = void(Rule[] rules);
   callback GetMatchedRulesCallback = void(RulesMatchedDetails details);
+  callback GetEnabledRulesetsCallback = void(DOMString[] rulesetIds);
 
   interface Functions {
 
@@ -421,6 +422,13 @@ namespace declarativeNetRequest {
         DOMString[] rulesetIdsToDisable, DOMString[] rulesetIdsToEnable,
         EmptyCallback callback);
 
+    // Returns the ids for the current set of enabled static rulesets.
+    // |callback|: Called with a list of ids, where each id corresponds to an
+    // enabled static $(ref:Ruleset).
+    // TODO(crbug.com/754526): Enable the documentation.
+    [nodoc]
+    static void getEnabledRulesets(GetEnabledRulesetsCallback callback);
+
     // Returns all rules matched for the extension. Callers can optionally
     // filter the list of matched rules by specifying a |filter|. This method is
     // only available to extensions with the

tools/metrics/histograms/enums.xml

@@ -22922,6 +22922,7 @@ Called by update_extension_histograms.py.-->
   <int value="1469" label="ACCESSIBILITY_PRIVATE_UPDATESWITCHACCESSBUBBLE"/>
   <int value="1470" label="TERMINALPRIVATE_OPENOPTIONSPAGE"/>
   <int value="1471" label="DECLARATIVENETREQUEST_UPDATEENABLEDRULESETS"/>
+  <int value="1472" label="DECLARATIVENETREQUEST_GETENABLEDRULESETS"/>
 </enum>
 
 <enum name="ExtensionIconState">