mock_auction_process_manager.cc | Explore in Territory

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

#include "content/browser/interest_group/mock_auction_process_manager.h"

#include <stdint.h>

#include <map>
#include <memory>
#include <optional>
#include <string>
#include <vector>

#include "base/check.h"
#include "base/containers/flat_map.h"
#include "base/functional/bind.h"
#include "base/memory/ref_counted.h"
#include "base/run_loop.h"
#include "base/time/time.h"
#include "content/browser/interest_group/auction_process_manager.h"
#include "content/public/browser/site_instance.h"
#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/bidder_worklet.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 "mojo/public/cpp/bindings/associated_receiver_set.h"
#include "mojo/public/cpp/bindings/associated_remote.h"
#include "mojo/public/cpp/bindings/pending_associated_receiver.h"
#include "mojo/public/cpp/bindings/pending_associated_remote.h"
#include "mojo/public/cpp/bindings/pending_receiver.h"
#include "mojo/public/cpp/bindings/receiver_set.h"
#include "testing/gtest/include/gtest/gtest.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/devtools/devtools_agent.mojom.h"
#include "url/gurl.h"
#include "url/origin.h"

namespace content {

MockBidderWorklet::MockBidderWorklet(
    mojo::PendingReceiver<auction_worklet::mojom::BidderWorklet>
        pending_receiver,
    const std::map<std::string, base::TimeDelta>& expected_per_buyer_timeouts,
    bool skip_generate_bid)
    : … { … }

MockBidderWorklet::~MockBidderWorklet() { … }

void MockBidderWorklet::BeginGenerateBid(
    auction_worklet::mojom::BidderWorkletNonSharedParamsPtr
        bidder_worklet_non_shared_params,
    auction_worklet::mojom::KAnonymityBidMode kanon_mode,
    const url::Origin& interest_group_join_origin,
    const std::optional<GURL>& direct_from_seller_per_buyer_signals,
    const std::optional<GURL>& direct_from_seller_auction_signals,
    const url::Origin& browser_signal_seller_origin,
    const std::optional<url::Origin>& browser_signal_top_level_seller_origin,
    const base::TimeDelta browser_signal_recency,
    auction_worklet::mojom::BiddingBrowserSignalsPtr bidding_browser_signals,
    base::Time auction_start_time,
    const std::optional<blink::AdSize>& requested_ad_size,
    uint16_t multi_bid_limit,
    uint64_t trace_id,
    mojo::PendingAssociatedRemote<auction_worklet::mojom::GenerateBidClient>
        generate_bid_client,
    mojo::PendingAssociatedReceiver<
        auction_worklet::mojom::GenerateBidFinalizer> bid_finalizer) { … }

void MockBidderWorklet::SendPendingSignalsRequests() { … }

void MockBidderWorklet::ReportWin(
    bool is_for_additional_bid,
    const std::optional<std::string>& interest_group_name_reporting_id,
    const std::optional<std::string>& buyer_reporting_id,
    const std::optional<std::string>& buyer_and_seller_reporting_id,
    const std::optional<std::string>& selected_buyer_and_seller_reporting_id,
    const std::optional<std::string>& auction_signals_json,
    const std::optional<std::string>& per_buyer_signals_json,
    const std::optional<GURL>& direct_from_seller_per_buyer_signals,
    const std::optional<std::string>&
        direct_from_seller_per_buyer_signals_header_ad_slot,
    const std::optional<GURL>& direct_from_seller_auction_signals,
    const std::optional<std::string>&
        direct_from_seller_auction_signals_header_ad_slot,
    const std::string& seller_signals_json,
    auction_worklet::mojom::KAnonymityBidMode kanon_mode,
    bool bid_is_kanon,
    const GURL& browser_signal_render_url,
    double browser_signal_bid,
    const std::optional<blink::AdCurrency>& browser_signal_bid_currency,
    double browser_signal_highest_scoring_other_bid,
    const std::optional<blink::AdCurrency>&
        browser_signal_highest_scoring_other_bid_currency,
    bool browser_signal_made_highest_scoring_other_bid,
    std::optional<double> browser_signal_ad_cost,
    std::optional<uint16_t> browser_signal_modeling_signals,
    uint8_t browser_signal_join_count,
    uint8_t browser_signal_recency,
    const url::Origin& browser_signal_seller_origin,
    const std::optional<url::Origin>& browser_signal_top_level_seller_origin,
    const std::optional<base::TimeDelta> browser_signal_reporting_timeout,
    std::optional<uint32_t> bidding_signals_data_version,
    uint64_t trace_id,
    ReportWinCallback report_win_callback) { … }

void MockBidderWorklet::ConnectDevToolsAgent(
    mojo::PendingAssociatedReceiver<blink::mojom::DevToolsAgent> agent,
    uint32_t thread_index) { … }

void MockBidderWorklet::FinishGenerateBid(
    const std::optional<std::string>& auction_signals_json,
    const std::optional<std::string>& per_buyer_signals_json,
    const std::optional<base::TimeDelta> per_buyer_timeout,
    const std::optional<blink::AdCurrency>& per_buyer_currency,
    const std::optional<GURL>& direct_from_seller_per_buyer_signals,
    const std::optional<std::string>&
        direct_from_seller_per_buyer_signals_header_ad_slot,
    const std::optional<GURL>& direct_from_seller_auction_signals,
    const std::optional<std::string>&
        direct_from_seller_auction_signals_header_ad_slot) { … }

void MockBidderWorklet::WaitForGenerateBid() { … }

void MockBidderWorklet::SetBidderTrustedSignalsFetchLatency(
    base::TimeDelta delta) { … }

void MockBidderWorklet::SetBiddingLatency(base::TimeDelta delta) { … }

void MockBidderWorklet::InvokeGenerateBidCallback(
    std::optional<double> bid,
    const std::optional<blink::AdCurrency>& bid_currency,
    const blink::AdDescriptor& ad_descriptor,
    auction_worklet::mojom::BidRole bid_role,
    std::vector<auction_worklet::mojom::BidderWorkletBidPtr> further_bids,
    std::optional<std::vector<blink::AdDescriptor>> ad_component_descriptors,
    base::TimeDelta duration,
    const std::optional<uint32_t>& bidding_signals_data_version,
    const std::optional<GURL>& debug_loss_report_url,
    const std::optional<GURL>& debug_win_report_url,
    std::vector<auction_worklet::mojom::PrivateAggregationRequestPtr>
        pa_requests,
    std::vector<auction_worklet::mojom::RealTimeReportingContributionPtr>
        real_time_contributions,
    auction_worklet::mojom::GenerateBidDependencyLatenciesPtr
        dependency_latencies,
    auction_worklet::mojom::RejectReason reject_reason) { … }

void MockBidderWorklet::WaitForReportWin() { … }

void MockBidderWorklet::InvokeReportWinCallback(
    std::optional<GURL> report_url,
    base::flat_map<std::string, GURL> ad_beacon_map,
    base::flat_map<std::string, std::string> ad_macro_map,
    std::vector<auction_worklet::mojom::PrivateAggregationRequestPtr>
        pa_requests,
    std::vector<std::string> errors) { … }

void MockBidderWorklet::Flush() { … }

bool MockBidderWorklet::PipeIsClosed() { … }

void MockBidderWorklet::SetSelectedBuyerAndSellerReportingId(
    std::optional<std::string> selected) { … }

MockSellerWorklet::ScoreAdParams::ScoreAdParams() = default;
MockSellerWorklet::ScoreAdParams::ScoreAdParams(ScoreAdParams&&) = default;
MockSellerWorklet::ScoreAdParams::~ScoreAdParams() = default;
MockSellerWorklet::ScoreAdParams& MockSellerWorklet::ScoreAdParams::operator=(
    ScoreAdParams&&) = default;

MockSellerWorklet::MockSellerWorklet(
    mojo::PendingReceiver<auction_worklet::mojom::SellerWorklet>
        pending_receiver)
    : … { … }

MockSellerWorklet::~MockSellerWorklet() { … }

void MockSellerWorklet::ScoreAd(
    const std::string& ad_metadata_json,
    double bid,
    const std::optional<blink::AdCurrency>& bid_currency,
    const blink::AuctionConfig::NonSharedParams&
        auction_ad_config_non_shared_params,
    const std::optional<GURL>& direct_from_seller_seller_signals,
    const std::optional<std::string>&
        direct_from_seller_seller_signals_header_ad_slot,
    const std::optional<GURL>& direct_from_seller_auction_signals,
    const std::optional<std::string>&
        direct_from_seller_auction_signals_header_ad_slot,
    auction_worklet::mojom::ComponentAuctionOtherSellerPtr
        browser_signals_other_seller,
    const std::optional<blink::AdCurrency>& component_expect_bid_currency,
    const url::Origin& browser_signal_interest_group_owner,
    const GURL& browser_signal_render_url,
    const std::optional<std::string>&
        browser_signal_selected_buyer_and_seller_reporting_id,
    const std::optional<std::string>&
        browser_signal_buyer_and_seller_reporting_id,
    const std::vector<GURL>& browser_signal_ad_components,
    uint32_t browser_signal_bidding_duration_msecs,
    const std::optional<blink::AdSize>& browser_signal_render_size,
    bool browser_signal_for_debugging_only_in_cooldown_or_lockout,
    const std::optional<base::TimeDelta> seller_timeout,
    uint64_t trace_id,
    mojo::PendingRemote<auction_worklet::mojom::ScoreAdClient>
        score_ad_client) { … }

void MockSellerWorklet::SendPendingSignalsRequests() { … }

void MockSellerWorklet::ReportResult(
    const blink::AuctionConfig::NonSharedParams&
        auction_ad_config_non_shared_params,
    const std::optional<GURL>& direct_from_seller_seller_signals,
    const std::optional<std::string>&
        direct_from_seller_seller_signals_header_ad_slot,
    const std::optional<GURL>& direct_from_seller_auction_signals,
    const std::optional<std::string>&
        direct_from_seller_auction_signals_header_ad_slot,
    auction_worklet::mojom::ComponentAuctionOtherSellerPtr
        browser_signals_other_seller,
    const url::Origin& browser_signal_interest_group_owner,
    const std::optional<std::string>&
        browser_signal_buyer_and_seller_reporting_id,
    const std::optional<std::string>&
        browser_signal_selected_buyer_and_seller_reporting_id,
    const GURL& browser_signal_render_url,
    double browser_signal_bid,
    const std::optional<blink::AdCurrency>& browser_signal_bid_currency,
    double browser_signal_desirability,
    double browser_signal_highest_scoring_other_bid,
    const std::optional<blink::AdCurrency>&
        browser_signal_highest_scoring_other_bid_currency,
    auction_worklet::mojom::ComponentAuctionReportResultParamsPtr
        browser_signals_component_auction_report_result_params,
    std::optional<uint32_t> browser_signal_data_version,
    uint64_t trace_id,
    ReportResultCallback report_result_callback) { … }

void MockSellerWorklet::ConnectDevToolsAgent(
    mojo::PendingAssociatedReceiver<blink::mojom::DevToolsAgent> agent,
    uint32_t thread_index) { … }

void MockSellerWorklet::ResetReceiverWithReason(const std::string& reason) { … }

// Waits until ScoreAd() has been invoked, if it hasn't been already. It's up
// to the caller to invoke the returned ScoreAdParams::callback to continue
// the auction.
MockSellerWorklet::ScoreAdParams MockSellerWorklet::WaitForScoreAd() { … }

void MockSellerWorklet::WaitForReportResult() { … }

void MockSellerWorklet::InvokeReportResultCallback(
    std::optional<GURL> report_url,
    base::flat_map<std::string, GURL> ad_beacon_map,
    std::vector<auction_worklet::mojom::PrivateAggregationRequestPtr>
        pa_requests,
    std::vector<std::string> errors) { … }

void MockSellerWorklet::Flush() { … }

MockAuctionProcessManager::MockAuctionProcessManager() = default;
MockAuctionProcessManager::~MockAuctionProcessManager() = default;

RenderProcessHost* MockAuctionProcessManager::LaunchProcess(
    mojo::PendingReceiver<auction_worklet::mojom::AuctionWorkletService>
        auction_worklet_service_receiver,
    const ProcessHandle* handle,
    const std::string& display_name) { … }

scoped_refptr<SiteInstance> MockAuctionProcessManager::MaybeComputeSiteInstance(
    SiteInstance* frame_site_instance,
    const url::Origin& worklet_origin) { … }

bool MockAuctionProcessManager::TryUseSharedProcess(
    ProcessHandle* process_handle) { … }

void MockAuctionProcessManager::LoadBidderWorklet(
    mojo::PendingReceiver<auction_worklet::mojom::BidderWorklet>
        bidder_worklet_receiver,
    std::vector<
        mojo::PendingRemote<auction_worklet::mojom::AuctionSharedStorageHost>>
        shared_storage_hosts,
    bool pause_for_debugger_on_start,
    mojo::PendingRemote<network::mojom::URLLoaderFactory>
        pending_url_loader_factory,
    mojo::PendingRemote<auction_worklet::mojom::AuctionNetworkEventsHandler>
        auction_network_events_handler,
    const GURL& script_source_url,
    const std::optional<GURL>& bidding_wasm_helper_url,
    const std::optional<GURL>& trusted_bidding_signals_url,
    const std::string& trusted_bidding_signals_slot_size_param,
    const url::Origin& top_window_origin,
    auction_worklet::mojom::AuctionWorkletPermissionsPolicyStatePtr
        permissions_policy_state,
    std::optional<uint16_t> experiment_group_id,
    auction_worklet::mojom::TrustedSignalsPublicKeyPtr public_key) { … }

void MockAuctionProcessManager::LoadSellerWorklet(
    mojo::PendingReceiver<auction_worklet::mojom::SellerWorklet>
        seller_worklet_receiver,
    std::vector<
        mojo::PendingRemote<auction_worklet::mojom::AuctionSharedStorageHost>>
        shared_storage_hosts,
    bool should_pause_on_start,
    mojo::PendingRemote<network::mojom::URLLoaderFactory>
        pending_url_loader_factory,
    mojo::PendingRemote<auction_worklet::mojom::AuctionNetworkEventsHandler>
        auction_network_events_handler,
    const GURL& script_source_url,
    const std::optional<GURL>& trusted_scoring_signals_url,
    const url::Origin& top_window_origin,
    auction_worklet::mojom::AuctionWorkletPermissionsPolicyStatePtr
        permissions_policy_state,
    std::optional<uint16_t> experiment_group_id) { … }

void MockAuctionProcessManager::SetExpectedBuyerBidTimeout(
    const std::string& name,
    base::TimeDelta value) { … }

void MockAuctionProcessManager::WaitForWorklets(int num_bidders,
                                                int num_sellers) { … }

void MockAuctionProcessManager::WaitForWinningBidderReload() { … }

void MockAuctionProcessManager::WaitForWinningSellerReload() { … }

std::unique_ptr<MockBidderWorklet> MockAuctionProcessManager::TakeBidderWorklet(
    const GURL& script_source_url) { … }

std::unique_ptr<MockSellerWorklet> MockAuctionProcessManager::TakeSellerWorklet(
    GURL script_source_url) { … }

void MockAuctionProcessManager::Flush() { … }

void MockAuctionProcessManager::MaybeQuitWaitForWorkletsRunLoop() { … }

}  // namespace content
chromium/content/browser/interest_group/mock_auction_process_manager.cc
