seller_worklet_unittest.cc | Explore in Territory

// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/342213636): Remove this and spanify to fix the errors.
#pragma allow_unsafe_buffers
#endif

#include "content/services/auction_worklet/seller_worklet.h"

#include <algorithm>
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>

#include "base/containers/flat_map.h"
#include "base/feature_list.h"
#include "base/functional/bind.h"
#include "base/ranges/algorithm.h"
#include "base/run_loop.h"
#include "base/strings/stringprintf.h"
#include "base/synchronization/waitable_event.h"
#include "base/test/bind.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/task_environment.h"
#include "base/test/values_test_util.h"
#include "base/test/with_feature_override.h"
#include "base/time/time.h"
#include "content/services/auction_worklet/auction_v8_helper.h"
#include "content/services/auction_worklet/public/cpp/real_time_reporting.h"
#include "content/services/auction_worklet/public/mojom/auction_network_events_handler.mojom.h"
#include "content/services/auction_worklet/public/mojom/auction_worklet_service.mojom.h"
#include "content/services/auction_worklet/public/mojom/private_aggregation_request.mojom.h"
#include "content/services/auction_worklet/public/mojom/real_time_reporting.mojom.h"
#include "content/services/auction_worklet/public/mojom/seller_worklet.mojom.h"
#include "content/services/auction_worklet/worklet_devtools_debug_test_util.h"
#include "content/services/auction_worklet/worklet_test_util.h"
#include "content/services/auction_worklet/worklet_v8_debug_test_util.h"
#include "mojo/public/cpp/bindings/pending_receiver.h"
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "mojo/public/cpp/bindings/self_owned_receiver.h"
#include "mojo/public/cpp/bindings/unique_receiver_set.h"
#include "net/http/http_status_code.h"
#include "services/network/test/test_url_loader_factory.h"
#include "testing/gmock/include/gmock/gmock-matchers.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/public/common/features.h"
#include "third_party/blink/public/common/interest_group/ad_auction_currencies.h"
#include "third_party/blink/public/common/interest_group/ad_display_size.h"
#include "third_party/blink/public/common/interest_group/auction_config.h"
#include "third_party/blink/public/mojom/interest_group/interest_group_types.mojom.h"
#include "url/gurl.h"

HasSubstr;
StartsWith;

