[M123]Add split logic with feature flag controlled.

Split the queued requests to smaller BatchedTrustedSignalsRequest by
precheck URL length with limit in each request for both trusted bidder
and seller signals update.

Use a feature flag kFledgeSplitTrustedSignalsFetchingURL to control it,
which is disabled by default.

Github: WICG/turtledove#767

(cherry picked from https://chromium-review.googlesource.com/c/chromium/src/+/5277387 commit 72e20be)

(cherry picked from commit 72e20be)

Bug: 324416012
Change-Id: I92b7077ae9e4b837ee65fb9fc0fc26b02a153b7e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/5277387
Reviewed-by: mmenke <mmenke@chromium.org>
Reviewed-by: Dominic Farolino <dom@chromium.org>
Commit-Queue: Tianyang Xu <xtlsheep@google.com>
Cr-Original-Commit-Position: refs/heads/main@{#1264576}
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/5321213
Commit-Queue: Krishna Govind <govind@chromium.org>
Bot-Commit: Rubber Stamper <rubber-stamper@appspot.gserviceaccount.com>
Cr-Commit-Position: refs/branch-heads/6312@{#188}
Cr-Branched-From: 6711dcd-refs/heads/main@{#1262506}

content/services/auction_worklet/bidder_worklet.cc

@@ -365,10 +365,12 @@ void BidderWorklet::BeginGenerateBid(
   TRACE_EVENT_NESTABLE_ASYNC_BEGIN0("fledge", "wait_generate_bid_deps",
                                     trace_id);
   if (trusted_signals_request_manager_) {
+    // Pass 0 as hardcoded `max_trusted_bidding_signals_url_length` for feature
+    // initializing.
     generate_bid_task->trusted_bidding_signals_request =
         trusted_signals_request_manager_->RequestBiddingSignals(
             generate_bid_task->bidder_worklet_non_shared_params->name,
-            trusted_bidding_signals_keys,
+            trusted_bidding_signals_keys, 0,
             base::BindOnce(&BidderWorklet::OnTrustedBiddingSignalsDownloaded,
                            base::Unretained(this), generate_bid_task));
     return;

content/services/auction_worklet/seller_worklet.cc

@@ -759,10 +759,12 @@ void SellerWorklet::ScoreAd(
   // If `trusted_signals_request_manager_` exists, there's a trusted scoring
   // signals URL which needs to be fetched before the auction can be run.
   if (trusted_signals_request_manager_) {
+    // Pass 0 as hardcoded `max_trusted_scoring_signals_url_length` for feature
+    // initializing.
     score_ad_task->trusted_scoring_signals_request =
         trusted_signals_request_manager_->RequestScoringSignals(
             browser_signal_render_url,
-            score_ad_task->browser_signal_ad_components,
+            score_ad_task->browser_signal_ad_components, 0,
             base::BindOnce(&SellerWorklet::OnTrustedScoringSignalsDownloaded,
                            base::Unretained(this), score_ad_task));
     return;

content/services/auction_worklet/trusted_signals.cc

@@ -347,6 +347,55 @@ v8::Local<v8::Object> TrustedSignals::Result::GetScoringSignals(
 
 TrustedSignals::Result::~Result() = default;
 
+GURL TrustedSignals::BuildTrustedBiddingSignalsURL(
+    const std::string& hostname,
+    const GURL& trusted_bidding_signals_url,
+    const std::set<std::string>& interest_group_names,
+    const std::set<std::string>& bidding_signals_keys,
+    std::optional<uint16_t> experiment_group_id,
+    const std::string& trusted_bidding_signals_slot_size_param) {
+  std::string query_params = base::StrCat(
+      {"hostname=", base::EscapeQueryParamValue(hostname, /*use_plus=*/true),
+       CreateQueryParam("keys", bidding_signals_keys),
+       CreateQueryParam("interestGroupNames", interest_group_names)});
+
+  if (experiment_group_id.has_value()) {
+    base::StrAppend(&query_params,
+                    {"&experimentGroupId=",
+                     base::NumberToString(experiment_group_id.value())});
+  }
+  if (!trusted_bidding_signals_slot_size_param.empty()) {
+    base::StrAppend(&query_params,
+                    {"&", trusted_bidding_signals_slot_size_param});
+  }
+  GURL full_signals_url =
+      SetQueryParam(trusted_bidding_signals_url, query_params);
+
+  return full_signals_url;
+}
+
+GURL TrustedSignals::BuildTrustedScoringSignalsURL(
+    const std::string& hostname,
+    const GURL& trusted_scoring_signals_url,
+    const std::set<std::string>& render_urls,
+    const std::set<std::string>& ad_component_render_urls,
+    std::optional<uint16_t> experiment_group_id) {
+  // TODO(crbug.com/1432707): Find a way to rename renderUrls to renderURLs.
+  std::string query_params = base::StrCat(
+      {"hostname=", base::EscapeQueryParamValue(hostname, /*use_plus=*/true),
+       CreateQueryParam("renderUrls", render_urls),
+       CreateQueryParam("adComponentRenderUrls", ad_component_render_urls)});
+  if (experiment_group_id.has_value()) {
+    base::StrAppend(&query_params,
+                    {"&experimentGroupId=",
+                     base::NumberToString(experiment_group_id.value())});
+  }
+  GURL full_signals_url =
+      SetQueryParam(trusted_scoring_signals_url, query_params);
+
+  return full_signals_url;
+}
+
 std::unique_ptr<TrustedSignals> TrustedSignals::LoadBiddingSignals(
     network::mojom::URLLoaderFactory* url_loader_factory,
     mojo::PendingRemote<auction_worklet::mojom::AuctionNetworkEventsHandler>
@@ -361,6 +410,11 @@ std::unique_ptr<TrustedSignals> TrustedSignals::LoadBiddingSignals(
     LoadSignalsCallback load_signals_callback) {
   DCHECK(!interest_group_names.empty());
 
+  GURL full_signals_url = TrustedSignals::BuildTrustedBiddingSignalsURL(
+      hostname, trusted_bidding_signals_url, interest_group_names,
+      bidding_signals_keys, experiment_group_id,
+      trusted_bidding_signals_slot_size_param);
+
   std::unique_ptr<TrustedSignals> trusted_signals =
       base::WrapUnique(new TrustedSignals(
           std::move(interest_group_names), std::move(bidding_signals_keys),
@@ -369,22 +423,6 @@ std::unique_ptr<TrustedSignals> TrustedSignals::LoadBiddingSignals(
           trusted_bidding_signals_url, std::move(devtools_pending_remote),
           std::move(v8_helper), std::move(load_signals_callback)));
 
-  std::string query_params = base::StrCat(
-      {"hostname=", base::EscapeQueryParamValue(hostname, /*use_plus=*/true),
-       CreateQueryParam("keys", *trusted_signals->bidding_signals_keys_),
-       CreateQueryParam("interestGroupNames",
-                        *trusted_signals->interest_group_names_)});
-  if (experiment_group_id.has_value()) {
-    base::StrAppend(&query_params,
-                    {"&experimentGroupId=",
-                     base::NumberToString(experiment_group_id.value())});
-  }
-  if (!trusted_bidding_signals_slot_size_param.empty()) {
-    base::StrAppend(&query_params,
-                    {"&", trusted_bidding_signals_slot_size_param});
-  }
-  GURL full_signals_url =
-      SetQueryParam(trusted_bidding_signals_url, query_params);
   base::UmaHistogramCounts100000(
       "Ads.InterestGroup.Net.RequestUrlSizeBytes.TrustedBidding",
       full_signals_url.spec().size());
@@ -406,6 +444,10 @@ std::unique_ptr<TrustedSignals> TrustedSignals::LoadScoringSignals(
     LoadSignalsCallback load_signals_callback) {
   DCHECK(!render_urls.empty());
 
+  GURL full_signals_url = BuildTrustedScoringSignalsURL(
+      hostname, trusted_scoring_signals_url, render_urls,
+      ad_component_render_urls, experiment_group_id);
+
   std::unique_ptr<TrustedSignals> trusted_signals =
       base::WrapUnique(new TrustedSignals(
           /*interest_group_names=*/std::nullopt,
@@ -414,19 +456,6 @@ std::unique_ptr<TrustedSignals> TrustedSignals::LoadScoringSignals(
           std::move(auction_network_events_handler), std::move(v8_helper),
           std::move(load_signals_callback)));
 
-  // TODO(crbug.com/1432707): Find a way to rename renderUrls to renderURLs.
-  std::string query_params = base::StrCat(
-      {"hostname=", base::EscapeQueryParamValue(hostname, /*use_plus=*/true),
-       CreateQueryParam("renderUrls", *trusted_signals->render_urls_),
-       CreateQueryParam("adComponentRenderUrls",
-                        *trusted_signals->ad_component_render_urls_)});
-  if (experiment_group_id.has_value()) {
-    base::StrAppend(&query_params,
-                    {"&experimentGroupId=",
-                     base::NumberToString(experiment_group_id.value())});
-  }
-  GURL full_signals_url =
-      SetQueryParam(trusted_scoring_signals_url, query_params);
   base::UmaHistogramCounts100000(
       "Ads.InterestGroup.Net.RequestUrlSizeBytes.TrustedScoring",
       full_signals_url.spec().size());

content/services/auction_worklet/trusted_signals.h

@@ -129,17 +129,32 @@ class CONTENT_EXPORT TrustedSignals {
   TrustedSignals& operator=(const TrustedSignals&) = delete;
   ~TrustedSignals();
 
-  // Constructs a TrustedSignals for fetching bidding signals, and starts the
-  // fetch. `trusted_bidding_signals_url` must be the base URL (no query params
-  // added).  Callback will be invoked asynchronously once the data has been
-  // fetched or an error has occurred. De-duplicates keys when assembling the
-  // full URL for the fetch. Fails if the URL already has a query param (or has
-  // a location or embedded credentials) or if the response is not JSON. If some
-  // or all of the render URLs are missing, still succeeds, and GetSignals()
-  // will populate them with nulls.
+  static GURL BuildTrustedBiddingSignalsURL(
+      const std::string& hostname,
+      const GURL& trusted_bidding_signals_url,
+      const std::set<std::string>& interest_group_names,
+      const std::set<std::string>& bidding_signals_keys,
+      std::optional<uint16_t> experiment_group_id,
+      const std::string& trusted_bidding_signals_slot_size_param);
+
+  static GURL BuildTrustedScoringSignalsURL(
+      const std::string& hostname,
+      const GURL& trusted_scoring_signals_url,
+      const std::set<std::string>& render_urls,
+      const std::set<std::string>& ad_component_render_urls,
+      std::optional<uint16_t> experiment_group_id);
+
+  // Constructs a TrustedSignals for fetching bidding signals, and starts
+  // the fetch. `trusted_bidding_signals_url` must be the base URL (no query
+  // params added).  Callback will be invoked asynchronously once the data
+  // has been fetched or an error has occurred. De-duplicates keys when
+  // assembling the full URL for the fetch. Fails if the URL already has a
+  // query param (or has a location or embedded credentials) or if the
+  // response is not JSON. If some or all of the render URLs are missing,
+  // still succeeds, and GetSignals() will populate them with nulls.
   //
-  // If non-empty, "&`trusted_bidding_signals_slot_size_param`" is appended to
-  // the end of the query string. It's expected to already be escaped if
+  // If non-empty, "&`trusted_bidding_signals_slot_size_param`" is appended
+  // to the end of the query string. It's expected to already be escaped if
   // necessary.
   //
   // There are no lifetime constraints of `url_loader_factory`.