chromium/src
0
Fork 0
Code Activity

Handle Contextual Data in TrustedSignalsKVv2RequestHelper

Browse Source 
Update trusted signals KVv2 request helper to take optional
perBuyerTKVSignals and sellerTKVSignals, create a new perPartitionMetadata field on top level of the request, and add
the signals into new contextualData field in perPartitionMetadata.

Bug: 391727084
Change-Id: I7b4ec8642bd09a10ed0e6b473f034072a55d249a
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6316991
Reviewed-by: mmenke <mmenke@chromium.org>
Commit-Queue: Tianyang Xu <xtlsheep@google.com>
Cr-Commit-Position: refs/heads/main@{#1435469}
This commit is contained in:
Tianyang Xu
2025-03-20 09:08:37 -07:00
committed by Chromium LUCI CQ
parent 1cd65afa52
commit 189ea9e89d
5 changed files with 276 additions and 282 deletions

11
content/services/auction_worklet/trusted_kvv2_signals_unittest.cc

@ -5,6 +5,7 @@
#include "content/services/auction_worklet/trusted_kvv2_signals.h"
#include <cstddef>
#include <optional>
#include "base/containers/span_writer.h"
#include "base/feature_list.h"
@ -42,8 +43,6 @@ namespace auction_worklet {
namespace {
const char kPublisherHostName[] = "publisher.test";
const int kExperimentGroupId = 12345;
const char kTrustedBiddingSignalsSlotSizeParam[] = "slotSize=100,200";
const char kJoiningOrigin[] = "https://foo.test/";
const size_t kFramingHeaderSize = 5; // bytes
const size_t kOhttpHeaderSize = 55; // bytes
@ -152,8 +151,9 @@ CreateBiddingRequestHelperBuilder() {
kKeyId);
return std::make_unique<TrustedBiddingSignalsKVv2RequestHelperBuilder>(
kPublisherHostName, kExperimentGroupId, std::move(public_key),
kTrustedBiddingSignalsSlotSizeParam);
kPublisherHostName, /*experiment_group_id=*/std::nullopt,
/*contextual_data=*/std::nullopt, std::move(public_key),
/*trusted_bidding_signals_slot_size_param=*/"");
}
std::unique_ptr<TrustedScoringSignalsKVv2RequestHelperBuilder>
@ -166,7 +166,8 @@ CreateScoringRequestHelperBuilder() {
kKeyId);
return std::make_unique<TrustedScoringSignalsKVv2RequestHelperBuilder>(
kPublisherHostName, kExperimentGroupId, std::move(public_key));
kPublisherHostName, /*experiment_group_id=*/std::nullopt,
/*contextual_data=*/std::nullopt, std::move(public_key));
}
class TrustedKVv2SignalsEmbeddedTest : public testing::Test {

33
content/services/auction_worklet/trusted_signals_kvv2_helper.cc

@ -723,22 +723,25 @@ TrustedSignalsKVv2RequestHelperBuilder ::
TrustedSignalsKVv2RequestHelperBuilder::TrustedSignalsKVv2RequestHelperBuilder(
std::string hostname,
std::optional<int> experiment_group_id,
std::optional<std::string> contextual_data,
mojom::TrustedSignalsPublicKeyPtr public_key)
: hostname_(std::move(hostname)),
experiment_group_id_(experiment_group_id),
contextual_data_(std::move(contextual_data)),
public_key_(std::move(public_key)) {}
std::unique_ptr<TrustedSignalsKVv2RequestHelper>
TrustedSignalsKVv2RequestHelperBuilder::Build() {
TrustedSignalsKVv2RequestHelperBuilder::Build() const {
cbor::Value::MapValue request_map_value;
AddPostRequestConstants(request_map_value);
// Add hostname to metadata.
// Add top-level `metadata`.
cbor::Value::MapValue metadata;
metadata.try_emplace(cbor::Value("hostname"), cbor::Value(hostname()));
request_map_value.try_emplace(cbor::Value("metadata"),
cbor::Value(std::move(metadata)));
// Add `partitions`.
cbor::Value::ArrayValue partition_array;
for (const auto& group_pair : compression_groups()) {
int compression_group_id = group_pair.first;
@ -754,6 +757,24 @@ TrustedSignalsKVv2RequestHelperBuilder::Build() {
request_map_value.try_emplace(cbor::Value("partitions"),
cbor::Value(std::move(partition_array)));
// Add `perPartitionMetadata` and subfield `contextualData`.
if (contextual_data().has_value()) {
cbor::Value::MapValue partitioned_metadata_map;
cbor::Value::ArrayValue contextual_data_array;
cbor::Value::MapValue contextual_data_map;
contextual_data_map.try_emplace(cbor::Value("value"),
cbor::Value(contextual_data().value()));
contextual_data_array.emplace_back(std::move(contextual_data_map));
partitioned_metadata_map.try_emplace(
cbor::Value("contextualData"),
cbor::Value(std::move(contextual_data_array)));
request_map_value.try_emplace(
cbor::Value("perPartitionMetadata"),
cbor::Value(std::move(partitioned_metadata_map)));
}
// Generate OHTTP request.
quiche::ObliviousHttpRequest request =
CreateOHttpRequest(public_key(), std::move(request_map_value));
std::string encrypted_request = request.EncapsulateAndSerialize();
@ -810,10 +831,12 @@ TrustedBiddingSignalsKVv2RequestHelperBuilder::
TrustedBiddingSignalsKVv2RequestHelperBuilder(
const std::string& hostname,
std::optional<int> experiment_group_id,
std::optional<std::string> contextual_data,
mojom::TrustedSignalsPublicKeyPtr public_key,
const std::string& trusted_bidding_signals_slot_size_param)
: TrustedSignalsKVv2RequestHelperBuilder(hostname,
experiment_group_id,
std::move(contextual_data),
std::move(public_key)) {
// Parse trusted bidding signals slot size parameter to a pair, which
// parameter key is first and value is second.
@ -901,7 +924,7 @@ cbor::Value::MapValue
TrustedBiddingSignalsKVv2RequestHelperBuilder::BuildMapForPartition(
const Partition& partition,
int partition_id,
int compression_group_id) {
int compression_group_id) const {
cbor::Value::MapValue partition_cbor_map;
partition_cbor_map.try_emplace(cbor::Value("id"), cbor::Value(partition_id));
@ -937,9 +960,11 @@ TrustedScoringSignalsKVv2RequestHelperBuilder::
TrustedScoringSignalsKVv2RequestHelperBuilder(
const std::string& hostname,
std::optional<int> experiment_group_id,
std::optional<std::string> contextual_data,
mojom::TrustedSignalsPublicKeyPtr public_key)
: TrustedSignalsKVv2RequestHelperBuilder(hostname,
experiment_group_id,
std::move(contextual_data),
std::move(public_key)) {}
TrustedScoringSignalsKVv2RequestHelperBuilder::
~TrustedScoringSignalsKVv2RequestHelperBuilder() = default;
@ -986,7 +1011,7 @@ cbor::Value::MapValue
TrustedScoringSignalsKVv2RequestHelperBuilder::BuildMapForPartition(
const Partition& partition,
int partition_id,
int compression_group_id) {
int compression_group_id) const {
cbor::Value::MapValue partition_cbor_map;
partition_cbor_map.try_emplace(cbor::Value("id"), cbor::Value(partition_id));

34
content/services/auction_worklet/trusted_signals_kvv2_helper.h

@ -98,12 +98,13 @@ class CONTENT_EXPORT TrustedSignalsKVv2RequestHelperBuilder {
// Build the request helper using the helper builder to construct the POST
// body string, noting that the partition IDs will not be sequential for
// bidding signals.
std::unique_ptr<TrustedSignalsKVv2RequestHelper> Build();
std::unique_ptr<TrustedSignalsKVv2RequestHelper> Build() const;
protected:
TrustedSignalsKVv2RequestHelperBuilder(
std::string hostname,
std::optional<int> experiment_group_id,
std::optional<std::string> contextual_data,
mojom::TrustedSignalsPublicKeyPtr public_key);
// All the data needed to request a particular bidding or scoring signals
@ -151,13 +152,23 @@ class CONTENT_EXPORT TrustedSignalsKVv2RequestHelperBuilder {
return compression_groups_;
}
const std::map<int, CompressionGroup>& compression_groups() const {
return compression_groups_;
}
const std::string& hostname() const { return hostname_; }
const std::optional<int>& experiment_group_id() const {
return experiment_group_id_;
}
const mojom::TrustedSignalsPublicKey& public_key() { return *public_key_; }
const std::optional<std::string>& contextual_data() const {
return contextual_data_;
}
const mojom::TrustedSignalsPublicKey& public_key() const {
return *public_key_;
}
// Return next compression group id and increase it by 1.
int next_compression_group_id() { return next_compression_group_id_++; }
@ -167,7 +178,7 @@ class CONTENT_EXPORT TrustedSignalsKVv2RequestHelperBuilder {
virtual cbor::Value::MapValue BuildMapForPartition(
const Partition& partition,
int partition_id,
int compression_group_id) = 0;
int compression_group_id) const = 0;
// Multiple partitions are keyed by compression group ID. For the Partition
// vector, always place interest groups with the execution mode
@ -177,6 +188,7 @@ class CONTENT_EXPORT TrustedSignalsKVv2RequestHelperBuilder {
const std::string hostname_;
const std::optional<int> experiment_group_id_;
const std::optional<std::string> contextual_data_;
mojom::TrustedSignalsPublicKeyPtr public_key_;
// Initial id for compression groups.
@ -189,6 +201,7 @@ class CONTENT_EXPORT TrustedBiddingSignalsKVv2RequestHelperBuilder
TrustedBiddingSignalsKVv2RequestHelperBuilder(
const std::string& hostname,
std::optional<int> experiment_group_id,
std::optional<std::string> contextual_data,
mojom::TrustedSignalsPublicKeyPtr public_key,
const std::string& trusted_bidding_signals_slot_size_param);
@ -224,9 +237,10 @@ class CONTENT_EXPORT TrustedBiddingSignalsKVv2RequestHelperBuilder
}
private:
cbor::Value::MapValue BuildMapForPartition(const Partition& partition,
int partition_id,
int compression_group_id) override;
cbor::Value::MapValue BuildMapForPartition(
const Partition& partition,
int partition_id,
int compression_group_id) const override;
// Joining origin to compression group id map.
std::map<url::Origin, int> join_origin_compression_id_map_;
@ -244,6 +258,7 @@ class CONTENT_EXPORT TrustedScoringSignalsKVv2RequestHelperBuilder
TrustedScoringSignalsKVv2RequestHelperBuilder(
const std::string& hostname,
std::optional<int> experiment_group_id,
std::optional<std::string> contextual_data,
mojom::TrustedSignalsPublicKeyPtr public_key);
TrustedScoringSignalsKVv2RequestHelperBuilder(
@ -276,9 +291,10 @@ class CONTENT_EXPORT TrustedScoringSignalsKVv2RequestHelperBuilder
}
};
cbor::Value::MapValue BuildMapForPartition(const Partition& partition,
int partition_id,
int compression_group_id) override;
cbor::Value::MapValue BuildMapForPartition(
const Partition& partition,
int partition_id,
int compression_group_id) const override;
// Store different compression group ids keyed by `CompressionGroupMapKey`.
std::map<CompressionGroupMapKey, int> compression_group_map;

475
content/services/auction_worklet/trusted_signals_kvv2_helper_unittest.cc

@ -48,6 +48,7 @@ namespace {
const char kHostName[] = "publisher.test";
const int kExperimentGroupId = 12345;
const char kContexualData[] = "contextual_signals";
const char kTrustedBiddingSignalsSlotSizeParam[] = "slotSize=100,200";
const size_t kFramingHeaderSize = 5; // bytes
const size_t kOhttpHeaderSize = 55; // bytes
@ -414,7 +415,7 @@ TEST_F(TrustedSignalsKVv2RequestHelperTest,
helper_builder =
std::make_unique<TrustedBiddingSignalsKVv2RequestHelperBuilder>(
kHostName, /*experiment_group_id=*/std::nullopt,
std::move(public_key_),
/*contextual_data=*/std::nullopt, std::move(public_key_),
/*trusted_bidding_signals_slot_size_param=*/"");
helper_builder->AddTrustedSignalsRequest(
@ -471,8 +472,8 @@ TEST_F(TrustedSignalsKVv2RequestHelperTest,
std::unique_ptr<TrustedBiddingSignalsKVv2RequestHelperBuilder>
helper_builder =
std::make_unique<TrustedBiddingSignalsKVv2RequestHelperBuilder>(
kHostName, kExperimentGroupId, std::move(public_key_),
kTrustedBiddingSignalsSlotSizeParam);
kHostName, kExperimentGroupId, kContexualData,
std::move(public_key_), kTrustedBiddingSignalsSlotSizeParam);
helper_builder->AddTrustedSignalsRequest(
std::string("groupA"), std::set<std::string>{"keyA", "keyAB"},
@ -522,140 +523,114 @@ TEST_F(TrustedSignalsKVv2RequestHelperTest,
// operation between the number and the number minus 1 should be 0.
EXPECT_FALSE(request_length & (request_length - 1));
// Use cbor.me to convert from
// {
// "metadata": {
// "hostname": "publisher.test"
// },
// "partitions": [
// {
// "id": 0,
// "metadata": {
// "slotSize": "100,200",
// "experimentGroupId": "12345"
// },
// "arguments": [
// {
// "data": [
// "groupA",
// "groupB"
// ],
// "tags": [
// "interestGroupNames"
// ]
// },
// {
// "data": [
// "keyA",
// "keyAB",
// "keyB"
// ],
// "tags": [
// "keys"
// ]
// }
// ],
// "compressionGroupId": 0
// },
// {
// "id": 1,
// "metadata": {
// "slotSize": "100,200",
// "experimentGroupId": "12345"
// },
// "arguments": [
// {
// "data": [
// "groupAB"
// ],
// "tags": [
// "interestGroupNames"
// ]
// },
// {
// "data": [
// "key"
// ],
// "tags": [
// "keys"
// ]
// }
// ],
// "compressionGroupId": 0
// },
// {
// "id": 0,
// "metadata": {
// "slotSize": "100,200",
// "experimentGroupId": "12345"
// },
// "arguments": [
// {
// "data": [
// "groupC",
// "groupD"
// ],
// "tags": [
// "interestGroupNames"
// ]
// },
// {
// "data": [
// "keyC",
// "keyCD",
// "keyD",
// "keyDD"
// ],
// "tags": [
// "keys"
// ]
// }
// ],
// "compressionGroupId": 1
// }
// ],
// "acceptCompression": [
// "none",
// "gzip"
// ]
// }
const std::string kExpectedBodyHex =
"A3686D65746164617461A168686F73746E616D656E7075626C69736865722E746573746A"
"706172746974696F6E7383A462696400686D65746164617461A268736C6F7453697A6567"
"3130302C323030716578706572696D656E7447726F757049646531323334356961726775"
"6D656E747382A26464617461826667726F7570416667726F75704264746167738172696E"
"74657265737447726F75704E616D6573A2646461746183646B657941656B65794142646B"
"657942647461677381646B65797372636F6D7072657373696F6E47726F7570496400A462"
"696401686D65746164617461A268736C6F7453697A65673130302C323030716578706572"
"696D656E7447726F7570496465313233343569617267756D656E747382A2646461746181"
"6767726F7570414264746167738172696E74657265737447726F75704E616D6573A26464"
"61746181636B6579647461677381646B65797372636F6D7072657373696F6E47726F7570"
"496400A462696400686D65746164617461A268736C6F7453697A65673130302C32303071"
"6578706572696D656E7447726F7570496465313233343569617267756D656E747382A264"
"64617461826667726F7570436667726F75704464746167738172696E7465726573744772"
"6F75704E616D6573A2646461746184646B657943656B65794344646B657944656B657944"
"44647461677381646B65797372636F6D7072657373696F6E47726F757049640171616363"
"657074436F6D7072657373696F6E82646E6F6E6564677A6970";
// Prefix hex for `kExpectedBodyHex` which includes the compression format
// code and the length.
const std::string kExpectedPrefixHex = "0000000235";
// Padding zeros.
const std::string kPaddingString =
"000000000000000000000000000000000000000000000000000000000000000000000000"
"000000000000000000000000000000000000000000000000000000000000000000000000"
"000000000000000000000000000000000000000000000000000000000000000000000000"
"000000000000000000000000000000000000000000000000000000000000000000000000"
"000000000000000000000000000000000000000000000000000000000000000000000000"
"000000000000000000000000000000000000000000000000000000000000000000000000"
"000000000000000000000000000000000000000000000000000000000000000000000000"
"000000000000000000000000000000000000000000000000000000000000000000000000"
"000000000000000000000000000000000000000000000000000000000000000000000000"
"000000000000000000000000000000000000000000000000000000000000000000000000"
"000000000000000000000000000000000000000000000000000000000000000000000000"
"000000";
std::string expected_request_body =
test::CreateKVv2RequestBody(test::ToCborString(
R"({
"metadata": {
"hostname": "publisher.test"
},
"partitions": [
{
"id": 0,
"metadata": {
"slotSize": "100,200",
"experimentGroupId": "12345"
},
"arguments": [
{
"data": [
"groupA",
"groupB"
],
"tags": [
"interestGroupNames"
]
},
{
"data": [
"keyA",
"keyAB",
"keyB"
],
"tags": [
"keys"
]
}
],
"compressionGroupId": 0
},
{
"id": 1,
"metadata": {
"slotSize": "100,200",
"experimentGroupId": "12345"
},
"arguments": [
{
"data": [
"groupAB"
],
"tags": [
"interestGroupNames"
]
},
{
"data": [
"key"
],
"tags": [
"keys"
]
}
],
"compressionGroupId": 0
},
{
"id": 0,
"metadata": {
"slotSize": "100,200",
"experimentGroupId": "12345"
},
"arguments": [
{
"data": [
"groupC",
"groupD"
],
"tags": [
"interestGroupNames"
]
},
{
"data": [
"keyC",
"keyCD",
"keyD",
"keyDD"
],
"tags": [
"keys"
]
}
],
"compressionGroupId": 1
}
],
"acceptCompression": [
"none",
"gzip"
],
"perPartitionMetadata": {
"contextualData": [
{
"value": "contextual_signals"
}
]
}
})"));
EXPECT_EQ(base::HexEncode(body_bytes),
kExpectedPrefixHex + kExpectedBodyHex + kPaddingString);
base::HexEncode(expected_request_body));
}
// TODO(crbug.com/337917489): When adding an identical trusted scoring signals
@ -689,7 +664,8 @@ TEST_F(TrustedSignalsKVv2RequestHelperTest,
std::unique_ptr<TrustedBiddingSignalsKVv2RequestHelperBuilder>
helper_builder =
std::make_unique<TrustedBiddingSignalsKVv2RequestHelperBuilder>(
kHostName, kExperimentGroupId, std::move(public_key_),
kHostName, /*experiment_group_id=*/std::nullopt,
/*contextual_data=*/std::nullopt, std::move(public_key_),
kTrustedBiddingSignalsSlotSizeParam);
EXPECT_EQ(
@ -754,7 +730,7 @@ TEST_F(TrustedSignalsKVv2RequestHelperTest,
helper_builder =
std::make_unique<TrustedScoringSignalsKVv2RequestHelperBuilder>(
kHostName, /*experiment_group_id=*/std::nullopt,
std::move(public_key_));
/*contextual_data=*/std::nullopt, std::move(public_key_));
helper_builder->AddTrustedSignalsRequest(
GURL(kOriginFooUrl), /*ad_component_render_urls=*/{},
@ -804,7 +780,8 @@ TEST_F(TrustedSignalsKVv2RequestHelperTest,
std::unique_ptr<TrustedScoringSignalsKVv2RequestHelperBuilder>
helper_builder =
std::make_unique<TrustedScoringSignalsKVv2RequestHelperBuilder>(
kHostName, kExperimentGroupId, std::move(public_key_));
kHostName, kExperimentGroupId, kContexualData,
std::move(public_key_));
helper_builder->AddTrustedSignalsRequest(
GURL(kOriginFooUrl), std::set<std::string>{kOriginFoosubUrl},
@ -831,131 +808,104 @@ TEST_F(TrustedSignalsKVv2RequestHelperTest,
// operation between the number and the number minus 1 should be 0.
EXPECT_FALSE(request_length & (request_length - 1));
// Use cbor.me to convert from
// {
// "metadata": {
// "hostname": "publisher.test"
// },
// "partitions": [
// {
// "id": 0,
// "metadata": {
// "experimentGroupId": "12345"
// },
// "arguments": [
// {
// "data": [
// "https://foo.test/"
// ],
// "tags": [
// "renderURLs"
// ]
// },
// {
// "data": [
// "https://foosub.test/"
// ],
// "tags": [
// "adComponentRenderURLs"
// ]
// }
// ],
// "compressionGroupId": 0
// },
// {
// "id": 1,
// "metadata": {
// "experimentGroupId": "12345"
// },
// "arguments": [
// {
// "data": [
// "https://bar.test/"
// ],
// "tags": [
// "renderURLs"
// ]
// },
// {
// "data": [
// "https://barsub.test/"
// ],
// "tags": [
// "adComponentRenderURLs"
// ]
// }
// ],
// "compressionGroupId": 0
// },
// {
// "id": 0,
// "metadata": {
// "experimentGroupId": "12345"
// },
// "arguments": [
// {
// "data": [
// "https://foo.test/"
// ],
// "tags": [
// "renderURLs"
// ]
// },
// {
// "data": [
// "https://foosub.test/"
// ],
// "tags": [
// "adComponentRenderURLs"
// ]
// }
// ],
// "compressionGroupId": 1
// }
// ],
// "acceptCompression": [
// "none",
// "gzip"
// ]
// }
const std::string kExpectedBodyHex =
"A3686D65746164617461A168686F73746E616D656E7075626C69736865722E746573746A"
"706172746974696F6E7383A462696400686D65746164617461A1716578706572696D656E"
"7447726F7570496465313233343569617267756D656E747382A264646174618171687474"
"70733A2F2F666F6F2E746573742F6474616773816A72656E64657255524C73A264646174"
"61817468747470733A2F2F666F6F7375622E746573742F647461677381756164436F6D70"
"6F6E656E7452656E64657255524C7372636F6D7072657373696F6E47726F7570496400A4"
"62696401686D65746164617461A1716578706572696D656E7447726F7570496465313233"
"343569617267756D656E747382A26464617461817168747470733A2F2F6261722E746573"
"742F6474616773816A72656E64657255524C73A26464617461817468747470733A2F2F62"
"61727375622E746573742F647461677381756164436F6D706F6E656E7452656E64657255"
"524C7372636F6D7072657373696F6E47726F7570496400A462696400686D657461646174"
"61A1716578706572696D656E7447726F7570496465313233343569617267756D656E7473"
"82A26464617461817168747470733A2F2F666F6F2E746573742F6474616773816A72656E"
"64657255524C73A26464617461817468747470733A2F2F666F6F7375622E746573742F64"
"7461677381756164436F6D706F6E656E7452656E64657255524C7372636F6D7072657373"
"696F6E47726F757049640171616363657074436F6D7072657373696F6E82646E6F6E6564"
"677A6970";
// Prefix hex for `kExpectedBodyHex` which includes the compression format
// code and the length.
const std::string kExpectedPrefixHex = "0000000244";
// Padding zeros.
const std::string kPaddingString =
"000000000000000000000000000000000000000000000000000000000000000000000000"
"000000000000000000000000000000000000000000000000000000000000000000000000"
"000000000000000000000000000000000000000000000000000000000000000000000000"
"000000000000000000000000000000000000000000000000000000000000000000000000"
"000000000000000000000000000000000000000000000000000000000000000000000000"
"000000000000000000000000000000000000000000000000000000000000000000000000"
"000000000000000000000000000000000000000000000000000000000000000000000000"
"000000000000000000000000000000000000000000000000000000000000000000000000"
"000000000000000000000000000000000000000000000000000000000000000000000000"
"000000000000000000000000000000000000000000000000000000000000000000000000"
"000000000000000000000000000000000000000000000000";
std::string expected_request_body =
test::CreateKVv2RequestBody(test::ToCborString(
R"({
"metadata": {
"hostname": "publisher.test"
},
"partitions": [
{
"id": 0,
"metadata": {
"experimentGroupId": "12345"
},
"arguments": [
{
"data": [
"https://foo.test/"
],
"tags": [
"renderURLs"
]
},
{
"data": [
"https://foosub.test/"
],
"tags": [
"adComponentRenderURLs"
]
}
],
"compressionGroupId": 0
},
{
"id": 1,
"metadata": {
"experimentGroupId": "12345"
},
"arguments": [
{
"data": [
"https://bar.test/"
],
"tags": [
"renderURLs"
]
},
{
"data": [
"https://barsub.test/"
],
"tags": [
"adComponentRenderURLs"
]
}
],
"compressionGroupId": 0
},
{
"id": 0,
"metadata": {
"experimentGroupId": "12345"
},
"arguments": [
{
"data": [
"https://foo.test/"
],
"tags": [
"renderURLs"
]
},
{
"data": [
"https://foosub.test/"
],
"tags": [
"adComponentRenderURLs"
]
}
],
"compressionGroupId": 1
}
],
"acceptCompression": [
"none",
"gzip"
],
"perPartitionMetadata": {
"contextualData": [
{
"value": "contextual_signals"
}
]
}
})"));
EXPECT_EQ(base::HexEncode(body_bytes),
kExpectedPrefixHex + kExpectedBodyHex + kPaddingString);
base::HexEncode(expected_request_body));
}
// TODO(crbug.com/337917489): When adding an identical trusted scoring signals
@ -998,7 +948,8 @@ TEST_F(TrustedSignalsKVv2RequestHelperTest,
std::unique_ptr<TrustedScoringSignalsKVv2RequestHelperBuilder>
helper_builder =
std::make_unique<TrustedScoringSignalsKVv2RequestHelperBuilder>(
kHostName, kExperimentGroupId, std::move(public_key_));
kHostName, /*experiment_group_id=*/std::nullopt,
/*contextual_data=*/std::nullopt, std::move(public_key_));
EXPECT_EQ(TrustedSignalsKVv2RequestHelperBuilder::IsolationIndex(0, 0),
helper_builder->AddTrustedSignalsRequest(

5
content/services/auction_worklet/trusted_signals_request_manager.cc

@ -505,7 +505,8 @@ void TrustedSignalsRequestManager::StartBatchedTrustedSignalsRequest() {
auto helper_builder(
std::make_unique<TrustedBiddingSignalsKVv2RequestHelperBuilder>(
top_level_origin_.host(), experiment_group_id_,
public_key_->Clone(), trusted_bidding_signals_slot_size_param_));
/*contextual_data=*/std::nullopt, public_key_->Clone(),
trusted_bidding_signals_slot_size_param_));
for (auto& request : batched_request->requests) {
CHECK(request->interest_group_name_.has_value());
@ -550,7 +551,7 @@ void TrustedSignalsRequestManager::StartBatchedTrustedSignalsRequest() {
auto helper_builder(
std::make_unique<TrustedScoringSignalsKVv2RequestHelperBuilder>(
top_level_origin_.host(), experiment_group_id_,
public_key_->Clone()));
/*contextual_data=*/std::nullopt, public_key_->Clone()));
for (auto& request : batched_request->requests) {
CHECK(request->ad_.has_value());