namespace auction_worklet {
namespace {

PrivateAggregationRequests;
RealTimeReportingContributions;

// Very short time used by some tests that want to wait until just before a
// timer triggers.
constexpr base::TimeDelta kTinyTime = …;

// Common trusted scoring signals response.
const char kTrustedScoringSignalsResponse[] = …;

// Creates a seller script with scoreAd() returning the specified expression.
// Allows using scoreAd() arguments, arbitrary values, incorrect types, etc.
std::string CreateScoreAdScript(const std::string& raw_return_value,
                                const std::string& extra_code = std::string()) { … }

// Returns a working script, primarily for testing failure cases where it
// should not be run.
std::string CreateBasicSellAdScript() { … }

// Creates a seller script with report_result() returning the specified
// expression. If |extra_code| is non-empty, it will be added as an additional
// line above the return value. Intended for sendReportTo() calls. In practice,
// these scripts will always include a scoreAd() method, but few tests check
// both methods.
std::string CreateReportToScript(
    const std::string& raw_return_value,
    const std::string& extra_code = std::string()) { … }

// A ScoreAdClient that takes a callback to call in OnScoreAdComplete().
class TestScoreAdClient : public mojom::ScoreAdClient { … };

class SellerWorkletTest : public testing::Test { … };

class SellerWorkletTwoThreadsTest : public SellerWorkletTest { … };

class SellerWorkletMultiThreadingTest
    : public SellerWorkletTest,
      public testing::WithParamInterface<size_t> { … };

INSTANTIATE_TEST_SUITE_P(…);

// Test the case the SellerWorklet pipe is closed before any of its methods are
// invoked. Nothing should happen.
TEST_F(SellerWorkletTest, PipeClosed) { … }

TEST_F(SellerWorkletTest, NetworkError) { … }

TEST_F(SellerWorkletTest, CompileError) { … }

// Test parsing of return values.
TEST_F(SellerWorkletTest, ScoreAd) { … }

TEST_F(SellerWorkletTest, ScoreAdAllowComponentAuction) { … }

// Test the `ad` output field of scoreAd().
TEST_F(SellerWorkletTest, ScoreAdAd) { … }

// Test the `rejectReason` output field of scoreAd().
TEST_F(SellerWorkletTest, ScoreAdRejectReason) { … }

// Invalid `rejectReason` output of scoreAd() results in error.
TEST_F(SellerWorkletTest, ScoreAdInvalidRejectReason) { … }

// Test the `bid` output field of scoreAd().
TEST_F(SellerWorkletTest, ScoreAdModifiesBid) { … }

// Test currency checks when score ad does not modify bid.
TEST_F(SellerWorkletTest, ScoreAdDoesNotModifyBidCurrency) { … }

// Test the `incomingBidInSellerCurrency` output field of scoreAd()
TEST_F(SellerWorkletTest, ScoreAdIncomingBidInSellerCurrency) { … }

TEST_F(SellerWorkletTest, ScoreAdDateNotAvailable) { … }

TEST_F(SellerWorkletTest, ScoreAdMedata) { … }

TEST_F(SellerWorkletTest, ScoreAdSelectedBuyerAndSellerReportingId) { … }

TEST_F(SellerWorkletTest, ScoreAdBuyerAndSellerReportingIdPresentWithSelected) { … }

TEST_F(SellerWorkletTest, ScoreAdTopWindowOrigin) { … }

TEST_F(SellerWorkletTest, ScoreAdTopLevelSeller) { … }

TEST_F(SellerWorkletTest, ScoreAdComponentSeller) { … }

TEST_F(SellerWorkletTest, ScoreAdInterestGroupOwner) { … }

TEST_F(SellerWorkletTest, ScoreAdRenderUrl) { … }

// Check that accessing `renderUrl` of browserSignals displays a warning.
//
// TODO(crbug.com/40266734): Remove this test when the field itself is
// removed.
TEST_F(SellerWorkletTest, ScoreAdRenderUrlDeprecationWarning) { … }

// Check that accessing `renderURL` of browserSignals does not display a
// warning.
//
// TODO(crbug.com/40266734): Remove this test when renderUrl is removed.
TEST_F(SellerWorkletTest, ScoreAdRenderUrlNoDeprecationWarning) { … }

TEST_F(SellerWorkletTest, ScoreAdAdComponents) { … }

TEST_F(SellerWorkletTest, ScoreAdBid) { … }

TEST_F(SellerWorkletTest, ScoreAdBidCurrency) { … }

TEST_F(SellerWorkletTest, ScoreAdBiddingDuration) { … }

// Test that auction config gets into scoreAd. More detailed handling of
// (shared) construction of actual object is in ReportResultAuctionConfigParam,
// as that worklet is easier to get things out of.
TEST_F(SellerWorkletTest, ScoreAdAuctionConfigParam) { … }

// Check that accessing `decisionLogicUrl` and `trustedScoringSignalsUrl` of
// `auctionConfig` displays a warning.
//
// TODO(crbug.com/40266734): Remove this test when the fields are
// removed.
TEST_F(SellerWorkletTest, ScoreAdAuctionConfigUrlDeprecationWarning) { … }

// Check that accessing `decisionLogicURL` and `trustedScoringSignalsURL` of
// `auctionConfig` does not display a warning.
//
// TODO(crbug.com/40266734): Remove this test when `decisionLogicUrl` and
// `trustedScoringSignalsUrl` are removed.
TEST_F(SellerWorkletTest, ScoreAdAuctionConfigUrlNoDeprecationWarning) { … }

TEST_F(SellerWorkletTest, ScoreAdExperimentGroupIdParam) { … }

// Tests that trusted scoring signals are correctly passed to scoreAd(). Each
// request is sent individually, without calling SendPendingSignalsRequests() -
// instead, the test advances the mock clock by
// TrustedSignalsRequestManager::kAutoSendDelay, triggering each request to
// automatically be sent.
TEST_P(SellerWorkletMultiThreadingTest, ScoreAdTrustedScoringSignals) { … }

// With the cross-origin trusted signals flag off, nothing is passed in to the
// cross-original signals parameter.
TEST_F(SellerWorkletTest, CrossOriginTrustedSignalsDisabled) { … }

TEST_F(SellerWorkletTest, ScoreAdTrustedScoringSignalsLatency) { … }

TEST_F(SellerWorkletTest, ScoreAdCodeReadyLatency) { … }

TEST_F(SellerWorkletTest, ScoreAdDataVersion) { … }

TEST_F(SellerWorkletTest, ScoreAdExperimentGroupId) { … }

// Test the case of a bunch of ScoreAd() calls in parallel, all started before
// the worklet script has loaded.
TEST_P(SellerWorkletMultiThreadingTest, ScoreAdParallelBeforeLoadComplete) { … }

// Test the case of a bunch of ScoreAd() calls in parallel, all started after
// the worklet script has loaded.
TEST_P(SellerWorkletMultiThreadingTest, ScoreAdParallelAfterLoadComplete) { … }

// Test the case of a bunch of ScoreAd() calls in parallel, all started before
// the worklet script fails to load.
TEST_P(SellerWorkletMultiThreadingTest, ScoreAdParallelLoadFails) { … }

// Test the case of a bunch of ScoreAd() calls in parallel, in the case trusted
// scoring signals is non-null. In this case, call AllBidsGenerated() between
// scoring each bid, which should result in requests being sent individually.
TEST_P(SellerWorkletMultiThreadingTest,
       ScoreAdParallelTrustedScoringSignalsNotBatched) { … }

// Test the case of a bunch of ScoreAd() calls in parallel, in the case trusted
// scoring signals is non-null. In this case, don't call AllBidsGenerated()
// between scoring each bid, which should result in all requests being sent as a
// single request.
//
// In this test, the ordering is:
// 1) The worklet script load completes.
// 2) ScoreAd() calls are made.
// 3) The trusted bidding signals are loaded.
TEST_P(SellerWorkletMultiThreadingTest,
       ScoreAdParallelTrustedScoringSignalsBatched1) { … }

// Same as above, but with different ordering.
//
// In this test, the ordering is:
// 1) ScoreAd() calls are made.
// 2) The worklet script load completes.
// 3) The trusted bidding signals are loaded.
TEST_P(SellerWorkletMultiThreadingTest,
       ScoreAdParallelTrustedScoringSignalsBatched2) { … }

// Same as above, but with different ordering.
//
// In this test, the ordering is:
// 1) ScoreAd() calls are made.
// 2) The trusted bidding signals are loaded.
// 3) The worklet script load completes.
TEST_P(SellerWorkletMultiThreadingTest,
       ScoreAdParallelTrustedScoringSignalsBatched3) { … }

// It shouldn't matter the order in which network fetches complete. For each
// required and optional scoreAd() URL load prerequisite, ensure that
// scoreAd() completes when that URL is the last loaded URL.
TEST_F(SellerWorkletTest, ScoreAdLoadCompletionOrder) { … }

// If multiple worklets request DirectFromSellerSignals, they each get the
// correct signals.
TEST_F(SellerWorkletTest, ScoreAdDirectFromSellerSignalsMultipleWorklets) { … }

// Test multiple ReportWin() calls on a single worklet, in parallel. Do this
// twice, once before the worklet has loaded its Javascript, and once after, to
// make sure both cases work.
TEST_F(SellerWorkletTest, ReportResultParallel) { … }

// Test multiple ReportResult() calls on a single worklet, in parallel, in the
// case the worklet script fails to load.
TEST_F(SellerWorkletTest, ReportResultParallelLoadFails) { … }

// Tests parsing of return values.
TEST_F(SellerWorkletTest, ReportResult) { … }

// Tests reporting URLs.
TEST_F(SellerWorkletTest, ReportResultSendReportTo) { … }

TEST_F(SellerWorkletTest, ReportResultDateNotAvailable) { … }

TEST_F(SellerWorkletTest, ReportResultTopWindowOrigin) { … }

TEST_F(SellerWorkletTest, ReportResultTopLevelSeller) { … }

TEST_F(SellerWorkletTest, ReportResultComponentSeller) { … }

TEST_F(SellerWorkletTest, ReportResultTopLevelSellerSignals) { … }

TEST_F(SellerWorkletTest, ReportResultModifiedBid) { … }

TEST_F(SellerWorkletTest, ReportResultInterestGroupOwner) { … }

TEST_F(SellerWorkletTest, ReportResultBuyerAndSellerReportingId) { … }

TEST_F(SellerWorkletTest, ReportResultSelectedBuyerAndSellerReportingId) { … }

TEST_F(SellerWorkletTest, ReportResultRenderUrl) { … }

// Check that accessing `renderUrl` of browserSignals displays a warning.
//
// TODO(crbug.com/40266734): Remove this test when the field itself is
// removed.
TEST_F(SellerWorkletTest, ReportResultRenderUrlDeprecationWarning) { … }

// Check that accessing `renderURL` of browserSignals does not display a
// warning.
//
// TODO(crbug.com/40266734): Remove this test when renderUrl is removed.
TEST_F(SellerWorkletTest, ReportResultRenderUrlNoDeprecationWarning) { … }

TEST_F(SellerWorkletTest, ReportResultRegisterAdBeacon) { … }

TEST_F(SellerWorkletTest, ReportResultBid) { … }

TEST_F(SellerWorkletTest, ReportResultBidCurrency) { … }

TEST_F(SellerWorkletTest, ReportResultDesireability) { … }

TEST_F(SellerWorkletTest, ReportResultHighestScoringOtherBid) { … }

TEST_F(SellerWorkletTest, ReportResultHighestScoringOtherBidCurrency) { … }

TEST_F(SellerWorkletTest, ReportResultAuctionConfigParam) { … }

// Check that accessing `decisionLogicUrl` and `trustedScoringSignalsUrl` of
// `auctionConfig` displays a warning.
//
// TODO(crbug.com/40266734): Remove this test when the fields are
// removed.
TEST_F(SellerWorkletTest, ReportResultAuctionConfigUrlDeprecationWarning) { … }

// Check that accessing `decisionLogicURL` and `trustedScoringSignalsURL` of
// `auctionConfig` does not display a warning.
//
// TODO(crbug.com/40266734): Remove this test when `decisionLogicUrl` and
// `trustedScoringSignalsUrl` are removed.
TEST_F(SellerWorkletTest, ReportResultAuctionConfigUrlNoDeprecationWarning) { … }

TEST_F(SellerWorkletTest,
       ReportResultDirectFromSellerSignalsHeaderAdSlotParam) { … }

TEST_F(SellerWorkletTest, ReportResultAuctionConfigParamPerBuyerTimeouts) { … }

TEST_F(SellerWorkletTest, ReportResultExperimentGroupIdParam) { … }

TEST_F(SellerWorkletTest, ReportResultDataVersion) { … }

// It shouldn't matter the order in which network fetches complete. For each
// required and optional reportResult() URL load prerequisite, ensure that
// reportResult() completes when that URL is the last loaded URL.
TEST_F(SellerWorkletTest, ReportResultLoadCompletionOrder) { … }

// Subsequent runs of the same script should not affect each other. Same is true
// for different scripts, but it follows from the single script case.
TEST_P(SellerWorkletMultiThreadingTest, ScriptIsolation) { … }

TEST_F(SellerWorkletTest,
       ContextIsReusedIfFledgeAlwaysReuseSellerContextEnabled) { … }

TEST_F(
    SellerWorkletTwoThreadsTest,
    OneWorklet_ContextIsReusedInSameThreadIfFledgeAlwaysReuseSellerContextEnabled) { … }

TEST_F(
    SellerWorkletTwoThreadsTest,
    TwoWorklets_ContextIsReusedInSameThreadIfFledgeAlwaysReuseSellerContextEnabled) { … }

TEST_F(SellerWorkletTwoThreadsTest,
       TrustedScoringSignalsTaskTriggersNextThreadIndexCallback) { … }

TEST_F(SellerWorkletTest, ContextReuseDoesNotCrashLazyFiller) { … }

TEST_F(SellerWorkletTest, DeleteBeforeScoreAdCallback) { … }

TEST_F(SellerWorkletTest, DeleteBeforeReportResultCallback) { … }

TEST_F(SellerWorkletTest, PauseOnStart) { … }

TEST_P(SellerWorkletMultiThreadingTest, PauseOnStartDelete) { … }

TEST_F(SellerWorkletTest, BasicV8Debug) { … }

TEST_F(SellerWorkletTwoThreadsTest, BasicV8Debug) { … }

TEST_F(SellerWorkletTest, ParseErrorV8Debug) { … }

TEST_F(SellerWorkletTwoThreadsTest, ParseErrorV8Debug) { … }

TEST_F(SellerWorkletTest, BasicDevToolsDebug) { … }

TEST_F(SellerWorkletTwoThreadsTest, BasicDevToolsDebug) { … }

TEST_F(SellerWorkletTest, InstrumentationBreakpoints) { … }

TEST_F(SellerWorkletTest, UnloadWhilePaused) { … }

// Test that cancelling the worklet before it runs but after the execution was
// queued actually cancels the execution. This is done by trying to run a
// while(true) {} script with a timeout that's bigger than the test timeout, so
// if it doesn't get cancelled the *test* will timeout.
TEST_F(SellerWorkletTest, Cancelation) { … }

// Test that queued tasks get cancelled at worklet destruction.
TEST_F(SellerWorkletTest, CancelationDtor) { … }

// Test that cancelling execution before the script is fetched doesn't run it.
TEST_F(SellerWorkletTest, CancelBeforeFetch) { … }

TEST_F(SellerWorkletTest, ForDebuggingOnlyReportsWithDebugFeatureDisabled) { … }

TEST_F(SellerWorkletTest, AuctionRequestedSizeIsPresentInScoreAdJavascript) { … }

TEST_F(SellerWorkletTest,
       AuctionRequestedSizeIsMissingFromScoreAdJavascriptWhenNotProvided) { … }

TEST_F(SellerWorkletTest, AuctionRequestedSizeIsPresentReportResultJavascript) { … }

TEST_F(SellerWorkletTest,
       AuctionRequestedSizeIsMissingFromReportResultJavascriptWhenNotProvided) { … }

TEST_F(SellerWorkletTest,
       ScoreAdBrowserSignalForDebuggingOnlyInCooldownOrLockout) { … }

class ScoreAdBrowserSignalRenderSizeTest
    : public base::test::WithFeatureOverride,
      public SellerWorkletTest { … };

TEST_P(ScoreAdBrowserSignalRenderSizeTest, ScoreAdBrowserSignalRenderSize) { … }

INSTANTIATE_FEATURE_OVERRIDE_TEST_SUITE(…);

class SellerWorkletSharedStorageAPIDisabledTest : public SellerWorkletTest { … };

TEST_F(SellerWorkletSharedStorageAPIDisabledTest, SharedStorageNotExposed) { … }

class SellerWorkletSharedStorageAPIEnabledTest : public SellerWorkletTest { … };

TEST_F(SellerWorkletSharedStorageAPIEnabledTest, SharedStorageWriteInScoreAd) { … }

TEST_F(SellerWorkletSharedStorageAPIEnabledTest,
       SharedStorageWriteInReportResult) { … }

class SellerWorkletTwoThreadsSharedStorageAPIEnabledTest
    : public SellerWorkletSharedStorageAPIEnabledTest { … };

TEST_F(SellerWorkletTwoThreadsSharedStorageAPIEnabledTest,
       SharedStorageWriteInScoreAd) { … }

class SellerWorkletRealTimeTest : public SellerWorkletTest { … };

// `scoreAd` should time out due to AuctionV8Helper's default script timeout (50
// ms).
TEST_F(SellerWorkletRealTimeTest, ScoreAdDefaultTimeout) { … }

// Test that seller timeout zero results in no score produced.
TEST_F(SellerWorkletRealTimeTest, ScoreAdZeroTimeout) { … }

TEST_F(SellerWorkletRealTimeTest, ScoreAdSellerTimeoutFromAuctionConfig) { … }

TEST_F(SellerWorkletRealTimeTest, ScoreAdJsonTimeout) { … }

// Tests both reporting latency, and default reporting timeout.
TEST_F(SellerWorkletRealTimeTest, ReportResultLatency) { … }

TEST_F(SellerWorkletRealTimeTest, ReportResultZeroTimeout) { … }

TEST_F(SellerWorkletRealTimeTest, ReportResultTimeoutFromAuctionConfig) { … }

TEST_F(SellerWorkletRealTimeTest, ReportResultJsonTimeout) { … }

class SellerWorkletBiddingAndScoringDebugReportingAPIEnabledTest
    : public SellerWorkletRealTimeTest { … };

// Test forDebuggingOnly.reportAdAuctionLoss() and
// forDebuggingOnly.reportAdAuctionWin() called in scoreAd().
TEST_F(SellerWorkletBiddingAndScoringDebugReportingAPIEnabledTest,
       ForDebuggingOnlyReports) { … }

// Debugging loss/win report URLs should be nullopt if scoreAd() parameters are
// invalid.
TEST_F(SellerWorkletBiddingAndScoringDebugReportingAPIEnabledTest,
       ForDebuggingOnlyReportsInvalidScoreAdParameter) { … }

// Loss report URLs before seller script times out should be kept.
TEST_F(SellerWorkletBiddingAndScoringDebugReportingAPIEnabledTest,
       ScoreAdHasError) { … }

// Loss report URLs before seller script times out should be kept.
TEST_F(SellerWorkletBiddingAndScoringDebugReportingAPIEnabledTest,
       ScoreAdTimedOut) { … }

// Subsequent runs of the same script should not affect each other.
TEST_F(SellerWorkletBiddingAndScoringDebugReportingAPIEnabledTest,
       ForDebuggingOnlyReportsScriptIsolation) { … }

class SellerWorkletSampleDebugReportsDisabledTest : public SellerWorkletTest { … };

TEST_F(SellerWorkletSampleDebugReportsDisabledTest,
       ScoreAdBrowserSignalForDebuggingOnlyInCooldownOrLockout) { … }

class SellerWorkletPrivateAggregationEnabledTest : public SellerWorkletTest { … };

TEST_F(SellerWorkletPrivateAggregationEnabledTest, ScoreAd) { … }

TEST_F(SellerWorkletPrivateAggregationEnabledTest, ReportResult) { … }

class SellerWorkletPrivateAggregationDisabledTest : public SellerWorkletTest { … };

TEST_F(SellerWorkletPrivateAggregationDisabledTest, ScoreAd) { … }

TEST_F(SellerWorkletPrivateAggregationDisabledTest, ReportResult) { … }

class SellerWorkletDeprecatedRenderURLReplacementsEnabledTest
    : public SellerWorkletTest { … };

TEST_F(SellerWorkletDeprecatedRenderURLReplacementsEnabledTest,
       DeprecatedRenderURLReplacementsArePresentInScoreAdJavascript) { … }

class SellerWorkletCrossOriginTrustedSignalsTest : public SellerWorkletTest { … };

// With the feature on, same-origin trusted signals still come in the same,
// only there is an extra null param.
TEST_F(SellerWorkletCrossOriginTrustedSignalsTest, SameOrigin) { … }

// Cross-origin signals need explicit header to work; so if it's not there,
// or doesn't permit the origin, they will get blocked including the version.
TEST_F(SellerWorkletCrossOriginTrustedSignalsTest, ForbiddenCrossOrigin) { … }

// Not allowed cross-origin trusted seller signals do not get fetched
TEST_F(SellerWorkletCrossOriginTrustedSignalsTest,
       ForbiddenCrossOriginNoFetch) { … }

// Note that the fetch also involves CORS, but this isn't really a good place
// to test it since we're using a TestURLLoaderFactory so all the CORS code is
// bypassed.
TEST_F(SellerWorkletCrossOriginTrustedSignalsTest, AllowedCrossOrigin) { … }

// When cross-origin trusted seller signals are allowed, they must happen
// after the script headers complete (approximated as script /fetch/
// completes in this test, since TestURLLoaderFactory isn't that fine-grained).
TEST_F(SellerWorkletCrossOriginTrustedSignalsTest, AllowedCrossOriginTiming) { … }

// Handling of errors in trusted signals other than the cross-origin permission;
// it should look identical except for the error message test.
TEST_F(SellerWorkletCrossOriginTrustedSignalsTest, ErrorCrossOrigin) { … }

// Need to use SYSTEM_TIME, because scoring latency uses elapsed_timer, which is
// always 0 if not using SYSTEM_TIME.
class SellerWorkletRealTimeReportingEnabledTest : public SellerWorkletTest { … };

TEST_F(SellerWorkletRealTimeReportingEnabledTest, RealTimeReporting) { … }

TEST_F(SellerWorkletRealTimeReportingEnabledTest, InvalidScore) { … }

TEST_F(SellerWorkletRealTimeReportingEnabledTest, ScriptTimeout) { … }

// contributeToHistogram's is dropped when the script's latency does not
// exceed the threshold.
TEST_F(SellerWorkletRealTimeReportingEnabledTest,
       NotExceedingLatencyThreshold) { … }

// A platform contribution is added when trusted scoring signals server returned
// a non-2xx HTTP response code.
TEST_F(SellerWorkletRealTimeReportingEnabledTest,
       TrustedScoringSignalNetworkError) { … }

// A platform contribution is added when trusted scoring signals server returned
// a non-2xx HTTP response code, even though scoreAd() failed.
TEST_F(SellerWorkletRealTimeReportingEnabledTest,
       TrustedScoringSignalNetworkErrorScoreAdFailed) { … }

}  // namespace
}  // namespace auction_worklet
chromium/content/services/auction_worklet/seller_worklet_unittest.cc
