DNR: Add priority to RequestAction and simplify GetRedirectOrUpgradeActionByPriority.

This CL adds the rule priority to RequestAction. This helps us simplify
implementation of GetRedirectOrUpgradeActionByPriority.

Also:
  - Move GetRedirectOrUpgradeActionByPriority from RulesetMatcherInterface to
    RulesetMatcher, since only RulesetMatcher needs it.
  - Change the type of |rule_id| in RequestAction from int to uint32_t since
    that's what is used by url_pattern_index::flat::UrlRule. Any casting to int
    can happen in client code.
  - Improve comments in ruleset_matcher_interface.h and
    extension_url_pattern_index_matcher.h to clarify that we return the highest
    priority redirect and upgrade actions.

This CL does not have any behavior change.

BUG=974391

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

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

@@ -161,7 +161,7 @@ TEST_P(RulesetManagerTest, MultipleRulesets) {
     manager()->EvaluateRequest(request, false /*is_incognito_context*/);
     return !request.dnr_actions->empty() &&
            ((*request.dnr_actions)[0] ==
-            RequestAction(RequestActionType::BLOCK, rule_id,
+            RequestAction(RequestActionType::BLOCK, rule_id, kDefaultPriority,
                           dnr_api::SOURCE_TYPE_MANIFEST, extension_id));
   };
 
@@ -243,7 +243,7 @@ TEST_P(RulesetManagerTest, IncognitoRequests) {
   manager()->EvaluateRequest(request_info, false /*is_incognito_context*/);
   ASSERT_EQ(1u, request_info.dnr_actions->size());
   EXPECT_EQ(RequestAction(RequestActionType::BLOCK, *rule_one.id,
-                          dnr_api::SOURCE_TYPE_MANIFEST,
+                          kDefaultPriority, dnr_api::SOURCE_TYPE_MANIFEST,
                           last_loaded_extension()->id()),
             (*request_info.dnr_actions)[0]);
   request_info.dnr_actions.reset();
@@ -257,7 +257,7 @@ TEST_P(RulesetManagerTest, IncognitoRequests) {
   manager()->EvaluateRequest(request_info, true /*is_incognito_context*/);
   ASSERT_EQ(1u, request_info.dnr_actions->size());
   EXPECT_EQ(RequestAction(RequestActionType::BLOCK, *rule_one.id,
-                          dnr_api::SOURCE_TYPE_MANIFEST,
+                          kDefaultPriority, dnr_api::SOURCE_TYPE_MANIFEST,
                           last_loaded_extension()->id()),
             (*request_info.dnr_actions)[0]);
   request_info.dnr_actions.reset();
@@ -265,7 +265,7 @@ TEST_P(RulesetManagerTest, IncognitoRequests) {
   manager()->EvaluateRequest(request_info, false /*is_incognito_context*/);
   ASSERT_EQ(1u, request_info.dnr_actions->size());
   EXPECT_EQ(RequestAction(RequestActionType::BLOCK, *rule_one.id,
-                          dnr_api::SOURCE_TYPE_MANIFEST,
+                          kDefaultPriority, dnr_api::SOURCE_TYPE_MANIFEST,
                           last_loaded_extension()->id()),
             (*request_info.dnr_actions)[0]);
   request_info.dnr_actions.reset();
@@ -311,7 +311,7 @@ TEST_P(RulesetManagerTest, TotalEvaluationTimeHistogram) {
     manager()->EvaluateRequest(example_com_request, is_incognito_context);
     ASSERT_EQ(1u, example_com_request.dnr_actions->size());
     EXPECT_EQ(RequestAction(RequestActionType::BLOCK, *rule.id,
-                            dnr_api::SOURCE_TYPE_MANIFEST,
+                            kDefaultPriority, dnr_api::SOURCE_TYPE_MANIFEST,
                             last_loaded_extension()->id()),
               (*example_com_request.dnr_actions)[0]);
 
@@ -346,9 +346,9 @@ TEST_P(RulesetManagerTest, Redirect) {
   // redirected to "google.com".
   const bool is_incognito_context = false;
   const char* kExampleURL = "http://example.com";
-  RequestAction expected_redirect_action(RequestActionType::REDIRECT, *rule.id,
-                                         dnr_api::SOURCE_TYPE_MANIFEST,
-                                         last_loaded_extension()->id());
+  RequestAction expected_redirect_action(
+      RequestActionType::REDIRECT, *rule.id, *rule.priority,
+      dnr_api::SOURCE_TYPE_MANIFEST, last_loaded_extension()->id());
   expected_redirect_action.redirect_url = GURL("http://google.com");
   WebRequestInfo request_1(GetRequestParamsForURL(kExampleURL, base::nullopt));
   manager()->EvaluateRequest(request_1, is_incognito_context);
@@ -422,9 +422,10 @@ TEST_P(RulesetManagerTest, ExtensionScheme) {
   WebRequestInfo request_1(GetRequestParamsForURL("http://example.com"));
   manager()->EvaluateRequest(request_1, false /*is_incognito_context*/);
   ASSERT_EQ(1u, request_1.dnr_actions->size());
-  EXPECT_EQ(RequestAction(RequestActionType::BLOCK, kMinValidID,
-                          dnr_api::SOURCE_TYPE_MANIFEST, extension_1->id()),
-            (*request_1.dnr_actions)[0]);
+  EXPECT_EQ(
+      RequestAction(RequestActionType::BLOCK, kMinValidID, kDefaultPriority,
+                    dnr_api::SOURCE_TYPE_MANIFEST, extension_1->id()),
+      (*request_1.dnr_actions)[0]);
 
   // Ensure that the background page for |extension_1| won't be blocked or
   // redirected.
@@ -508,9 +509,9 @@ TEST_P(RulesetManagerTest, RemoveHeaders) {
 
   // Removal of the cookie header should be attributed to |extension_2| because
   // it was installed later than |extension_1| and thus has more priority.
-  RequestAction expected_action_1(RequestActionType::REMOVE_HEADERS,
-                                  kMinValidID, dnr_api::SOURCE_TYPE_MANIFEST,
-                                  extension_2->id());
+  RequestAction expected_action_1(
+      RequestActionType::REMOVE_HEADERS, kMinValidID, kDefaultPriority,
+      dnr_api::SOURCE_TYPE_MANIFEST, extension_2->id());
   expected_action_1.request_headers_to_remove.push_back(
       net::HttpRequestHeaders::kCookie);
 
@@ -518,9 +519,9 @@ TEST_P(RulesetManagerTest, RemoveHeaders) {
   expected_action_1.request_headers_to_remove.push_back(
       net::HttpRequestHeaders::kReferer);
 
-  RequestAction expected_action_2(RequestActionType::REMOVE_HEADERS,
-                                  kMinValidID, dnr_api::SOURCE_TYPE_MANIFEST,
-                                  extension_1->id());
+  RequestAction expected_action_2(
+      RequestActionType::REMOVE_HEADERS, kMinValidID, kDefaultPriority,
+      dnr_api::SOURCE_TYPE_MANIFEST, extension_1->id());
   expected_action_2.response_headers_to_remove.push_back("set-cookie");
 
   EXPECT_EQ(expected_action_1, actual_actions[0]);
@@ -687,7 +688,7 @@ TEST_P(RulesetManagerTest, PageAllowingAPI) {
       ASSERT_EQ(1u, actions.size());
       EXPECT_EQ(
           RequestAction(RequestActionType::BLOCK, *test_case.matched_rule_id,
-                        dnr_api::SOURCE_TYPE_MANIFEST,
+                        kDefaultPriority, dnr_api::SOURCE_TYPE_MANIFEST,
                         last_loaded_extension()->id()),
           actions[0]);
     } else {
@@ -779,9 +780,9 @@ TEST_P(RulesetManagerTest, HostPermissionForInitiator) {
     manager()->AddRuleset(redirect_extension_id, std::move(redirect_matcher),
                           URLPatternSet());
     for (const auto& test : cases) {
-      RequestAction redirect_action(RequestActionType::REDIRECT, kMinValidID,
-                                    dnr_api::SOURCE_TYPE_MANIFEST,
-                                    redirect_extension_id);
+      RequestAction redirect_action(
+          RequestActionType::REDIRECT, kMinValidID, kMinValidPriority,
+          dnr_api::SOURCE_TYPE_MANIFEST, redirect_extension_id);
       redirect_action.redirect_url = GURL("https://foo.com/");
 
       verify_test_case(
@@ -797,9 +798,9 @@ TEST_P(RulesetManagerTest, HostPermissionForInitiator) {
     manager()->AddRuleset(blocking_extension_id, std::move(blocking_matcher),
                           URLPatternSet());
     for (const auto& test : cases) {
-      RequestAction block_action(RequestActionType::BLOCK, kMinValidID,
-                                 dnr_api::SOURCE_TYPE_MANIFEST,
-                                 blocking_extension_id);
+      RequestAction block_action(
+          RequestActionType::BLOCK, kMinValidID, kDefaultPriority,
+          dnr_api::SOURCE_TYPE_MANIFEST, blocking_extension_id);
 
       verify_test_case(
           test.url, test.initiator,

extensions/browser/api/declarative_net_request/composite_matcher_unittest.cc

@@ -266,7 +266,7 @@ TEST_F(CompositeMatcherTest, AllowRuleOverrides) {
 
   RequestAction expected_action = CreateRequestActionForTesting(
       RequestAction::Type::REMOVE_HEADERS, *remove_headers_rule_1.id,
-      dnr_api::SOURCE_TYPE_DYNAMIC);
+      kDefaultPriority, dnr_api::SOURCE_TYPE_DYNAMIC);
   expected_action.request_headers_to_remove.push_back(
       net::HttpRequestHeaders::kReferer);
   expected_action.response_headers_to_remove.push_back("set-cookie");
@@ -347,19 +347,19 @@ TEST_F(CompositeMatcherTest, HeadersMaskForRules) {
   // Static actions are attributed to |matcher_1| and dynamic actions are
   // attributed to |matcher_2|.
   RequestAction static_action_1 = CreateRequestActionForTesting(
-      RequestAction::Type::REMOVE_HEADERS, *static_rule_1.id,
+      RequestAction::Type::REMOVE_HEADERS, *static_rule_1.id, kDefaultPriority,
       dnr_api::SOURCE_TYPE_MANIFEST);
   static_action_1.request_headers_to_remove.push_back(
       net::HttpRequestHeaders::kCookie);
 
   RequestAction dynamic_action_1 = CreateRequestActionForTesting(
-      RequestAction::Type::REMOVE_HEADERS, *dynamic_rule_1.id,
+      RequestAction::Type::REMOVE_HEADERS, *dynamic_rule_1.id, kDefaultPriority,
       dnr_api::SOURCE_TYPE_DYNAMIC);
   dynamic_action_1.request_headers_to_remove.push_back(
       net::HttpRequestHeaders::kReferer);
 
   RequestAction dynamic_action_2 = CreateRequestActionForTesting(
-      RequestAction::Type::REMOVE_HEADERS, *dynamic_rule_2.id,
+      RequestAction::Type::REMOVE_HEADERS, *dynamic_rule_2.id, kDefaultPriority,
       dnr_api::SOURCE_TYPE_DYNAMIC);
   dynamic_action_2.response_headers_to_remove.push_back("set-cookie");
 
@@ -387,7 +387,7 @@ TEST_F(CompositeMatcherTest, HeadersMaskForRules) {
       net::HttpRequestHeaders::kReferer);
 
   RequestAction static_action_2 = CreateRequestActionForTesting(
-      RequestAction::Type::REMOVE_HEADERS, *static_rule_2.id,
+      RequestAction::Type::REMOVE_HEADERS, *static_rule_2.id, kDefaultPriority,
       dnr_api::SOURCE_TYPE_MANIFEST);
   static_action_2.response_headers_to_remove.push_back("set-cookie");
 

extensions/browser/api/declarative_net_request/extension_url_pattern_index_matcher.cc

@@ -254,10 +254,11 @@ GURL GetUpgradedUrl(const GURL& url) {
 // Populates the list of headers corresponding to |mask|.
 RequestAction GetRemoveHeadersActionForMask(const ExtensionId& extension_id,
                                             uint8_t mask,
-                                            int rule_id,
+                                            uint32_t rule_id,
+                                            uint32_t rule_priority,
                                             dnr_api::SourceType source_type) {
   RequestAction action(RequestAction::Type::REMOVE_HEADERS, rule_id,
-                       source_type, extension_id);
+                       rule_priority, source_type, extension_id);
 
   for (int i = 0; mask && i <= dnr_api::REMOVE_HEADER_TYPE_LAST; ++i) {
     switch (i) {
@@ -308,9 +309,9 @@ ExtensionUrlPatternIndexMatcher::GetBlockOrCollapseAction(
 
   return ShouldCollapseResourceType(params.element_type)
              ? RequestAction(RequestAction::Type::COLLAPSE, rule->id(),
-                             source_type(), extension_id())
+                             rule->priority(), source_type(), extension_id())
              : RequestAction(RequestAction::Type::BLOCK, rule->id(),
-                             source_type(), extension_id());
+                             rule->priority(), source_type(), extension_id());
 }
 
 bool ExtensionUrlPatternIndexMatcher::HasMatchingAllowRule(
@@ -329,8 +330,8 @@ ExtensionUrlPatternIndexMatcher::GetRedirectAction(
     return base::nullopt;
 
   RequestAction redirect_action(RequestAction::Type::REDIRECT,
-                                redirect_rule->id(), source_type(),
-                                extension_id());
+                                redirect_rule->id(), redirect_rule->priority(),
+                                source_type(), extension_id());
   redirect_action.redirect_url = std::move(redirect_rule_url);
 
   return redirect_action;
@@ -344,51 +345,13 @@ base::Optional<RequestAction> ExtensionUrlPatternIndexMatcher::GetUpgradeAction(
     return base::nullopt;
 
   RequestAction upgrade_action(RequestAction::Type::REDIRECT,
-                               upgrade_rule->id(), source_type(),
-                               extension_id());
+                               upgrade_rule->id(), upgrade_rule->priority(),
+                               source_type(), extension_id());
   upgrade_action.redirect_url = GetUpgradedUrl(*params.url);
 
   return upgrade_action;
 }
 
-base::Optional<RequestAction>
-ExtensionUrlPatternIndexMatcher::GetRedirectOrUpgradeActionByPriority(
-    const RequestParams& params) const {
-  GURL redirect_rule_url;
-  const flat_rule::UrlRule* redirect_rule =
-      GetRedirectRule(params, &redirect_rule_url);
-  const flat_rule::UrlRule* upgrade_rule = GetUpgradeRule(params);
-
-  if (!redirect_rule && !upgrade_rule)
-    return base::nullopt;
-
-  GURL highest_priority_url;
-  int rule_id = kMinValidID - 1;
-  if (!upgrade_rule) {
-    highest_priority_url = std::move(redirect_rule_url);
-    rule_id = redirect_rule->id();
-  } else if (!redirect_rule) {
-    highest_priority_url = GetUpgradedUrl(*params.url);
-    rule_id = upgrade_rule->id();
-  } else {
-    highest_priority_url = upgrade_rule->priority() > redirect_rule->priority()
-                               ? GetUpgradedUrl(*params.url)
-                               : std::move(redirect_rule_url);
-
-    rule_id = upgrade_rule->priority() > redirect_rule->priority()
-                  ? upgrade_rule->id()
-                  : redirect_rule->id();
-  }
-
-  DCHECK_GE(rule_id, kMinValidID);
-
-  RequestAction action(RequestAction::Type::REDIRECT, rule_id, source_type(),
-                       extension_id());
-  action.redirect_url = std::move(highest_priority_url);
-
-  return action;
-}
-
 uint8_t ExtensionUrlPatternIndexMatcher::GetRemoveHeadersMask(
     const RequestParams& params,
     uint8_t ignored_mask,
@@ -439,11 +402,14 @@ uint8_t ExtensionUrlPatternIndexMatcher::GetRemoveHeadersMask(
     }
   }
 
+  // Rule priority doesn't matter for remove header rules.
+  uint32_t rule_priority = kDefaultPriority;
   for (auto it = rule_id_to_mask.begin(); it != rule_id_to_mask.end(); ++it) {
     uint8_t mask_for_rule = it->second;
     DCHECK(mask_for_rule);
     remove_headers_actions->push_back(GetRemoveHeadersActionForMask(
-        extension_id(), mask_for_rule, it->first /* rule_id */, source_type()));
+        extension_id(), mask_for_rule, it->first /* rule_id */, rule_priority,
+        source_type()));
   }
 
   DCHECK(!(mask & ignored_mask));

extensions/browser/api/declarative_net_request/extension_url_pattern_index_matcher.h

@@ -39,8 +39,6 @@ class ExtensionUrlPatternIndexMatcher final : public RulesetMatcherInterface {
       const RequestParams& params) const override;
   base::Optional<RequestAction> GetUpgradeAction(
       const RequestParams& params) const override;
-  base::Optional<RequestAction> GetRedirectOrUpgradeActionByPriority(
-      const RequestParams& params) const override;
   uint8_t GetRemoveHeadersMask(
       const RequestParams& params,
       uint8_t ignored_mask,
@@ -56,15 +54,15 @@ class ExtensionUrlPatternIndexMatcher final : public RulesetMatcherInterface {
  private:
   using UrlPatternIndexMatcher = url_pattern_index::UrlPatternIndexMatcher;
 
-  // Returns the ruleset's matching redirect rule and populates
-  // |redirect_url| if there is a matching redirect rule, otherwise returns
-  // nullptr.
+  // Returns the ruleset's highest priority matching redirect rule and populates
+  // |redirect_url|. Returns nullptr if there is no matching redirect rule.
   const url_pattern_index::flat::UrlRule* GetRedirectRule(
       const RequestParams& params,
       GURL* redirect_url) const;
 
-  // Returns the ruleset's matching upgrade scheme rule or nullptr if no
-  // matching rule is found or if the request's scheme is not upgradeable.
+  // Returns the ruleset's highest priority matching upgrade scheme rule or
+  // nullptr if no matching rule is found or if the request's scheme is not
+  // upgradeable.
   const url_pattern_index::flat::UrlRule* GetUpgradeRule(
       const RequestParams& params) const;
 

extensions/browser/api/declarative_net_request/request_action.cc

@@ -9,11 +9,13 @@ namespace declarative_net_request {
 
 RequestAction::RequestAction(
     RequestAction::Type type,
-    int rule_id,
+    uint32_t rule_id,
+    uint32_t rule_priority,
     api::declarative_net_request::SourceType source_type,
     const ExtensionId& extension_id)
     : type(type),
       rule_id(rule_id),
+      rule_priority(rule_priority),
       source_type(source_type),
       extension_id(extension_id) {}
 RequestAction::~RequestAction() = default;

extensions/browser/api/declarative_net_request/request_action.h

@@ -5,7 +5,7 @@
 #ifndef EXTENSIONS_BROWSER_API_DECLARATIVE_NET_REQUEST_REQUEST_ACTION_H_
 #define EXTENSIONS_BROWSER_API_DECLARATIVE_NET_REQUEST_REQUEST_ACTION_H_
 
-#include <stddef.h>
+#include <cstdint>
 #include <vector>
 
 #include "base/macros.h"
@@ -32,7 +32,8 @@ struct RequestAction {
   };
 
   RequestAction(Type type,
-                int rule_id,
+                uint32_t rule_id,
+                uint32_t rule_priority,
                 api::declarative_net_request::SourceType source_type,
                 const ExtensionId& extension_id);
   ~RequestAction();
@@ -45,7 +46,11 @@ struct RequestAction {
   base::Optional<GURL> redirect_url;
 
   // The ID of the matching rule for this action.
-  int rule_id;
+  uint32_t rule_id;
+
+  // The priority of the matching rule for this action. Only really valid for
+  // redirect actions.
+  uint32_t rule_priority;
 
   // The source type of the matching rule for this action.
   api::declarative_net_request::SourceType source_type;

extensions/browser/api/declarative_net_request/ruleset_matcher.cc

@@ -82,13 +82,6 @@ base::Optional<RequestAction> RulesetMatcher::GetUpgradeAction(
   return url_pattern_index_matcher_.GetUpgradeAction(params);
 }
 
-base::Optional<RequestAction>
-RulesetMatcher::GetRedirectOrUpgradeActionByPriority(
-    const RequestParams& params) const {
-  return url_pattern_index_matcher_.GetRedirectOrUpgradeActionByPriority(
-      params);
-}
-
 uint8_t RulesetMatcher::GetRemoveHeadersMask(
     const RequestParams& params,
     uint8_t ignored_mask,
@@ -101,6 +94,21 @@ bool RulesetMatcher::IsExtraHeadersMatcher() const {
   return url_pattern_index_matcher_.IsExtraHeadersMatcher();
 }
 
+base::Optional<RequestAction>
+RulesetMatcher::GetRedirectOrUpgradeActionByPriority(
+    const RequestParams& params) const {
+  base::Optional<RequestAction> redirect_action = GetRedirectAction(params);
+  base::Optional<RequestAction> upgrade_action = GetUpgradeAction(params);
+
+  if (!redirect_action)
+    return upgrade_action;
+  if (!upgrade_action)
+    return redirect_action;
+  if (upgrade_action->rule_priority >= redirect_action->rule_priority)
+    return upgrade_action;
+  return redirect_action;
+}
+
 RulesetMatcher::RulesetMatcher(
     std::string ruleset_data,
     size_t id,

extensions/browser/api/declarative_net_request/ruleset_matcher.h

@@ -73,8 +73,6 @@ class RulesetMatcher : public RulesetMatcherInterface {
       const RequestParams& params) const override;
   base::Optional<RequestAction> GetUpgradeAction(
       const RequestParams& params) const override;
-  base::Optional<RequestAction> GetRedirectOrUpgradeActionByPriority(
-      const RequestParams& params) const override;
   uint8_t GetRemoveHeadersMask(
       const RequestParams& params,
       uint8_t ignored_mask,
@@ -85,6 +83,12 @@ class RulesetMatcher : public RulesetMatcherInterface {
     return source_type_;
   }
 
+  // Returns a RequestAction constructed from the matching redirect or upgrade
+  // rule with the highest priority, or base::nullopt if no matching redirect or
+  // upgrade rules are found for this request.
+  base::Optional<RequestAction> GetRedirectOrUpgradeActionByPriority(
+      const RequestParams& params) const;
+
   // ID of the ruleset. Each extension can have multiple rulesets with
   // their own unique ids.
   size_t id() const { return id_; }

extensions/browser/api/declarative_net_request/ruleset_matcher_interface.h

@@ -31,23 +31,18 @@ class RulesetMatcherInterface {
   // Returns whether the ruleset has a matching allow rule.
   virtual bool HasMatchingAllowRule(const RequestParams& params) const = 0;
 
-  // Returns the ruleset's matching redirect RequestAction if there is a
-  // matching redirect rule, otherwise returns base::nullopt.
+  // Returns a RequestAction constructed from the matching redirect rule with
+  // the highest priority, or base::nullopt if no matching redirect rules are
+  // found for this request.
   virtual base::Optional<RequestAction> GetRedirectAction(
       const RequestParams& params) const = 0;
 
-  // Returns the ruleset's matching RequestAction with |params.url| upgraded to
-  // HTTPS as the redirect url, or base::nullopt if no matching rule is found or
-  // if the request's scheme is not upgradeable.
+  // Returns a RequestAction constructed from the matching upgrade rule with the
+  // highest priority, or base::nullopt if no matching upgrade rules are found
+  // for this request.
   virtual base::Optional<RequestAction> GetUpgradeAction(
       const RequestParams& params) const = 0;
 
-  // Returns a RedirectAction constructed from the matching redirect or upgrade
-  // rule with the highest priority, or base::nullopt if no matching redirect or
-  // upgrade rules are found for this request.
-  virtual base::Optional<RequestAction> GetRedirectOrUpgradeActionByPriority(
-      const RequestParams& params) const = 0;
-
   // Returns the bitmask of headers to remove from the request. The bitmask
   // corresponds to RemoveHeadersMask type. |ignored_mask| denotes the mask of
   // headers to be skipped for evaluation and is excluded in the return value.

extensions/browser/api/declarative_net_request/test_utils.cc

@@ -26,10 +26,11 @@ namespace declarative_net_request {
 namespace dnr_api = api::declarative_net_request;
 
 RequestAction CreateRequestActionForTesting(RequestAction::Type type,
-                                            int rule_id,
+                                            uint32_t rule_id,
+                                            uint32_t rule_priority,
                                             dnr_api::SourceType source_type,
                                             const ExtensionId& extension_id) {
-  return RequestAction(type, rule_id, source_type, extension_id);
+  return RequestAction(type, rule_id, rule_priority, source_type, extension_id);
 }
 
 // Note: This is not declared in the anonymous namespace so that we can use it
@@ -48,7 +49,8 @@ bool operator==(const RequestAction& lhs, const RequestAction& rhs) {
 
   auto get_members_tuple = [](const RequestAction& action) {
     return std::tie(action.type, action.redirect_url, action.rule_id,
-                    action.source_type, action.extension_id);
+                    action.rule_priority, action.source_type,
+                    action.extension_id);
   };
 
   return get_members_tuple(lhs) == get_members_tuple(rhs) &&
@@ -84,6 +86,7 @@ std::ostream& operator<<(std::ostream& output, const RequestAction& action) {
                                  : std::string("nullopt"))
          << "\n";
   output << "|rule_id| " << action.rule_id << "\n";
+  output << "|rule_priority| " << action.rule_priority << "\n";
   output << "|source_type| "
          << api::declarative_net_request::ToString(action.source_type) << "\n";
   output << "|extension_id| " << action.extension_id << "\n";

extensions/browser/api/declarative_net_request/test_utils.h

@@ -38,7 +38,8 @@ enum class ExtensionLoadType {
 // optionally, an ExtensionId.
 RequestAction CreateRequestActionForTesting(
     RequestAction::Type type,
-    int rule_id = kMinValidID,
+    uint32_t rule_id = kMinValidID,
+    uint32_t rule_priority = kDefaultPriority,
     api::declarative_net_request::SourceType source_type =
         api::declarative_net_request::SOURCE_TYPE_MANIFEST,
     const ExtensionId& extension_id = "extensionid");