[FLEDGE] Use a single TrustedSignals class for bidder and seller signals

This will make it easier to use a single class to batch and cache
requests of both types.

Bug: 1276639
Change-Id: Ic811c330efa57d65eeb45352c23ab26c979123a9
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3315923
Reviewed-by: Maks Orlovich <morlovich@chromium.org>
Commit-Queue: Matt Menke <mmenke@chromium.org>
Cr-Commit-Position: refs/heads/main@{#949628}

content/services/auction_worklet/BUILD.gn

@@ -57,10 +57,8 @@ source_set("auction_worklet") {
     "report_bindings.h",
     "seller_worklet.cc",
     "seller_worklet.h",
-    "trusted_bidding_signals.cc",
-    "trusted_bidding_signals.h",
-    "trusted_scoring_signals.cc",
-    "trusted_scoring_signals.h",
+    "trusted_signals.cc",
+    "trusted_signals.h",
     "worklet_loader.cc",
     "worklet_loader.h",
   ]
@@ -98,8 +96,7 @@ source_set("tests") {
     "bidder_worklet_unittest.cc",
     "debug_command_queue_unittest.cc",
     "seller_worklet_unittest.cc",
-    "trusted_bidding_signals_unittest.cc",
-    "trusted_scoring_signals_unittest.cc",
+    "trusted_signals_unittest.cc",
     "worklet_devtools_debug_test_util.cc",
     "worklet_devtools_debug_test_util.h",
     "worklet_loader_unittest.cc",

content/services/auction_worklet/bidder_worklet.cc

@@ -21,7 +21,7 @@
 #include "content/services/auction_worklet/auction_v8_helper.h"
 #include "content/services/auction_worklet/public/mojom/auction_worklet_service.mojom.h"
 #include "content/services/auction_worklet/report_bindings.h"
-#include "content/services/auction_worklet/trusted_bidding_signals.h"
+#include "content/services/auction_worklet/trusted_signals.h"
 #include "content/services/auction_worklet/worklet_loader.h"
 #include "gin/converter.h"
 #include "gin/dictionary.h"
@@ -223,7 +223,7 @@ void BidderWorklet::GenerateBid(
       trusted_bidding_signals_keys_.has_value() &&
       !trusted_bidding_signals_keys_->empty()) {
     generate_bid_task->trusted_bidding_signals =
-        std::make_unique<TrustedBiddingSignals>(
+        TrustedSignals::LoadBiddingSignals(
             url_loader_factory_.get(), *trusted_bidding_signals_keys_,
             top_window_origin.host(), *trusted_bidding_signals_url_, v8_helper_,
             base::BindOnce(&BidderWorklet::OnTrustedBiddingSignalsDownloaded,
@@ -386,8 +386,7 @@ void BidderWorklet::V8State::GenerateBid(
     const url::Origin& browser_signal_top_window_origin,
     const url::Origin& browser_signal_seller_origin,
     base::Time auction_start_time,
-    std::unique_ptr<TrustedBiddingSignals::Result>
-        trusted_bidding_signals_result,
+    std::unique_ptr<TrustedSignals::Result> trusted_bidding_signals_result,
     GenerateBidCallbackInternal callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(v8_sequence_checker_);
 
@@ -452,7 +451,7 @@ void BidderWorklet::V8State::GenerateBid(
   if (!trusted_bidding_signals_result) {
     trusted_signals = v8::Null(isolate);
   } else {
-    trusted_signals = trusted_bidding_signals_result->GetSignals(
+    trusted_signals = trusted_bidding_signals_result->GetBiddingSignals(
         v8_helper_.get(), context,
         *interest_group.trusted_bidding_signals_keys);
   }
@@ -718,12 +717,12 @@ void BidderWorklet::OnScriptDownloaded(WorkletLoader::Result worklet_script,
 
 void BidderWorklet::OnTrustedBiddingSignalsDownloaded(
     GenerateBidTaskList::iterator task,
-    std::unique_ptr<TrustedBiddingSignals::Result> result,
+    std::unique_ptr<TrustedSignals::Result> result,
     absl::optional<std::string> error_msg) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(user_sequence_checker_);
 
   task->trusted_bidding_signals_error_msg = std::move(error_msg);
-  task->trusted_Bidding_signals_result = std::move(result);
+  task->trusted_bidding_signals_result = std::move(result);
   task->trusted_bidding_signals.reset();
 
   GenerateBidIfReady(task);
@@ -741,7 +740,7 @@ void BidderWorklet::GenerateBidIfReady(GenerateBidTaskList::iterator task) {
           base::Unretained(v8_state_.get()), task->auction_signals_json,
           task->per_buyer_signals_json, task->top_window_origin,
           task->seller_origin, task->auction_start_time,
-          std::move(task->trusted_Bidding_signals_result),
+          std::move(task->trusted_bidding_signals_result),
           base::BindOnce(&BidderWorklet::DeliverBidCallbackOnUserThread,
                          weak_ptr_factory_.GetWeakPtr(), task)));
 }

content/services/auction_worklet/bidder_worklet.h

@@ -18,7 +18,7 @@
 #include "content/services/auction_worklet/auction_v8_helper.h"
 #include "content/services/auction_worklet/public/mojom/auction_worklet_service.mojom.h"
 #include "content/services/auction_worklet/public/mojom/bidder_worklet.mojom.h"
-#include "content/services/auction_worklet/trusted_bidding_signals.h"
+#include "content/services/auction_worklet/trusted_signals.h"
 #include "content/services/auction_worklet/worklet_loader.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
 #include "mojo/public/cpp/bindings/remote.h"
@@ -100,10 +100,9 @@ class BidderWorklet : public mojom::BidderWorklet {
     base::Time auction_start_time;
 
     // Set while loading is in progress.
-    std::unique_ptr<TrustedBiddingSignals> trusted_bidding_signals;
+    std::unique_ptr<TrustedSignals> trusted_bidding_signals;
     // Results of loading trusted bidding signals.
-    std::unique_ptr<TrustedBiddingSignals::Result>
-        trusted_Bidding_signals_result;
+    std::unique_ptr<TrustedSignals::Result> trusted_bidding_signals_result;
     // Error message returned by attempt to load `trusted_bidding_signals_`.
     // Errors loading it are not fatal, so such errors are cached here and only
     // reported on bid completion.
@@ -160,14 +159,14 @@ class BidderWorklet : public mojom::BidderWorklet {
                    double browser_signal_bid,
                    ReportWinCallbackInternal callback);
 
-    void GenerateBid(const absl::optional<std::string>& auction_signals_json,
-                     const absl::optional<std::string>& per_buyer_signals_json,
-                     const url::Origin& browser_signal_top_window_origin,
-                     const url::Origin& browser_signal_seller_origin,
-                     base::Time auction_start_time,
-                     std::unique_ptr<TrustedBiddingSignals::Result>
-                         trusted_bidding_signals_result,
-                     GenerateBidCallbackInternal callback);
+    void GenerateBid(
+        const absl::optional<std::string>& auction_signals_json,
+        const absl::optional<std::string>& per_buyer_signals_json,
+        const url::Origin& browser_signal_top_window_origin,
+        const url::Origin& browser_signal_seller_origin,
+        base::Time auction_start_time,
+        std::unique_ptr<TrustedSignals::Result> trusted_bidding_signals_result,
+        GenerateBidCallbackInternal callback);
 
     void ConnectDevToolsAgent(
         mojo::PendingReceiver<blink::mojom::DevToolsAgent> agent);
@@ -214,11 +213,11 @@ class BidderWorklet : public mojom::BidderWorklet {
 
   void OnTrustedBiddingSignalsDownloaded(
       GenerateBidTaskList::iterator task,
-      std::unique_ptr<TrustedBiddingSignals::Result> result,
+      std::unique_ptr<TrustedSignals::Result> result,
       absl::optional<std::string> error_msg);
 
   // Checks if the script has been loaded successfully, and the
-  // TrustedBiddingSignals load has finished (successfully or not). If so, calls
+  // TrustedSignals load has finished (successfully or not). If so, calls
   // generateBid(), and invokes `load_script_and_generate_bid_callback_` with
   // the resulting bid, if any. May only be called once BidderWorklet has
   // successfully loaded.

content/services/auction_worklet/seller_worklet.cc

@@ -19,7 +19,7 @@
 #include "content/services/auction_worklet/public/mojom/auction_worklet_service.mojom.h"
 #include "content/services/auction_worklet/public/mojom/seller_worklet.mojom.h"
 #include "content/services/auction_worklet/report_bindings.h"
-#include "content/services/auction_worklet/trusted_scoring_signals.h"
+#include "content/services/auction_worklet/trusted_signals.h"
 #include "content/services/auction_worklet/worklet_loader.h"
 #include "gin/converter.h"
 #include "gin/dictionary.h"
@@ -180,25 +180,23 @@ void SellerWorklet::ScoreAd(
   score_ad_task->browser_signal_interest_group_owner =
       browser_signal_interest_group_owner;
   score_ad_task->browser_signal_render_url = browser_signal_render_url;
-  score_ad_task->browser_signal_ad_components = browser_signal_ad_components;
+  for (const GURL& url : browser_signal_ad_components) {
+    score_ad_task->browser_signal_ad_components.emplace_back(url.spec());
+  }
   score_ad_task->browser_signal_bidding_duration_msecs =
       browser_signal_bidding_duration_msecs;
   score_ad_task->callback = std::move(callback);
 
-  std::set<GURL> ad_component_render_urls(browser_signal_ad_components.begin(),
-                                          browser_signal_ad_components.end());
-
   if (score_ad_task->auction_config->trusted_scoring_signals_url) {
-    score_ad_task->trusted_scoring_signals =
-        std::make_unique<TrustedScoringSignals>(
-            url_loader_factory_.get(),
-            /*render_urls=*/std::set<GURL>{browser_signal_render_url},
-            std::move(ad_component_render_urls),
-            browser_signal_top_window_origin.host(),
-            *score_ad_task->auction_config->trusted_scoring_signals_url,
-            v8_helper_,
-            base::BindOnce(&SellerWorklet::OnTrustedScoringSignalsDownloaded,
-                           base::Unretained(this), score_ad_task));
+    score_ad_task->trusted_scoring_signals = TrustedSignals::LoadScoringSignals(
+        url_loader_factory_.get(),
+        /*render_urls=*/
+        std::vector<std::string>{browser_signal_render_url.spec()},
+        score_ad_task->browser_signal_ad_components,
+        browser_signal_top_window_origin.host(),
+        *score_ad_task->auction_config->trusted_scoring_signals_url, v8_helper_,
+        base::BindOnce(&SellerWorklet::OnTrustedScoringSignalsDownloaded,
+                       base::Unretained(this), score_ad_task));
     return;
   }
 
@@ -262,11 +260,11 @@ void SellerWorklet::V8State::ScoreAd(
     const std::string& ad_metadata_json,
     double bid,
     blink::mojom::AuctionAdConfigPtr auction_config,
-    std::unique_ptr<TrustedScoringSignals::Result> trusted_scoring_signals,
+    std::unique_ptr<TrustedSignals::Result> trusted_scoring_signals,
     const url::Origin& browser_signal_top_window_origin,
     const url::Origin& browser_signal_interest_group_owner,
     const GURL& browser_signal_render_url,
-    const std::vector<GURL>& browser_signal_ad_components,
+    const std::vector<std::string>& browser_signal_ad_components,
     uint32_t browser_signal_bidding_duration_msecs,
     ScoreAdCallbackInternal callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(v8_sequence_checker_);
@@ -295,15 +293,9 @@ void SellerWorklet::V8State::ScoreAd(
 
   v8::Local<v8::Value> trusted_scoring_signals_value;
   if (trusted_scoring_signals) {
-    // TODO(mmenke): It's doubtless more efficient to just make GetSignals()
-    // take a vector of ad components instead of a set, though this API will
-    // likely change when we implement caching, anyways.
-    std::set<GURL> ad_component_render_urls(
-        browser_signal_ad_components.begin(),
-        browser_signal_ad_components.end());
-    trusted_scoring_signals_value = trusted_scoring_signals->GetSignals(
+    trusted_scoring_signals_value = trusted_scoring_signals->GetScoringSignals(
         v8_helper_.get(), context, browser_signal_render_url,
-        ad_component_render_urls);
+        browser_signal_ad_components);
   } else {
     trusted_scoring_signals_value = v8::Null(isolate);
   }
@@ -325,11 +317,8 @@ void SellerWorklet::V8State::ScoreAd(
     return;
   }
   if (!browser_signal_ad_components.empty()) {
-    std::vector<std::string> ad_component_url_strings;
-    for (const GURL& url : browser_signal_ad_components) {
-      ad_component_url_strings.push_back(url.spec());
-    }
-    if (!browser_signals_dict.Set("adComponents", ad_component_url_strings)) {
+    if (!browser_signals_dict.Set("adComponents",
+                                  browser_signal_ad_components)) {
       PostScoreAdCallbackToUserThread(std::move(callback), /*score=*/0,
                                       /*errors=*/std::vector<std::string>());
       return;
@@ -541,7 +530,7 @@ void SellerWorklet::OnDownloadComplete(WorkletLoader::Result worklet_script,
 
 void SellerWorklet::OnTrustedScoringSignalsDownloaded(
     ScoreAdTaskList::iterator task,
-    std::unique_ptr<TrustedScoringSignals::Result> result,
+    std::unique_ptr<TrustedSignals::Result> result,
     absl::optional<std::string> error_msg) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(user_sequence_checker_);
 

content/services/auction_worklet/seller_worklet.h

@@ -18,7 +18,7 @@
 #include "content/services/auction_worklet/public/mojom/auction_worklet_service.mojom-forward.h"
 #include "content/services/auction_worklet/public/mojom/auction_worklet_service.mojom.h"
 #include "content/services/auction_worklet/public/mojom/seller_worklet.mojom.h"
-#include "content/services/auction_worklet/trusted_scoring_signals.h"
+#include "content/services/auction_worklet/trusted_signals.h"
 #include "content/services/auction_worklet/worklet_loader.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
 #include "mojo/public/cpp/bindings/remote.h"
@@ -93,12 +93,15 @@ class SellerWorklet : public mojom::SellerWorklet {
     url::Origin browser_signal_top_window_origin;
     url::Origin browser_signal_interest_group_owner;
     GURL browser_signal_render_url;
-    std::vector<GURL> browser_signal_ad_components;
+    // While these are URLs, it's more concenient to store these as strings
+    // rather than GURLs, both for creating a v8 array from, and for sharing
+    // ScoringSignals code with BidderWorklets.
+    std::vector<std::string> browser_signal_ad_components;
     uint32_t browser_signal_bidding_duration_msecs;
 
     ScoreAdCallback callback;
 
-    std::unique_ptr<TrustedScoringSignals> trusted_scoring_signals;
+    std::unique_ptr<TrustedSignals> trusted_scoring_signals;
 
     // Error message from downloading trusted scoring signals, if any. Prepended
     // to errors passed to the ScoreAdCallback.
@@ -129,11 +132,11 @@ class SellerWorklet : public mojom::SellerWorklet {
         const std::string& ad_metadata_json,
         double bid,
         blink::mojom::AuctionAdConfigPtr auction_config,
-        std::unique_ptr<TrustedScoringSignals::Result> trusted_scoring_signals,
+        std::unique_ptr<TrustedSignals::Result> trusted_scoring_signals,
         const url::Origin& browser_signal_top_window_origin,
         const url::Origin& browser_signal_interest_group_owner,
         const GURL& browser_signal_render_url,
-        const std::vector<GURL>& browser_signal_ad_components,
+        const std::vector<std::string>& browser_signal_ad_components,
         uint32_t browser_signal_bidding_duration_msecs,
         ScoreAdCallbackInternal callback);
 
@@ -193,7 +196,7 @@ class SellerWorklet : public mojom::SellerWorklet {
   // V8 thread.
   void OnTrustedScoringSignalsDownloaded(
       ScoreAdTaskList::iterator task,
-      std::unique_ptr<TrustedScoringSignals::Result> result,
+      std::unique_ptr<TrustedSignals::Result> result,
       absl::optional<std::string> error_msg);
 
   void DeliverScoreAdCallbackOnUserThread(ScoreAdTaskList::iterator task,