// 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.

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

#include <cstddef>
#include <list>
#include <memory>
#include <optional>
#include <string>
#include <tuple>
#include <vector>

#include "base/check.h"
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/functional/callback_helpers.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/scoped_refptr.h"
#include "base/memory/weak_ptr.h"
#include "base/notreached.h"
#include "base/run_loop.h"
#include "base/strings/strcat.h"
#include "base/strings/stringprintf.h"
#include "base/test/bind.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/run_until.h"
#include "base/test/scoped_command_line.h"
#include "base/test/scoped_feature_list.h"
#include "base/time/time.h"
#include "base/types/expected.h"
#include "content/browser/interest_group/bidding_and_auction_server_key_fetcher.h"
#include "content/browser/interest_group/data_decoder_manager.h"
#include "content/browser/interest_group/interest_group_features.h"
#include "content/browser/interest_group/trusted_signals_cache_impl.h"
#include "content/browser/renderer_host/render_process_host_impl.h"
#include "content/browser/service_worker/service_worker_process_manager.h"
#include "content/common/features.h"
#include "content/public/browser/frame_tree_node_id.h"
#include "content/public/browser/site_instance.h"
#include "content/public/browser/site_isolation_mode.h"
#include "content/public/browser/site_isolation_policy.h"
#include "content/public/common/content_client.h"
#include "content/public/common/content_features.h"
#include "content/public/common/content_switches.h"
#include "content/public/test/browser_task_environment.h"
#include "content/public/test/mock_render_process_host.h"
#include "content/public/test/test_browser_context.h"
#include "content/services/auction_worklet/public/mojom/auction_shared_storage_host.mojom.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/in_progress_auction_download.mojom.h"
#include "content/services/auction_worklet/public/mojom/seller_worklet.mojom.h"
#include "content/services/auction_worklet/public/mojom/trusted_signals_cache.mojom.h"
#include "content/test/test_content_browser_client.h"
#include "mojo/public/cpp/bindings/pending_receiver.h"
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "mojo/public/cpp/bindings/receiver_set.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "mojo/public/cpp/system/message_pipe.h"
#include "services/network/public/cpp/shared_url_loader_factory.h"
#include "services/network/public/mojom/ip_address_space.mojom.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "url/gurl.h"
#include "url/origin.h"

namespace content {
namespace {

using RequestWorkletServiceOutcome =
    AuctionProcessManager::RequestWorkletServiceOutcome;

// Alias constants to improve readability.
const size_t kMaxSellerProcesses = AuctionProcessManager::kMaxSellerProcesses;
const size_t kMaxBidderProcesses = AuctionProcessManager::kMaxBidderProcesses;

// For tests that make sure the TrustedSignalsCache is wired up correctly, the
// cache is configured to fail with this error, if it successfully receives a
// request.
constexpr std::string_view kCacheMessage =
    "The cache failed with the right error.";

base::OnceClosure NeverInvokedClosure() {
  return base::BindOnce([]() { ADD_FAILURE() << "This should not be called"; });
}

template <class AuctionManagerBaseType>
class TestAuctionProcessManager
    : public AuctionManagerBaseType,
      public auction_worklet::mojom::AuctionWorkletService {
 public:
  // Per-AuctionWorkletService receiver pipe information. Public only so inlined
  // public methods can use it.
  struct ReceiverContext {
    explicit ReceiverContext(
        base::WeakPtr<AuctionProcessManager::WorkletProcess> worklet_process)
        : worklet_process(std::move(worklet_process)) {}

    // The associated worklet process, which may have been destroyed.
    base::WeakPtr<AuctionProcessManager::WorkletProcess> worklet_process;

    // The TrustedSignalsCache Mojo pipe, received from
    // SetTrustedSignalsCache(). There should only be a single call to that
    // method, so should only be one such pipe.
    mojo::Remote<auction_worklet::mojom::TrustedSignalsCache> cache_remote;

    // If non-null, its Quit() method will be invoked when `cache_remote` is
    // populated.
    raw_ptr<base::RunLoop> wait_for_cache_remote_run_loop;
  };

  explicit TestAuctionProcessManager(
      TrustedSignalsCacheImpl* trusted_signals_cache)
      : AuctionManagerBaseType(trusted_signals_cache) {}

  TestAuctionProcessManager(const TestAuctionProcessManager&) = delete;
  const TestAuctionProcessManager& operator=(const TestAuctionProcessManager&) =
      delete;

  ~TestAuctionProcessManager() override = default;

  void SetTrustedSignalsCache(
      mojo::PendingRemote<auction_worklet::mojom::TrustedSignalsCache>
          trusted_signals_cache) override {
    ReceiverContext& context = receiver_set_.current_context();
    // This should only be called once per pipe.
    ASSERT_FALSE(context.cache_remote);
    context.cache_remote.Bind(std::move(trusted_signals_cache));
    if (context.wait_for_cache_remote_run_loop) {
      context.wait_for_cache_remote_run_loop->Quit();
      context.wait_for_cache_remote_run_loop = nullptr;
    }
  }

  void 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,
      auction_worklet::mojom::InProgressAuctionDownloadPtr script_load,
      auction_worklet::mojom::InProgressAuctionDownloadPtr wasm_load,
      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_id,
      auction_worklet::mojom::TrustedSignalsPublicKeyPtr public_key) override {
    NOTREACHED();
  }

  void LoadSellerWorklet(
      mojo::PendingReceiver<auction_worklet::mojom::SellerWorklet>
          seller_worklet,
      std::vector<
          mojo::PendingRemote<auction_worklet::mojom::AuctionSharedStorageHost>>
          shared_storage_hosts,
      bool should_pause_on_start,
      mojo::PendingRemote<network::mojom::URLLoaderFactory> url_loader_factory,
      mojo::PendingRemote<auction_worklet::mojom::AuctionNetworkEventsHandler>
          auction_network_events_handler,
      auction_worklet::mojom::InProgressAuctionDownloadPtr script_load,
      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_id,
      std::optional<bool> send_creative_scanning_metadata,
      auction_worklet::mojom::TrustedSignalsPublicKeyPtr public_key,
      mojo::PendingRemote<auction_worklet::mojom::LoadSellerWorkletClient>
          trusted_signals_url_allowed) override {
    NOTREACHED();
  }

  void ClosePipes() {
    receiver_set_.Clear();
    // No wait to flush a closed pipe from the end that was closed. Run until
    // the other side has noticed the pipe was closed instead.
    base::RunLoop().RunUntilIdle();
  }

  // Get the index that this process was created (e.g. if it was the first
  // created process, return 0). Returns -1 and has an EXPECT failure if the
  // process wasn't found or has since been destroyed. `handle` must have been
  // assigned a WorkletProcess.
  size_t ProcessCreationOrder(
      const AuctionProcessManager::ProcessHandle& handle) {
    EXPECT_TRUE(handle.worklet_process_for_testing());
    for (size_t i = 0u; i < launched_processes_.size(); ++i) {
      if (handle.worklet_process_for_testing() ==
          launched_processes_[i].get()) {
        return i;
      }
    }
    ADD_FAILURE() << "Worklet process not found";
    return -1;
  }

  // Simulate readiness of the creation_index'th launched process.
  // This function will return fail if there is no ith process.
  // Do not call this function after any process in the test has been
  // destroyed.
  //
  // Only works for the dedicated process case. In the non-dedicated case, these
  // should go through the MockRenderProcessHost.
  void SimulateReadyProcess(size_t creation_index) {
    if constexpr (std::is_same<AuctionManagerBaseType,
                               InRendererAuctionProcessManager>::value) {
      // This should not be used in the  InRendererAuctionProcessManager case.
      NOTREACHED();
      return;
    }
    if (launched_processes_.size() <= creation_index) {
      ADD_FAILURE() << "Process unexpectedly doesn't exist: " << creation_index;
      return;
    }
    launched_processes_[creation_index]->OnLaunchedWithProcess(
        base::Process::Current());
    return;
  }

  // Checks that `handle` has no cache remote. Calls RunUntilIdle() to make sure
  // there are no pending calls to pass in a cache remote.
  void ExpectNoCacheRemote(const AuctionProcessManager::ProcessHandle& handle) {
    // `handle` must be assigned a process.
    ASSERT_TRUE(handle.worklet_process_for_testing());

    base::RunLoop().RunUntilIdle();
    // `handle` must still be assigned a process.
    ASSERT_TRUE(handle.worklet_process_for_testing());

    ReceiverContext* context = FindContextForProcess(handle);
    ASSERT_TRUE(context);
    EXPECT_FALSE(context->cache_remote);
  }

  // Waits until a non-zero number of TrustedSignalsCache PendingRemotes have
  // been received, and then returns them all. Because of the complexity of
  // figuring out which remote come from which worklet pipe, they aren't tracked
  // by which WorkletProcess's receiver they were received by.
  auction_worklet::mojom::TrustedSignalsCache* WaitForCacheRemote(
      const AuctionProcessManager::ProcessHandle& handle) {
    // `handle` must be assigned a process.
    CHECK(handle.worklet_process_for_testing());

    ReceiverContext* context = FindContextForProcess(handle);
    if (!context) {
      return nullptr;
    }

    if (!context->cache_remote) {
      base::RunLoop run_loop;
      context->wait_for_cache_remote_run_loop = &run_loop;
      // Null out context, since the pointer may be invalidated while spinning
      // the message loop.
      context = nullptr;
      run_loop.Run();

      context = FindContextForProcess(handle);
      if (!context) {
        return nullptr;
      }
    }

    EXPECT_TRUE(context->cache_remote.is_bound());
    EXPECT_TRUE(context->cache_remote.is_connected());

    return context->cache_remote.get();
  }

 private:
  AuctionProcessManager::WorkletProcess::ProcessContext CreateProcessInternal(
      AuctionProcessManager::WorkletProcess& worklet_process) override {
    launched_processes_.emplace_back(worklet_process.GetWeakPtrForTesting());
    if constexpr (std::is_same<AuctionManagerBaseType,
                               InRendererAuctionProcessManager>::value) {
      // The MockRenderProcessHost drops Mojo pipes on the floor by default, so
      // need to set a binder so `this` can intercept them and bind them to
      // `receiver_set_`, while still exercising the production
      // CreateProcessInternal() call.
      //
      // The `worklet_process` weak pointer is passed to store in
      // `receiver_set_` when BindInterface() is invoke. This assumes that
      // BindInterface() will only be invoked once, synchronously, for each
      // AuctionManagerBaseType::CreateProcessInternal() invocation.
      static_cast<MockRenderProcessHost*>(
          worklet_process.site_instance()->GetOrCreateProcessForTesting())
          ->OverrideBinderForTesting(
              auction_worklet::mojom::AuctionWorkletService::Name_,
              base::BindRepeating(&TestAuctionProcessManager<
                                      AuctionManagerBaseType>::BindInterface,
                                  weak_ptr_factory_.GetWeakPtr(),
                                  worklet_process.GetWeakPtrForTesting()));
      // Defer to the RendererProcessHost mocks when using the InRenderer path.
      return AuctionManagerBaseType::CreateProcessInternal(worklet_process);
    } else {
      mojo::PendingRemote<auction_worklet::mojom::AuctionWorkletService>
          service;
      receiver_set_.Add(
          this, service.InitWithNewPipeAndPassReceiver(),
          ReceiverContext(worklet_process.GetWeakPtrForTesting()));
      return AuctionProcessManager::WorkletProcess::ProcessContext(
          std::move(service));
    }
  }

  // Callback when trying to bind a pipe through the MockRenderProcessHost.
  void BindInterface(
      base::WeakPtr<AuctionProcessManager::WorkletProcess> worklet_process,
      mojo::ScopedMessagePipeHandle pipe) {
    receiver_set_.Add(
        this,
        mojo::PendingReceiver<auction_worklet::mojom::AuctionWorkletService>(
            std::move(pipe)),
        ReceiverContext(worklet_process));
  }

  // Finds the ReceiverContext associated with `handle`. `handle` must have a
  // process. It's considered and error for no such ReceiverContext to exist.
  ReceiverContext* FindContextForProcess(
      const AuctionProcessManager::ProcessHandle& handle) {
    // `handle` must be assigned a process.
    CHECK(handle.worklet_process_for_testing());
    for (const auto& receiver : receiver_set_.GetAllContexts()) {
      if (receiver.second->worklet_process.get() ==
          handle.worklet_process_for_testing()) {
        return receiver.second;
      }
    }
    ADD_FAILURE() << "Context associated with process not found.";
    return nullptr;
  }

  std::vector<base::WeakPtr<AuctionProcessManager::WorkletProcess>>
      launched_processes_;

  mojo::ReceiverSet<auction_worklet::mojom::AuctionWorkletService,
                    ReceiverContext>
      receiver_set_;

  base::WeakPtrFactory<TestAuctionProcessManager<AuctionManagerBaseType>>
      weak_ptr_factory_{this};
};

class TestCacheClient
    : public auction_worklet::mojom::TrustedSignalsCacheClient {
 public:
  explicit TestCacheClient(auction_worklet::mojom::TrustedSignalsCache* cache)
      : cache_(cache) {}

  ~TestCacheClient() override = default;

  void RequestSignalsExpectingSuccess(
      base::UnguessableToken compression_group_token) {
    run_loop_ = std::make_unique<base::RunLoop>();
    cache_->GetTrustedSignals(compression_group_token,
                              receiver_.BindNewPipeAndPassRemote());
    run_loop_->Run();
    run_loop_.reset();
  }

 private:
  // TrustedSignalsCacheClient implementation:
  void OnSuccess(auction_worklet::mojom::TrustedSignalsCompressionScheme
                     compression_scheme,
                 mojo_base::BigBuffer foo) override {
    ADD_FAILURE() << "Valid signals should never be received in these tests";
    run_loop_->Quit();
  }

  void OnError(const std::string& error_message) override {
    EXPECT_EQ(error_message, kCacheMessage);
    run_loop_->Quit();
  }

  std::unique_ptr<base::RunLoop> run_loop_;

  raw_ptr<auction_worklet::mojom::TrustedSignalsCache> cache_;
  mojo::Receiver<auction_worklet::mojom::TrustedSignalsCacheClient> receiver_{
      this};
};

// ContentBrowserClient to disable strict site isolation.
class PartialSiteIsolationContentBrowserClient
    : public TestContentBrowserClient {
 public:
  bool ShouldEnableStrictSiteIsolation() override { return false; }

  bool ShouldDisableSiteIsolation(
      SiteIsolationMode site_isolation_mode) override {
    switch (site_isolation_mode) {
      case SiteIsolationMode::kStrictSiteIsolation:
        return true;
      case SiteIsolationMode::kPartialSiteIsolation:
        return false;
    }
  }
};

// The three ways the base test fixture can be configured.
enum class ProcessMode {
  // Use DedicatedAuctionProcessManager.
  kDedicated,
  // Use InRendererProcessManager and kSitePerProcess.
  kInRendererSitePerProcess,
  // Use InRendererProcessManager and disabled kSitePerProcess.
  kInRendererSharedProcess,
};

class AuctionProcessManagerTest
    : public testing::TestWithParam<
          std::tuple<AuctionProcessManager::WorkletType, ProcessMode>> {
 protected:
  AuctionProcessManagerTest() {
    SiteIsolationPolicy::DisableFlagCachingForTesting();
    std::vector<base::test::FeatureRefAndParams> enabled_features{
        {features::kFledgeStartAnticipatoryProcesses,
         {{"AnticipatoryProcessHoldTime", "10s"}}}};
    std::vector<base::test::FeatureRef> disabled_features;
    switch (GetProcessMode()) {
      case ProcessMode::kDedicated:
        break;
      case ProcessMode::kInRendererSitePerProcess:
        scoped_command_line_.GetProcessCommandLine()->AppendSwitch(
            switches::kSitePerProcess);
        break;
      case ProcessMode::kInRendererSharedProcess:
        disabled_features.emplace_back(
            features::kOriginKeyedProcessesByDefault);
        scoped_command_line_.GetProcessCommandLine()->RemoveSwitch(
            switches::kSitePerProcess);
        original_browser_client_ =
            content::SetBrowserClientForTesting(&browser_client_);
        break;
    }
    RenderProcessHostImpl::set_render_process_host_factory_for_testing(
        &rph_factory_);
    // Note: if we're going to disable kOriginKeyedProcessesByDefault, as is
    // done in the kInRendererSharedProcess case, it's important to do it here
    // before we create any SiteInstances, since that will create
    // BrowsingInstances, and each BrowsingInstance will create a default
    // isolation state based on kOriginKeyedProcessesByDefault.
    feature_list_.InitWithFeaturesAndParameters(enabled_features,
                                                disabled_features);

    // This StartIsolatingSite() call should be done before any SiteInstances
    // are created, so that it applies to them.
    SiteInstance::StartIsolatingSite(
        &test_browser_context_, kIsolatedOrigin.GetURL(),
        ChildProcessSecurityPolicy::IsolatedOriginSource::TEST);

    site_instance1_ = SiteInstance::Create(&test_browser_context_);
    site_instance2_ = SiteInstance::Create(&test_browser_context_);

    CreateAuctionProcessManager(&trusted_signals_cache_);
  }

  virtual ~AuctionProcessManagerTest() {
    if (original_browser_client_) {
      content::SetBrowserClientForTesting(original_browser_client_);
    }
    RenderProcessHostImpl::set_render_process_host_factory_for_testing(nullptr);
  }

  void CreateAuctionProcessManager(
      TrustedSignalsCacheImpl* trusted_signals_cache) {
    // Need to clear the raw ptr first, in case there's already an existing
    // process.
    auction_process_manager_ = nullptr;

    switch (GetProcessMode()) {
      case ProcessMode::kDedicated:
        dedicated_process_manager_.emplace(trusted_signals_cache);
        auction_process_manager_ = &dedicated_process_manager_.value();
        break;
      case ProcessMode::kInRendererSitePerProcess:
      case ProcessMode::kInRendererSharedProcess:
        in_renderer_process_manager_.emplace(trusted_signals_cache);
        auction_process_manager_ = &in_renderer_process_manager_.value();
        break;
    }
  }

  // Closes all worklet pipes, much like a crash.
  void ClosePipes() {
    if (dedicated_process_manager_) {
      dedicated_process_manager_->ClosePipes();
    } else {
      in_renderer_process_manager_->ClosePipes();
    }
  }

  // Wraps calling ProcessCreationOrder() on the correct
  // TestAuctionProcessManager.
  size_t ProcessCreationOrder(
      const AuctionProcessManager::ProcessHandle& handle) {
    if (dedicated_process_manager_) {
      return dedicated_process_manager_->ProcessCreationOrder(handle);
    } else {
      return in_renderer_process_manager_->ProcessCreationOrder(handle);
    }
  }

  // Calls WaitForCacheRemote() on the correct TestAuctionProcessManager.
  auction_worklet::mojom::TrustedSignalsCache* WaitForCacheRemote(
      const AuctionProcessManager::ProcessHandle& handle) {
    if (dedicated_process_manager_) {
      return dedicated_process_manager_->WaitForCacheRemote(handle);
    } else {
      return in_renderer_process_manager_->WaitForCacheRemote(handle);
    }
  }

  // Checks that `handle` has no cache remote. Calls RunUntilIdle() to make sure
  // there are no pending calls to pass in a cache remote.
  void ExpectNoCacheRemote(const AuctionProcessManager::ProcessHandle& handle) {
    if (dedicated_process_manager_) {
      dedicated_process_manager_->ExpectNoCacheRemote(handle);
    } else {
      in_renderer_process_manager_->ExpectNoCacheRemote(handle);
    }
  }

  // Validates `handle` has received a cache remote that works for the provided
  // origin.
  void ValidateCacheRemote(const AuctionProcessManager::ProcessHandle& handle,
                           const url::Origin& origin) {
    auto* cache_remote = WaitForCacheRemote(handle);
    ASSERT_TRUE(cache_remote);

    std::unique_ptr<TrustedSignalsCacheImpl::Handle> trusted_signals_handle;
    int partition_id_ignored = 0;
    // Request signals of the corresponding worklet type, on behalf of `origin`.
    // None of the other parameters matter.
    switch (GetWorkletType()) {
      case AuctionProcessManager::WorkletType::kBidder:
        trusted_signals_handle =
            trusted_signals_cache_.RequestTrustedBiddingSignals(
                /*url_loader_factory=*/nullptr, FrameTreeNodeId(1),
                {"devtools_auction_id"},
                url::Origin::Create(GURL("https://main-frame-origin.test")),
                network::mojom::IPAddressSpace::kPublic, origin,
                "Interest Group Name",
                blink::InterestGroup::ExecutionMode::kCompatibilityMode,
                url::Origin::Create(GURL("https://joinin-origin.test")),
                GURL("https://trusted-signals-url/"),
                url::Origin::Create(GURL("https://coordinator.test")),
                /*trusted_bidding_signals_keys=*/{}, /*additional_params=*/{},
                /*buyer_tkv_signals=*/std::nullopt, partition_id_ignored);
        break;
      case AuctionProcessManager::WorkletType::kSeller:
        trusted_signals_handle =
            trusted_signals_cache_.RequestTrustedScoringSignals(
                /*url_loader_factory=*/nullptr, FrameTreeNodeId(1),
                {"devtools_auction_id"},
                url::Origin::Create(GURL("https://main-frame-origin.test")),
                network::mojom::IPAddressSpace::kPublic, origin,
                GURL("https://trusted-signals-url/"),
                url::Origin::Create(GURL("https://coordinator.test")),
                url::Origin::Create(GURL("https://bidder.test")),
                url::Origin::Create(GURL("https://joining-origin.test")),
                GURL("https://render-url.test"), /*component_render_urls=*/{},
                /*additional_params=*/{}, /*seller_tkv_signals=*/std::nullopt,
                partition_id_ignored);
        break;
    }

    TestCacheClient cache_client(cache_remote);
    cache_client.RequestSignalsExpectingSuccess(
        trusted_signals_handle->compression_group_token());
  }

  // Currently only works when testing the dedicated path.
  void SimulateReadyProcess(size_t creation_index) {
    CHECK(dedicated_process_manager_);
    dedicated_process_manager_->SimulateReadyProcess(creation_index);
  }

  void MaybeStartAnticipatoryProcess(
      const url::Origin& origin,
      std::optional<AuctionProcessManager::WorkletType> worklet_type =
          std::nullopt) {
    auction_process_manager_->MaybeStartAnticipatoryProcess(
        origin, site_instance1_.get(), worklet_type.value_or(GetWorkletType()));
  }

  std::string RequestWorkletServiceOutcomeUmaName(
      std::optional<AuctionProcessManager::WorkletType> worklet_type =
          std::nullopt) {
    return base::StrCat({"Ads.InterestGroup.Auction.",
                         worklet_type.value_or(GetWorkletType()) ==
                                 AuctionProcessManager::WorkletType::kSeller
                             ? "Seller."
                             : "Buyer.",
                         "RequestWorkletServiceOutcome"});
  }

  void RequestWorkletService(
      AuctionProcessManager::ProcessHandle* process_handle,
      const url::Origin& origin,
      AuctionProcessManager::WorkletType worklet_type,
      bool expect_success,
      RequestWorkletServiceOutcome expected_outcome) {
    base::HistogramTester histogram_tester;
    bool success = auction_process_manager_->RequestWorkletService(
        worklet_type, origin, site_instance1_.get(), process_handle,
        base::DoNothing());
    EXPECT_EQ(expect_success, success);
    histogram_tester.ExpectUniqueSample(
        RequestWorkletServiceOutcomeUmaName(worklet_type), expected_outcome,
        1u);
  }

  // Request a worklet service and expect the request to complete synchronously.
  // There's no async version, since async calls are only triggered by deleting
  // another handle. Uses `site_instance1_` if no `site_instance` is provided.
  std::unique_ptr<AuctionProcessManager::ProcessHandle>
  GetServiceOfTypeExpectSuccess(
      AuctionProcessManager::WorkletType worklet_type,
      const url::Origin& origin,
      scoped_refptr<SiteInstance> site_instance = nullptr) {
    if (!site_instance) {
      site_instance = site_instance1_;
    }
    auto process_handle =
        std::make_unique<AuctionProcessManager::ProcessHandle>();
    EXPECT_TRUE(auction_process_manager_->RequestWorkletService(
        worklet_type, origin, std::move(site_instance), process_handle.get(),
        NeverInvokedClosure()));
    EXPECT_TRUE(process_handle->GetService());
    return process_handle;
  }

  // Requests a process of type GetWorkletType().
  std::unique_ptr<AuctionProcessManager::ProcessHandle> GetServiceExpectSuccess(
      const url::Origin& origin) {
    return GetServiceOfTypeExpectSuccess(GetWorkletType(), origin);
  }

  // Returns the maximum number of processes of type GetWorkletType().
  size_t GetMaxProcesses() const {
    switch (GetWorkletType()) {
      case AuctionProcessManager::WorkletType::kSeller:
        return kMaxSellerProcesses;
      case AuctionProcessManager::WorkletType::kBidder:
        return kMaxBidderProcesses;
    }
  }

  ProcessMode GetProcessMode() const {
    return std::get<ProcessMode>(GetParam());
  }

  AuctionProcessManager::WorkletType GetWorkletType() const {
    return std::get<AuctionProcessManager::WorkletType>(GetParam());
  }

  AuctionProcessManager::WorkletType GetOtherWorkletType() const {
    switch (GetWorkletType()) {
      case AuctionProcessManager::WorkletType::kSeller:
        return AuctionProcessManager::WorkletType::kBidder;
      case AuctionProcessManager::WorkletType::kBidder:
        return AuctionProcessManager::WorkletType::kSeller;
    }
  }

  // Returns the number of pending requests of GetWorkletType() type.
  size_t GetPendingRequestsOfWorkletType() {
    switch (GetWorkletType()) {
      case AuctionProcessManager::WorkletType::kSeller:
        return auction_process_manager_->GetPendingSellerRequestsForTesting();
      case AuctionProcessManager::WorkletType::kBidder:
        return auction_process_manager_->GetPendingBidderRequestsForTesting();
    }
  }

  // Returns active processes of GetWorkletType() by default.
  size_t GetActiveProcessesOfWorkletType(
      std::optional<AuctionProcessManager::WorkletType> type = std::nullopt) {
    switch (type.value_or(GetWorkletType())) {
      case AuctionProcessManager::WorkletType::kSeller:
        return auction_process_manager_->GetSellerProcessCountForTesting();
      case AuctionProcessManager::WorkletType::kBidder:
        return auction_process_manager_->GetBidderProcessCountForTesting();
    }
  }

  void CheckOnlyIdleProcessesWithCount(size_t expected_idle_process_count) {
    EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(),
              expected_idle_process_count);
    EXPECT_EQ(auction_process_manager_->GetBidderProcessCountForTesting(), 0u);
    EXPECT_EQ(auction_process_manager_->GetSellerProcessCountForTesting(), 0u);
  }

  // Isolated by StartIsolatingSite() call in the constructor.
  const url::Origin kIsolatedOrigin =
      url::Origin::Create(GURL("https://bank.test"));

  const url::Origin kOriginA = url::Origin::Create(GURL("https://a.test"));
  const url::Origin kOriginB = url::Origin::Create(GURL("https://b.test"));
  const url::Origin kOriginC = url::Origin::Create(GURL("https://c.test"));

  BrowserTaskEnvironment task_environment_{
      content::BrowserTaskEnvironment::TimeSource::MOCK_TIME};
  base::test::ScopedFeatureList feature_list_;

  // `scoped_command_line_` must be destroyeded after any WorkletProcessManager.
  // Otherwise idle worklet processes may try to read it after destruction.
  base::test::ScopedCommandLine scoped_command_line_;

  MockRenderProcessHostFactory rph_factory_;

  TestBrowserContext test_browser_context_;

  // Used by the kInRendererSharedProcess case to disable strict site isolation.
  PartialSiteIsolationContentBrowserClient browser_client_;
  raw_ptr<ContentBrowserClient> original_browser_client_;

  // `site_instance1_` and `site_instance2_` are in different browsing
  // instances.
  scoped_refptr<SiteInstance> site_instance1_;
  scoped_refptr<SiteInstance> site_instance2_;

  DataDecoderManager data_decoder_manager_;
  TrustedSignalsCacheImpl trusted_signals_cache_{
      &data_decoder_manager_,
      base::BindRepeating(
          [](const url::Origin& scope_origin,
             const std::optional<url::Origin>& coordinator,
             base::OnceCallback<void(base::expected<BiddingAndAuctionServerKey,
                                                    std::string>)> callback) {
            std::move(callback).Run(
                base::unexpected(std::string(kCacheMessage)));
          })};

  // Only one of these two is populated, based on the ProcessMode.
  std::optional<TestAuctionProcessManager<DedicatedAuctionProcessManager>>
      dedicated_process_manager_;
  std::optional<TestAuctionProcessManager<InRendererAuctionProcessManager>>
      in_renderer_process_manager_;

  // Points to whichever of the above is non-null.
  raw_ptr<AuctionProcessManager> auction_process_manager_;
};

// Run most tests in both kDedicated and kInRendererSitePerProcess ProcessModes,
// as their behavior should be very similar in most cases.
using SitePerProcessAuctionProcessManagerTest = AuctionProcessManagerTest;
INSTANTIATE_TEST_SUITE_P(
    All,
    SitePerProcessAuctionProcessManagerTest,
    testing::Combine(
        testing::Values(AuctionProcessManager::WorkletType::kSeller,
                        AuctionProcessManager::WorkletType::kBidder),
        testing::Values(ProcessMode::kDedicated,
                        ProcessMode::kInRendererSitePerProcess)));

// Tests for the kInRendererSharedProcess ProcessMode only. These are different
// enough for the SameSite test, that no tests are currently run in all three
// modes.
using SharedRendererInRendererAuctionProcessManagerTest =
    AuctionProcessManagerTest;
INSTANTIATE_TEST_SUITE_P(
    All,
    SharedRendererInRendererAuctionProcessManagerTest,
    testing::Combine(
        testing::Values(AuctionProcessManager::WorkletType::kSeller,
                        AuctionProcessManager::WorkletType::kBidder),
        testing::Values(ProcessMode::kInRendererSharedProcess)));

TEST_P(SitePerProcessAuctionProcessManagerTest, Basic) {
  auto worklet = GetServiceExpectSuccess(kOriginA);
  EXPECT_TRUE(worklet->GetService());
  EXPECT_EQ(1u, GetActiveProcessesOfWorkletType());
  EXPECT_EQ(0u, GetActiveProcessesOfWorkletType(GetOtherWorkletType()));
  EXPECT_EQ(0u, auction_process_manager_->GetIdleProcessCountForTesting());
}

// Make sure requests for different origins don't share processes, nor do
// sellers and bidders.
TEST_P(SitePerProcessAuctionProcessManagerTest,
       MultipleRequestsForDifferentProcesses) {
  auto worlket_a = GetServiceOfTypeExpectSuccess(GetWorkletType(), kOriginA);
  auto worklet_b = GetServiceOfTypeExpectSuccess(GetWorkletType(), kOriginB);
  auto worklet_of_other_type_a =
      GetServiceOfTypeExpectSuccess(GetOtherWorkletType(), kOriginA);
  auto worklet_of_other_type_b =
      GetServiceOfTypeExpectSuccess(GetOtherWorkletType(), kOriginB);

  EXPECT_EQ(2u, GetActiveProcessesOfWorkletType(
                    AuctionProcessManager::WorkletType::kBidder));
  EXPECT_EQ(2u, GetActiveProcessesOfWorkletType(
                    AuctionProcessManager::WorkletType::kSeller));
  EXPECT_EQ(0u, auction_process_manager_->GetIdleProcessCountForTesting());
  EXPECT_NE(worlket_a->GetService(), worklet_b->GetService());
  EXPECT_NE(worlket_a->GetService(), worklet_of_other_type_a->GetService());
  EXPECT_NE(worlket_a->GetService(), worklet_of_other_type_b->GetService());
  EXPECT_NE(worklet_b->GetService(), worklet_of_other_type_a->GetService());
  EXPECT_NE(worklet_b->GetService(), worklet_of_other_type_b->GetService());
  EXPECT_NE(worklet_of_other_type_a->GetService(),
            worklet_of_other_type_b->GetService());
}

TEST_P(SitePerProcessAuctionProcessManagerTest,
       MultipleRequestsForSameProcess) {
  // Request 3 processes of the same type for the same origin. All requests
  // should get the same process.
  auto process_a1 = GetServiceExpectSuccess(kOriginA);
  EXPECT_TRUE(process_a1->GetService());
  auto process_a2 = GetServiceExpectSuccess(kOriginA);
  EXPECT_EQ(process_a1->GetService(), process_a2->GetService());
  EXPECT_EQ(1u, GetActiveProcessesOfWorkletType());
  auto process_a3 = GetServiceExpectSuccess(kOriginA);
  EXPECT_EQ(process_a1->GetService(), process_a3->GetService());
  EXPECT_EQ(1u, GetActiveProcessesOfWorkletType());

  // Request process of the other type with the same origin. It should get a
  // different process.
  std::unique_ptr<AuctionProcessManager::ProcessHandle> other_process_a1 =
      GetServiceOfTypeExpectSuccess(GetOtherWorkletType(), kOriginA);
  EXPECT_EQ(1u, GetActiveProcessesOfWorkletType());
  EXPECT_EQ(1u, GetActiveProcessesOfWorkletType(GetOtherWorkletType()));
  EXPECT_NE(process_a1->GetService(), other_process_a1->GetService());
}

// Test requesting and releasing worklet processes, exceeding the limit. This
// test does not cover the case of multiple requests sharing the same process,
// which is covered by the next test.
TEST_P(SitePerProcessAuctionProcessManagerTest, LimitExceeded) {
  // The list of operations below assumes at least 3 processes are allowed at
  // once.
  CHECK_GE(GetMaxProcesses(), 3u);

  // Operations applied to the process manager. All requests use unique origins,
  // so no need to specify that.
  struct Operation {
    enum class Op {
      // Request the specified number of handle. If there are less than
      // GetMaxProcesses() handles already, expects a process to be immediately
      // assigned. All requests use different origins from every other request.
      kRequestHandles,

      // Destroy a handle with the given index. If the index is less than
      // GetMaxProcesses(), then expect a ProcessHandle to have its callback
      // invoked, if there are more than GetMaxProcesses() already.
      kDestroyHandle,

      // Same as destroy handle, but additionally destroys the next handle that
      // would have been assigned the next available process slot, and makes
      // sure the handle after that one gets a process instead.
      kDestroyHandleAndNextInQueue,
    };

    Op op;

    // Number of handles to request for kRequestHandles operations.
    std::optional<size_t> num_handles;

    // Used for kDestroyHandle and kDestroyHandleAndNextInQueue operations.
    std::optional<size_t> index;

    // The number of total handles expected after this operation. This can be
    // inferred by sum of requested handles requests less handles destroyed
    // handles, but having it explcitly in the struct makes sure the test cases
    // are testing what they're expected to.
    size_t expected_total_handles;

    // If `num_handles` is set, this represents whether each request caused us
    // to hit the limit for the number of processes.
    bool hit_limit_after_requesting_handles;
  };

  const Operation kOperationList[] = {
      {Operation::Op::kRequestHandles,
       /*num_handles=*/GetMaxProcesses(),
       /*index=*/std::nullopt,
       /*expected_total_handles=*/GetMaxProcesses(),
       /*hit_limit_after_requesting_handles=*/false},

      // Check destroying intermediate, last, and first handle when there are no
      // queued requests. Keep exactly GetMaxProcesses() requests, to ensure
      // there are in fact first, last, and intermediate requests (as long as
      // GetMaxProcesses() is at least 3).
      {Operation::Op::kDestroyHandle, /*num_handles=*/std::nullopt,
       /*index=*/1u, /*expected_total_handles=*/GetMaxProcesses() - 1},
      {Operation::Op::kRequestHandles,
       /*num_handles=*/1,
       /*index=*/std::nullopt,
       /*expected_total_handles=*/GetMaxProcesses(),
       /*hit_limit_after_requesting_handles=*/false},
      {Operation::Op::kDestroyHandle, /*num_handles=*/std::nullopt,
       /*index=*/0u, /*expected_total_handles=*/GetMaxProcesses() - 1},
      {Operation::Op::kRequestHandles,
       /*num_handles=*/1,
       /*index=*/std::nullopt,
       /*expected_total_handles=*/GetMaxProcesses(),
       /*hit_limit_after_requesting_handles=*/false},
      {Operation::Op::kDestroyHandle, /*num_handles=*/std::nullopt,
       /*index=*/GetMaxProcesses() - 1,
       /*expected_total_handles=*/GetMaxProcesses() - 1},
      {Operation::Op::kRequestHandles,
       /*num_handles=*/1,
       /*index=*/std::nullopt,
       /*expected_total_handles=*/GetMaxProcesses(),
       /*hit_limit_after_requesting_handles=*/false},

      // Queue 3 more requests, but delete the last and first of them, to test
      // deleting queued requests.
      {Operation::Op::kRequestHandles,
       /*num_handles=*/3,
       /*index=*/std::nullopt,
       /*expected_total_handles=*/GetMaxProcesses() + 3,
       /*hit_limit_after_requesting_handles=*/true},
      {Operation::Op::kDestroyHandle, /*num_handles=*/std::nullopt,
       /*index=*/GetMaxProcesses(),
       /*expected_total_handles=*/GetMaxProcesses() + 2},
      {Operation::Op::kDestroyHandle, /*num_handles=*/std::nullopt,
       /*index=*/GetMaxProcesses() + 1,
       /*expected_total_handles=*/GetMaxProcesses() + 1},

      // Request 4 more processes.
      {Operation::Op::kRequestHandles,
       /*num_handles=*/4,
       /*index=*/std::nullopt,
       /*expected_total_handles=*/GetMaxProcesses() + 5,
       /*hit_limit_after_requesting_handles=*/true},

      // Destroy the first handle and the first pending in the queue immediately
      // afterwards. The next pending request should get a process.
      {Operation::Op::kDestroyHandleAndNextInQueue,
       /*num_handles=*/std::nullopt, /*index=*/0u,
       /*expected_total_handles=*/GetMaxProcesses() + 3},

      // Destroy three more requests that have been asssigned processes, being
      // sure to destroy the first, last, and some request request with nether,
      // amongst requests with assigned processes.
      {Operation::Op::kDestroyHandle, /*num_handles=*/std::nullopt,
       /*index=*/GetMaxProcesses() - 1,
       /*expected_total_handles=*/GetMaxProcesses() + 2},
      {Operation::Op::kDestroyHandle, /*num_handles=*/std::nullopt,
       /*index=*/0u, /*expected_total_handles=*/GetMaxProcesses() + 1},
      {Operation::Op::kDestroyHandle, /*num_handles=*/std::nullopt,
       /*index=*/1u, /*expected_total_handles=*/GetMaxProcesses()},
  };

  struct ProcessHandleData {
    std::unique_ptr<AuctionProcessManager::ProcessHandle> process_handle =
        std::make_unique<AuctionProcessManager::ProcessHandle>();
    std::unique_ptr<base::RunLoop> run_loop = std::make_unique<base::RunLoop>();
  };

  std::vector<ProcessHandleData> data;

  // Used to create distinct origins for each handle
  int num_origins = 0;
  for (const auto& operation : kOperationList) {
    switch (operation.op) {
      case Operation::Op::kRequestHandles:
        for (size_t i = 0; i < *operation.num_handles; ++i) {
          size_t original_size = data.size();
          data.emplace_back(ProcessHandleData());
          url::Origin distinct_origin = url::Origin::Create(
              GURL(base::StringPrintf("https://%i.test", ++num_origins)));
          base::HistogramTester histogram_tester;
          ASSERT_EQ(original_size < GetMaxProcesses(),
                    auction_process_manager_->RequestWorkletService(
                        GetWorkletType(), distinct_origin, site_instance1_,
                        data.back().process_handle.get(),
                        data.back().run_loop->QuitClosure()));
          RequestWorkletServiceOutcome expected_result =
              operation.hit_limit_after_requesting_handles
                  ? RequestWorkletServiceOutcome::kHitProcessLimit
                  : RequestWorkletServiceOutcome::kCreatedNewDedicatedProcess;
          histogram_tester.ExpectUniqueSample(
              RequestWorkletServiceOutcomeUmaName(), expected_result,
              /*expected_bucket_count=*/1);
        }
        break;

      case Operation::Op::kDestroyHandle: {
        size_t original_size = data.size();

        ASSERT_GT(data.size(), *operation.index);
        data.erase(data.begin() + *operation.index);
        // If destroying one of the first GetMaxProcesses() handles, and
        // there were more than GetMaxProcesses() handles before, the
        // first of the handles waiting on a process should get a process.
        if (*operation.index < GetMaxProcesses() &&
            original_size > GetMaxProcesses()) {
          data[GetMaxProcesses() - 1].run_loop->Run();
          EXPECT_TRUE(data[GetMaxProcesses() - 1].process_handle->GetService());
        }
        break;
      }

      case Operation::Op::kDestroyHandleAndNextInQueue: {
        ASSERT_GT(data.size(), *operation.index);
        ASSERT_GT(data.size(), GetMaxProcesses() + 1);

        data.erase(data.begin() + *operation.index);
        data.erase(data.begin() + GetMaxProcesses());
        data[GetMaxProcesses() - 1].run_loop->Run();
        EXPECT_TRUE(data[GetMaxProcesses() - 1].process_handle->GetService());
        break;
      }
    }

    EXPECT_EQ(operation.expected_total_handles, data.size());

    // The first GetMaxProcesses() ProcessHandles should all have
    // assigned processes, which should all be distinct.
    for (size_t i = 0; i < data.size() && i < GetMaxProcesses(); ++i) {
      EXPECT_TRUE(data[i].process_handle->GetService());
      for (size_t j = 0; j < i; ++j) {
        EXPECT_NE(data[i].process_handle->GetService(),
                  data[j].process_handle->GetService());
      }
    }

    // Make sure all pending tasks have been run.
    base::RunLoop().RunUntilIdle();

    // All other requests should not have been assigned processes yet.
    for (size_t i = GetMaxProcesses(); i < data.size(); ++i) {
      EXPECT_FALSE(data[i].run_loop->AnyQuitCalled());
      EXPECT_FALSE(data[i].process_handle->GetService());
    }
  }
}

// Check the process sharing logic - specifically, that requests share processes
// when origins match, and that handles that share a process only count once
// towrads the process limit the process limit.
TEST_P(SitePerProcessAuctionProcessManagerTest, ProcessSharing) {
  // This test assumes GetMaxProcesses() is greater than 1.
  DCHECK_GT(GetMaxProcesses(), 1u);

  // Make 2*GetMaxProcesses() requests for each of GetMaxProcesses() different
  // origins. All requests should succeed immediately.
  std::vector<std::list<std::unique_ptr<AuctionProcessManager::ProcessHandle>>>
      processes(GetMaxProcesses());
  for (size_t origin_index = 0; origin_index < GetMaxProcesses();
       ++origin_index) {
    url::Origin origin = url::Origin::Create(
        GURL(base::StringPrintf("https://%zu.test", origin_index)));
    base::HistogramTester histogram_tester;
    for (size_t i = 0; i < 2 * GetMaxProcesses(); ++i) {
      processes[origin_index].emplace_back(GetServiceExpectSuccess(origin));
      // All requests for the same origin share a process.
      EXPECT_EQ(processes[origin_index].back()->GetService(),
                processes[origin_index].front()->GetService());
      EXPECT_EQ(origin_index + 1, GetActiveProcessesOfWorkletType());
    }
    histogram_tester.ExpectBucketCount(
        RequestWorkletServiceOutcomeUmaName(),
        RequestWorkletServiceOutcome::kCreatedNewDedicatedProcess, 1);
    histogram_tester.ExpectBucketCount(
        RequestWorkletServiceOutcomeUmaName(),
        RequestWorkletServiceOutcome::kUsedExistingDedicatedProcess,
        2 * GetMaxProcesses() - 1);

    // Each origin should have a different process.
    for (size_t origin_index2 = 0; origin_index2 < origin_index;
         ++origin_index2) {
      EXPECT_NE(processes[origin_index].front()->GetService(),
                processes[origin_index2].front()->GetService());
    }
  }

  // Make two process requests for kOriginA and one one for kOriginB, which
  // should all be blocked due to the process limit being reached.

  base::RunLoop run_loop_delayed_a1;
  auto process_delayed_a1 =
      std::make_unique<AuctionProcessManager::ProcessHandle>();
  ASSERT_FALSE(auction_process_manager_->RequestWorkletService(
      GetWorkletType(), kOriginA, site_instance1_, process_delayed_a1.get(),
      run_loop_delayed_a1.QuitClosure()));
  base::RunLoop().RunUntilIdle();
  EXPECT_FALSE(run_loop_delayed_a1.AnyQuitCalled());
  EXPECT_FALSE(process_delayed_a1->GetService());
  EXPECT_EQ(GetMaxProcesses(), GetActiveProcessesOfWorkletType());

  base::RunLoop run_loop_delayed_a2;
  auto process_delayed_a2 =
      std::make_unique<AuctionProcessManager::ProcessHandle>();
  ASSERT_FALSE(auction_process_manager_->RequestWorkletService(
      GetWorkletType(), kOriginA, site_instance1_, process_delayed_a2.get(),
      run_loop_delayed_a2.QuitClosure()));
  base::RunLoop().RunUntilIdle();
  EXPECT_FALSE(run_loop_delayed_a2.AnyQuitCalled());
  EXPECT_FALSE(process_delayed_a2->GetService());
  EXPECT_EQ(GetMaxProcesses(), GetActiveProcessesOfWorkletType());

  base::RunLoop run_loop_delayed_b;
  auto process_delayed_b =
      std::make_unique<AuctionProcessManager::ProcessHandle>();
  ASSERT_FALSE(auction_process_manager_->RequestWorkletService(
      GetWorkletType(), kOriginB, site_instance1_, process_delayed_b.get(),
      run_loop_delayed_b.QuitClosure()));
  base::RunLoop().RunUntilIdle();
  EXPECT_FALSE(run_loop_delayed_b.AnyQuitCalled());
  EXPECT_FALSE(process_delayed_b->GetService());
  EXPECT_EQ(GetMaxProcesses(), GetActiveProcessesOfWorkletType());

  // Release processes for first origin one at a time, until only one is left.
  // The pending requests for kOriginA and kOriginB should remain stalled.
  while (processes[0].size() > 1u) {
    processes[0].pop_front();
    base::RunLoop().RunUntilIdle();
    EXPECT_FALSE(run_loop_delayed_a1.AnyQuitCalled());
    EXPECT_FALSE(process_delayed_a1->GetService());
    EXPECT_FALSE(run_loop_delayed_a2.AnyQuitCalled());
    EXPECT_FALSE(process_delayed_a2->GetService());
    EXPECT_FALSE(run_loop_delayed_b.AnyQuitCalled());
    EXPECT_FALSE(process_delayed_b->GetService());
    EXPECT_EQ(GetMaxProcesses(), GetActiveProcessesOfWorkletType());
  }

  // Remove the final process for the first origin. It should queue a callback
  // to resume the kOriginA requests (prioritized alphabetically), but nothing
  // should happen until the callbacks are invoked.
  processes[0].pop_front();
  EXPECT_FALSE(run_loop_delayed_a1.AnyQuitCalled());
  EXPECT_FALSE(process_delayed_a1->GetService());
  EXPECT_FALSE(run_loop_delayed_a2.AnyQuitCalled());
  EXPECT_FALSE(process_delayed_a2->GetService());
  EXPECT_FALSE(run_loop_delayed_b.AnyQuitCalled());
  EXPECT_FALSE(process_delayed_b->GetService());

  // The two kOriginA callbacks should be invoked when the message loop next
  // spins. The two kOriginA requests should now have been assigned the same
  // service, while the kOriginB request is still pending.
  run_loop_delayed_a1.Run();
  run_loop_delayed_a2.Run();
  EXPECT_TRUE(process_delayed_a1->GetService());
  EXPECT_TRUE(process_delayed_a2->GetService());
  EXPECT_EQ(process_delayed_a1->GetService(), process_delayed_a2->GetService());
  EXPECT_FALSE(run_loop_delayed_b.AnyQuitCalled());
  EXPECT_FALSE(process_delayed_b->GetService());
  EXPECT_EQ(GetMaxProcesses(), GetActiveProcessesOfWorkletType());

  // Freeing one of the two kOriginA processes should have no effect.
  process_delayed_a2.reset();
  base::RunLoop().RunUntilIdle();
  EXPECT_FALSE(run_loop_delayed_b.AnyQuitCalled());
  EXPECT_FALSE(process_delayed_b->GetService());

  // Freeing the other one should queue a task to give the kOriginB requests a
  // process.
  process_delayed_a1.reset();
  EXPECT_FALSE(run_loop_delayed_b.AnyQuitCalled());
  EXPECT_FALSE(process_delayed_b->GetService());

  run_loop_delayed_b.Run();
  EXPECT_TRUE(process_delayed_b->GetService());
  EXPECT_EQ(GetMaxProcesses(), GetActiveProcessesOfWorkletType());
}

TEST_P(SitePerProcessAuctionProcessManagerTest,
       DestroyHandlesWithPendingRequests) {
  // Make GetMaxProcesses() requests for worklets with different origins.
  std::list<std::unique_ptr<AuctionProcessManager::ProcessHandle>> processes;
  for (size_t i = 0; i < GetMaxProcesses(); ++i) {
    url::Origin origin =
        url::Origin::Create(GURL(base::StringPrintf("https://%zu.test", i)));
    processes.emplace_back(GetServiceExpectSuccess(origin));
  }

  // Make a pending request.
  auto pending_process1 =
      std::make_unique<AuctionProcessManager::ProcessHandle>();
  ASSERT_FALSE(auction_process_manager_->RequestWorkletService(
      GetWorkletType(), kOriginA, site_instance1_, pending_process1.get(),
      NeverInvokedClosure()));
  EXPECT_EQ(1u, GetPendingRequestsOfWorkletType());

  // Destroy the pending request. Its callback should not be invoked.
  pending_process1.reset();
  EXPECT_EQ(0u, GetPendingRequestsOfWorkletType());
  base::RunLoop().RunUntilIdle();

  // Make two more pending process requests.
  auto pending_process2 =
      std::make_unique<AuctionProcessManager::ProcessHandle>();
  ASSERT_FALSE(auction_process_manager_->RequestWorkletService(
      GetWorkletType(), kOriginA, site_instance1_, pending_process2.get(),
      NeverInvokedClosure()));
  auto pending_process3 =
      std::make_unique<AuctionProcessManager::ProcessHandle>();
  base::RunLoop pending_process3_run_loop;
  ASSERT_FALSE(auction_process_manager_->RequestWorkletService(
      GetWorkletType(), kOriginB, site_instance1_, pending_process3.get(),
      pending_process3_run_loop.QuitClosure()));
  EXPECT_EQ(2u, GetPendingRequestsOfWorkletType());

  // Delete a process. This should result in a posted task to give
  // `pending_process2` a process.
  processes.pop_front();
  EXPECT_EQ(1u, GetPendingRequestsOfWorkletType());

  // Destroy `pending_process2` before it gets passed a process.
  pending_process2.reset();

  // `pending_process3` should get a process instead.
  pending_process3_run_loop.Run();
  EXPECT_TRUE(pending_process3->GetService());
  EXPECT_EQ(0u, auction_process_manager_->GetPendingSellerRequestsForTesting());
}

// Check that process crash is handled properly, by creating a new process.
TEST_P(SitePerProcessAuctionProcessManagerTest, ProcessCrash) {
  auto process = GetServiceExpectSuccess(kOriginA);
  auction_worklet::mojom::AuctionWorkletService* service =
      process->GetService();
  EXPECT_TRUE(service);
  EXPECT_EQ(1u, GetActiveProcessesOfWorkletType());

  // Close pipes. No new pipe should be created.
  ClosePipes();
  EXPECT_EQ(0u, GetActiveProcessesOfWorkletType());

  // Requesting a new process will create a new pipe.
  auto process2 = GetServiceExpectSuccess(kOriginA);
  auction_worklet::mojom::AuctionWorkletService* service2 =
      process2->GetService();
  EXPECT_TRUE(service2);
  EXPECT_NE(service, service2);
  EXPECT_NE(process, process2);
  EXPECT_EQ(1u, GetActiveProcessesOfWorkletType());
}

TEST_P(SitePerProcessAuctionProcessManagerTest, DisconnectBeforeDelete) {
  // Exercise the codepath where the mojo pipe to a service is broken when
  // a handle to its process is still alive, to make sure this is handled
  // correctly (rather than hitting a DCHECK on incorrect refcounting).
  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_a1 =
      GetServiceExpectSuccess(kOriginA);
  ClosePipes();
  task_environment_.RunUntilIdle();
  handle_a1.reset();
  task_environment_.RunUntilIdle();
}

TEST_P(SitePerProcessAuctionProcessManagerTest,
       DoesNotStartAnticipatoryProcessIfFeatureDisabled) {
  base::test::ScopedFeatureList feature_list;
  feature_list.InitAndDisableFeature(
      features::kFledgeStartAnticipatoryProcesses);
  MaybeStartAnticipatoryProcess(kOriginA, GetWorkletType());
  CheckOnlyIdleProcessesWithCount(0);
}

TEST_P(SitePerProcessAuctionProcessManagerTest,
       ProcessLimitIsRespected_AnticipatoryProcessesOnly) {
  // Create the maximum possible # of anticipatory processes.
  for (size_t i = 0; i < GetMaxProcesses(); ++i) {
    url::Origin origin =
        url::Origin::Create(GURL(base::StringPrintf("https://%i.test", i)));
    MaybeStartAnticipatoryProcess(origin, GetWorkletType());
    CheckOnlyIdleProcessesWithCount(1 + i);
  }
  // We can't make more.
  MaybeStartAnticipatoryProcess(kOriginA, GetWorkletType());
  CheckOnlyIdleProcessesWithCount(GetMaxProcesses());
}

// Make sure the process limit is respected when we have a combination of
// anticipatory and active processes. Make sure we can make processes of
// the other type (active and idle) even if we've hit the limit of one type.
TEST_P(SitePerProcessAuctionProcessManagerTest,
       ProcessLimitIsRespected_ActiveAndAnticipatoryProcesses) {
  // Alternate creating anticipatory and active processes. Each active processes
  // will consume 1 anticipatory process. After the for loop, we end up with 1
  // anticipatory process and GetMaxProcesses() - 1 active processes.
  MaybeStartAnticipatoryProcess(url::Origin::Create(GURL("https://0.test")),
                                GetWorkletType());
  CheckOnlyIdleProcessesWithCount(1);
  std::vector<std::unique_ptr<AuctionProcessManager::ProcessHandle>> handles;
  for (size_t i = 0; i < GetMaxProcesses() - 1; ++i) {
    url::Origin origin =
        url::Origin::Create(GURL(base::StringPrintf("https://%i.test", i)));
    handles.emplace_back(
        std::make_unique<AuctionProcessManager::ProcessHandle>());
    RequestWorkletService(handles.back().get(), origin, GetWorkletType(),
                          /*expect_success=*/true,
                          RequestWorkletServiceOutcome::kUsedIdleProcess);
    EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(), 0u);
    EXPECT_EQ(GetActiveProcessesOfWorkletType(), handles.size());
    origin =
        url::Origin::Create(GURL(base::StringPrintf("https://%i.test", i + 1)));
    MaybeStartAnticipatoryProcess(origin, GetWorkletType());
    EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(), 1u);
    EXPECT_EQ(GetActiveProcessesOfWorkletType(), handles.size());
  }

  // Can't make more anticipatory processes of this type.
  MaybeStartAnticipatoryProcess(kOriginA, GetWorkletType());
  EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(), 1u);
  EXPECT_EQ(GetActiveProcessesOfWorkletType(), GetMaxProcesses() - 1);

  // Can make an anticipatory process of the other type.
  MaybeStartAnticipatoryProcess(kOriginB, GetOtherWorkletType());
  EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(), 2u);
  EXPECT_EQ(GetActiveProcessesOfWorkletType(), GetMaxProcesses() - 1);

  // We should still be able to create another worklet with the
  // anticipatory process we made of this type.
  handles.emplace_back(
      std::make_unique<AuctionProcessManager::ProcessHandle>());
  RequestWorkletService(
      handles.back().get(),
      url::Origin::Create(
          GURL(base::StringPrintf("https://%i.test", GetMaxProcesses() - 1))),
      GetWorkletType(),
      /*expect_success=*/true, RequestWorkletServiceOutcome::kUsedIdleProcess);
  EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(), 1u);
  EXPECT_EQ(GetActiveProcessesOfWorkletType(), GetMaxProcesses());

  // Can't make more processes of this type.
  handles.emplace_back(
      std::make_unique<AuctionProcessManager::ProcessHandle>());
  RequestWorkletService(handles.back().get(), kOriginB, GetWorkletType(),
                        /*expect_success=*/false,
                        RequestWorkletServiceOutcome::kHitProcessLimit);
  EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(), 1u);
  EXPECT_EQ(GetActiveProcessesOfWorkletType(), GetMaxProcesses());

  // Create a handle that should be backed by the anticipatory process of the
  // other type for kOriginB, created three code blocks back.
  handles.emplace_back(
      std::make_unique<AuctionProcessManager::ProcessHandle>());
  if (GetProcessMode() == ProcessMode::kDedicated) {
    // If using the dedicated process manager, the origin doesn't need to match
    // that of the idle process to reuse it, so can request a service for
    // kOriginC to get the WorkletProcess for kOriginB.
    RequestWorkletService(handles.back().get(), kOriginC, GetOtherWorkletType(),
                          /*expect_success=*/true,
                          RequestWorkletServiceOutcome::kUsedIdleProcess);
  } else {
    // In the in-renderer case, have to request the same origin to use the
    // anticipatory process.
    RequestWorkletService(handles.back().get(), kOriginB, GetOtherWorkletType(),
                          /*expect_success=*/true,
                          RequestWorkletServiceOutcome::kUsedIdleProcess);
  }
  EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(), 0u);
  EXPECT_EQ(GetActiveProcessesOfWorkletType(), GetMaxProcesses());

  handles.clear();
  EXPECT_EQ(GetActiveProcessesOfWorkletType(), 0u);
  // Now we should no longer be at the process limit. We can make more
  // processes.
  handles.emplace_back(
      std::make_unique<AuctionProcessManager::ProcessHandle>());
  RequestWorkletService(
      handles.back().get(), url::Origin::Create(GURL("https://worklet2.test")),
      GetWorkletType(),
      /*expect_success=*/true,
      RequestWorkletServiceOutcome::kCreatedNewDedicatedProcess);
  EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(), 0u);
  EXPECT_EQ(GetActiveProcessesOfWorkletType(), 1u);
  MaybeStartAnticipatoryProcess(
      url::Origin::Create(GURL("https://worklet3.test")), GetWorkletType());
  EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(), 1u);
  EXPECT_EQ(GetActiveProcessesOfWorkletType(), 1u);
}

TEST_P(SitePerProcessAuctionProcessManagerTest,
       DoNotStartMultipleProcessesSameOriginAndType) {
  MaybeStartAnticipatoryProcess(kOriginA, GetWorkletType());
  CheckOnlyIdleProcessesWithCount(1);
  MaybeStartAnticipatoryProcess(kOriginA, GetWorkletType());
  CheckOnlyIdleProcessesWithCount(1);
}

TEST_P(SitePerProcessAuctionProcessManagerTest,
       CanStartProcessesWithSameOriginIfOneIsSellerAndOneIsBuyer) {
  MaybeStartAnticipatoryProcess(kOriginA, GetWorkletType());
  CheckOnlyIdleProcessesWithCount(1);
  MaybeStartAnticipatoryProcess(kOriginA, GetOtherWorkletType());
  CheckOnlyIdleProcessesWithCount(2);
}

TEST_P(SitePerProcessAuctionProcessManagerTest,
       DoNotStartProcessWithSameOriginAndTypeAsExistingProcess) {
  AuctionProcessManager::ProcessHandle process_handle;
  RequestWorkletService(
      &process_handle, kOriginA, GetWorkletType(), /*expect_success=*/true,
      RequestWorkletServiceOutcome::kCreatedNewDedicatedProcess);
  EXPECT_EQ(GetActiveProcessesOfWorkletType(), 1u);
  MaybeStartAnticipatoryProcess(kOriginA, GetWorkletType());
  EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(), 0u);
  EXPECT_EQ(GetActiveProcessesOfWorkletType(), 1u);
}

// This test covers the different behavior when there's an unused anticipatory
// process created with varying parameters.
TEST_P(SitePerProcessAuctionProcessManagerTest,
       TryToUseAnticipatoryProcessOfSameOrDifferentOriginAndType) {
  for (const auto& origin_to_request : {kOriginA, kOriginB}) {
    SCOPED_TRACE(origin_to_request);
    for (AuctionProcessManager::WorkletType worklet_type_to_request :
         {GetWorkletType(), GetOtherWorkletType()}) {
      SCOPED_TRACE(static_cast<int>(worklet_type_to_request));
      MaybeStartAnticipatoryProcess(kOriginA, GetWorkletType());
      CheckOnlyIdleProcessesWithCount(1);
      EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(), 1u);

      if (GetProcessMode() == ProcessMode::kDedicated ||
          (origin_to_request == kOriginA &&
           worklet_type_to_request == GetWorkletType())) {
        // In the dedicated case, or the in-renderer case where the origin and
        // worklet types both match, requesting a process should result in using
        // the idle process.
        AuctionProcessManager::ProcessHandle handle;
        RequestWorkletService(&handle, origin_to_request,
                              worklet_type_to_request,
                              /*expect_success=*/true,
                              RequestWorkletServiceOutcome::kUsedIdleProcess);
        EXPECT_EQ(GetActiveProcessesOfWorkletType(worklet_type_to_request), 1u);
        EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(),
                  0u);
      } else {
        // In the other case, a new process should be created, leaving the
        // anticipatory process idle.
        AuctionProcessManager::ProcessHandle handle;
        RequestWorkletService(
            &handle, origin_to_request, worklet_type_to_request,
            /*expect_success=*/true,
            RequestWorkletServiceOutcome::kCreatedNewDedicatedProcess);
        EXPECT_EQ(GetActiveProcessesOfWorkletType(worklet_type_to_request), 1u);
        // The antipatory process should still exist and be idle.
        EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(),
                  1u);

        // Make a request matching the parameters of the anticipatory process.
        AuctionProcessManager::ProcessHandle handle2;
        RequestWorkletService(&handle2, kOriginA, GetWorkletType(),
                              /*expect_success=*/true,
                              RequestWorkletServiceOutcome::kUsedIdleProcess);
        // There should be no more idle processes.
        EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(),
                  0u);
      }

      // There should be no processes, idle or otherwise, at this point, so the
      // manager is in a clean state for the next loop iteration.
      CheckOnlyIdleProcessesWithCount(0);
    }
  }
}

TEST_P(SitePerProcessAuctionProcessManagerTest,
       ReassignsOrDestroysIdleProcessOfSameTypeOnlyAfterReachingLimit) {
  // Make an anticipatory process of the other type. This will not be
  // convertible to a process of our type after we hit the limit.
  MaybeStartAnticipatoryProcess(kOriginA, GetOtherWorkletType());
  CheckOnlyIdleProcessesWithCount(1);
  for (size_t i = 0; i < GetMaxProcesses(); ++i) {
    url::Origin origin =
        url::Origin::Create(GURL(base::StringPrintf("https://%i.test", i)));
    MaybeStartAnticipatoryProcess(origin, GetWorkletType());
    CheckOnlyIdleProcessesWithCount(2 + i);
  }
  // Try assigning these to different origins.
  std::vector<std::unique_ptr<AuctionProcessManager::ProcessHandle>> handles;
  for (size_t i = 0; i < GetMaxProcesses(); ++i) {
    url::Origin origin =
        url::Origin::Create(GURL(base::StringPrintf("https://%i_2.test", i)));
    handles.emplace_back(
        std::make_unique<AuctionProcessManager::ProcessHandle>());
    if (GetProcessMode() == ProcessMode::kDedicated) {
      // We should assign the oldest anticipatory process of the same type
      // because we've hit the process limit -- we'd prefer to assign a newer
      // anticipatory process than to use the older process & have to remove one
      // of our anticipatory processes. All anticipatory processes were of type
      // GetWorkletType() except the first one.
      RequestWorkletService(handles.back().get(), origin, GetWorkletType(),
                            /*expect_success=*/true,
                            RequestWorkletServiceOutcome::kUsedIdleProcess);
      EXPECT_EQ(ProcessCreationOrder(*handles.back()), i + 1u);
    } else {
      // In the renderer case, processes could not be used for another origin,
      // so a new process was created, and an old idle process destroyed.
      RequestWorkletService(
          handles.back().get(), origin, GetWorkletType(),
          /*expect_success=*/true,
          RequestWorkletServiceOutcome::kCreatedNewDedicatedProcess);
      EXPECT_EQ(ProcessCreationOrder(*handles.back()),
                GetMaxProcesses() + i + 1u);
    }
    EXPECT_EQ(GetActiveProcessesOfWorkletType(), i + 1u);
  }
  EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(), 1u);
}

TEST_P(SitePerProcessAuctionProcessManagerTest,
       ProcessesCanBeAssignedInDifferentOrderFromHowTheyWereMade) {
  std::vector<std::tuple<url::Origin, AuctionProcessManager::WorkletType>>
      origins_and_types;
  for (url::Origin origin : {kOriginA, kOriginB, kOriginC}) {
    for (AuctionProcessManager::WorkletType type :
         {GetWorkletType(), GetOtherWorkletType()}) {
      origins_and_types.emplace_back(origin, type);
      MaybeStartAnticipatoryProcess(origin, type);
    }
  }

  std::vector<std::unique_ptr<AuctionProcessManager::ProcessHandle>> handles;
  for (size_t i = 0; i < origins_and_types.size(); i++) {
    size_t inverse_index = origins_and_types.size() - 1 - i;
    const auto& origin_and_type = origins_and_types[inverse_index];
    std::unique_ptr<AuctionProcessManager::ProcessHandle> handle =
        std::make_unique<AuctionProcessManager::ProcessHandle>();
    RequestWorkletService(
        handle.get(), std::get<url::Origin>(origin_and_type),
        std::get<AuctionProcessManager::WorkletType>(origin_and_type),
        /*expect_success=*/true,
        RequestWorkletServiceOutcome::kUsedIdleProcess);
    if (GetProcessMode() == ProcessMode::kDedicated) {
      // We assigned the oldest available idle process.
      EXPECT_EQ(ProcessCreationOrder(*handle), i);
    } else {
      // We assigned process created with the same origin.
      EXPECT_EQ(ProcessCreationOrder(*handle), inverse_index);
    }
    EXPECT_EQ(GetActiveProcessesOfWorkletType(
                  AuctionProcessManager::WorkletType::kBidder) +
                  GetActiveProcessesOfWorkletType(
                      AuctionProcessManager::WorkletType::kSeller),
              i + 1u);
    EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(),
              inverse_index);
    handles.push_back(std::move(handle));
  }
}

// Make sure we're not creating duplicate processes for
// an origin, even if we've assigned one of our anticipatory
// processes to a worklet.
TEST_P(SitePerProcessAuctionProcessManagerTest,
       DoesNotRecreateAnticipatoryProcessForOriginAfterAssigned) {
  url::Origin origins[] = {kOriginA, kOriginB, kOriginC};
  for (const url::Origin& origin_to_request_service : origins) {
    CheckOnlyIdleProcessesWithCount(0);
    for (const url::Origin& origin_for_anticipatory_process : origins) {
      MaybeStartAnticipatoryProcess(origin_for_anticipatory_process,
                                    GetWorkletType());
    }
    EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(), 3u);

    AuctionProcessManager::ProcessHandle handle;
    RequestWorkletService(&handle, origin_to_request_service, GetWorkletType(),
                          /*expect_success=*/true,
                          RequestWorkletServiceOutcome::kUsedIdleProcess);
    EXPECT_EQ(GetActiveProcessesOfWorkletType(), 1u);
    EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(), 2u);

    for (const url::Origin& origin_for_anticipatory_process : origins) {
      MaybeStartAnticipatoryProcess(origin_for_anticipatory_process,
                                    GetWorkletType());
    }
    EXPECT_EQ(GetActiveProcessesOfWorkletType(), 1u);
    EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(), 2u);

    // Reset the number of processes for the next loop by letting the idle
    // processes expire. The active process will go out of scope.
    task_environment_.FastForwardBy(
        features::kFledgeStartAnticipatoryProcessExpirationTime.Get());
    EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(), 0u);
  }
}

TEST_P(SitePerProcessAuctionProcessManagerTest,
       RemovesProcessAfterExpirationTime) {
  base::HistogramTester histogram_tester;
  MaybeStartAnticipatoryProcess(kOriginA, GetWorkletType());
  CheckOnlyIdleProcessesWithCount(1);
  task_environment_.FastForwardBy(
      features::kFledgeStartAnticipatoryProcessExpirationTime.Get() -
      base::Milliseconds(1));
  CheckOnlyIdleProcessesWithCount(1);
  task_environment_.FastForwardBy(base::Milliseconds(1));
  CheckOnlyIdleProcessesWithCount(0);
  histogram_tester.ExpectUniqueSample(
      "Ads.InterestGroup.Auction.IdleProcessExpired", true, 1);
}

TEST_P(SitePerProcessAuctionProcessManagerTest,
       CorrectProcessGetsDeletedAfterExpiration) {
  MaybeStartAnticipatoryProcess(kOriginA, GetWorkletType());
  CheckOnlyIdleProcessesWithCount(1);
  task_environment_.FastForwardBy(base::Milliseconds(1));
  MaybeStartAnticipatoryProcess(kOriginB, GetWorkletType());
  CheckOnlyIdleProcessesWithCount(2);

  // One processes should be deleted after the first
  // features::kFledgeStartAnticipatoryProcessExpirationTime
  // passes.
  task_environment_.FastForwardBy(
      features::kFledgeStartAnticipatoryProcessExpirationTime.Get() -
      base::Milliseconds(2));
  CheckOnlyIdleProcessesWithCount(2);
  task_environment_.FastForwardBy(base::Milliseconds(1));
  CheckOnlyIdleProcessesWithCount(1);

  // Should not add a new idle process of kOriginB. We shouldn't
  // have deleted that process.
  MaybeStartAnticipatoryProcess(kOriginB, GetWorkletType());
  CheckOnlyIdleProcessesWithCount(1);

  // Should add a new idle process of kOriginA.
  MaybeStartAnticipatoryProcess(kOriginA, GetWorkletType());
  CheckOnlyIdleProcessesWithCount(2);
}

TEST_P(SitePerProcessAuctionProcessManagerTest,
       DoesNotRemoveActiveProcessAfterExpirationTime) {
  MaybeStartAnticipatoryProcess(kOriginA, GetWorkletType());
  CheckOnlyIdleProcessesWithCount(1);
  AuctionProcessManager::ProcessHandle handle;
  base::HistogramTester histogram_tester;
  RequestWorkletService(&handle, kOriginA, GetWorkletType(),
                        /*expect_success=*/true,
                        RequestWorkletServiceOutcome::kUsedIdleProcess);
  EXPECT_EQ(GetActiveProcessesOfWorkletType(), 1u);
  EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(), 0u);

  task_environment_.FastForwardBy(
      features::kFledgeStartAnticipatoryProcessExpirationTime.Get());
  EXPECT_EQ(GetActiveProcessesOfWorkletType(), 1u);
  EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(), 0u);
  histogram_tester.ExpectUniqueSample(
      "Ads.InterestGroup.Auction.IdleProcessExpired", false, 1);
}

TEST_P(SitePerProcessAuctionProcessManagerTest,
       PrioritizesReadyIdleUnboundProcess) {
  // Unbound processes are only created in the dedicated process case.
  if (GetProcessMode() != ProcessMode::kDedicated) {
    return;
  }

  MaybeStartAnticipatoryProcess(kOriginA, GetWorkletType());
  MaybeStartAnticipatoryProcess(kOriginB, GetOtherWorkletType());
  MaybeStartAnticipatoryProcess(kOriginC, GetWorkletType());
  CheckOnlyIdleProcessesWithCount(3);

  const size_t kLastCreatedProcessIndex = 2;
  SimulateReadyProcess(kLastCreatedProcessIndex);
  AuctionProcessManager::ProcessHandle handle1, handle2;
  RequestWorkletService(&handle1, kOriginA, GetWorkletType(),
                        /*expect_success=*/true,
                        RequestWorkletServiceOutcome::kUsedIdleProcess);
  EXPECT_EQ(GetActiveProcessesOfWorkletType(), 1u);
  EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(),
            kLastCreatedProcessIndex);
  EXPECT_EQ(ProcessCreationOrder(handle1), kLastCreatedProcessIndex);

  // The next best process is the first created one.
  RequestWorkletService(&handle2, kOriginB, GetWorkletType(),
                        /*expect_success=*/true,
                        RequestWorkletServiceOutcome::kUsedIdleProcess);
  EXPECT_EQ(GetActiveProcessesOfWorkletType(), 2u);
  EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(), 1u);
  EXPECT_EQ(ProcessCreationOrder(handle2), 0u);
}

TEST_P(SitePerProcessAuctionProcessManagerTest,
       PrioritizesEarliestReadyUnboundIdleProcess) {
  // Unbound processes are only created in the dedicated process case.
  if (GetProcessMode() != ProcessMode::kDedicated) {
    return;
  }

  std::vector<url::Origin> origins = {kOriginA, kOriginB, kOriginC};
  for (const auto& origin : origins) {
    MaybeStartAnticipatoryProcess(origin, GetWorkletType());
  }
  CheckOnlyIdleProcessesWithCount(3);

  for (size_t i = 0; i < origins.size(); ++i) {
    SimulateReadyProcess(i);
  }

  // Because the processes are all ready, they should be allocated in order.
  std::vector<std::unique_ptr<AuctionProcessManager::ProcessHandle>> handles;
  for (size_t i = 0; i < origins.size(); ++i) {
    handles.emplace_back(
        std::make_unique<AuctionProcessManager::ProcessHandle>());
    RequestWorkletService(handles.back().get(), origins[i], GetWorkletType(),
                          /*expect_success=*/true,
                          RequestWorkletServiceOutcome::kUsedIdleProcess);
    EXPECT_EQ(GetActiveProcessesOfWorkletType(), i + 1);
    EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(), 2 - i);
    EXPECT_EQ(ProcessCreationOrder(*handles.back()), i);
  }
}

TEST_P(SitePerProcessAuctionProcessManagerTest,
       PrioritizesReadyUnboundIdleProcessOfSameTypeIfOverLimit) {
  // Unbound processes are only created in the dedicated process case.
  if (GetProcessMode() != ProcessMode::kDedicated) {
    return;
  }

  MaybeStartAnticipatoryProcess(kOriginA, GetOtherWorkletType());
  CheckOnlyIdleProcessesWithCount(1);
  for (size_t i = 0; i < GetMaxProcesses(); ++i) {
    url::Origin origin =
        url::Origin::Create(GURL(base::StringPrintf("https://%i.test", i)));
    MaybeStartAnticipatoryProcess(origin, GetWorkletType());
    CheckOnlyIdleProcessesWithCount(2 + i);
  }
  // Both the process of the other type and the last process
  // of the same type are ready.
  SimulateReadyProcess(GetMaxProcesses());
  SimulateReadyProcess(0);

  // We are at the limit so we should use that last process.
  AuctionProcessManager::ProcessHandle handle1, handle2, handle3;
  RequestWorkletService(&handle1, kOriginA, GetWorkletType(),
                        /*expect_success=*/true,
                        RequestWorkletServiceOutcome::kUsedIdleProcess);
  EXPECT_EQ(GetActiveProcessesOfWorkletType(), 1u);
  EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(),
            GetMaxProcesses());
  EXPECT_EQ(ProcessCreationOrder(handle1), GetMaxProcesses());

  // Even though the first process is ready we have to use the same type because
  // we're at the limit.
  RequestWorkletService(&handle2, kOriginB, GetWorkletType(),
                        /*expect_success=*/true,
                        RequestWorkletServiceOutcome::kUsedIdleProcess);
  EXPECT_EQ(GetActiveProcessesOfWorkletType(), 2u);
  EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(),
            GetMaxProcesses() - 1);
  EXPECT_EQ(ProcessCreationOrder(handle2), 1u);

  // We can use the first process when we request a process for
  // GetOtherWorkletType().
  RequestWorkletService(&handle3, kOriginC, GetOtherWorkletType(),
                        /*expect_success=*/true,
                        RequestWorkletServiceOutcome::kUsedIdleProcess);
  EXPECT_EQ(GetActiveProcessesOfWorkletType(), 2u);
  EXPECT_EQ(GetActiveProcessesOfWorkletType(GetOtherWorkletType()), 1u);
  EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(),
            GetMaxProcesses() - 2);
  EXPECT_EQ(ProcessCreationOrder(handle3), 0u);
}

// Exercise the codepath where a RenderProcessHostDestroyed is received, to
// make sure it doesn't crash.
TEST_P(SitePerProcessAuctionProcessManagerTest, ProcessDeleteBeforeHandle) {
  // The process crashing case in the dedicated process world is covered by the
  // ProcessCrash test, rather than this one.
  if (GetProcessMode() == ProcessMode::kDedicated) {
    return;
  }

  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_a1 =
      GetServiceExpectSuccess(kOriginA);
  ASSERT_FALSE(rph_factory_.GetProcesses()->empty());
  for (std::unique_ptr<MockRenderProcessHost>& proc :
       *rph_factory_.GetProcesses()) {
    proc.reset();
  }
  task_environment_.RunUntilIdle();
  handle_a1.reset();
  task_environment_.RunUntilIdle();
}

TEST_P(SitePerProcessAuctionProcessManagerTest, PidLookup) {
  auto handle = GetServiceExpectSuccess(kOriginA);

  base::ProcessId expected_pid = base::Process::Current().Pid();

  // Request PID twice. Should happen asynchronously, but only use one RPC.
  base::RunLoop run_loop0, run_loop1;
  bool got_pid0 = false, got_pid1 = false;
  std::optional<base::ProcessId> pid0 =
      handle->GetPid(base::BindLambdaForTesting(
          [&run_loop0, &got_pid0, expected_pid](base::ProcessId pid) {
            EXPECT_EQ(expected_pid, pid);
            got_pid0 = true;
            run_loop0.Quit();
          }));
  EXPECT_FALSE(pid0.has_value());
  std::optional<base::ProcessId> pid1 =
      handle->GetPid(base::BindLambdaForTesting(
          [&run_loop1, &got_pid1, expected_pid](base::ProcessId pid) {
            EXPECT_EQ(expected_pid, pid);
            got_pid1 = true;
            run_loop1.Quit();
          }));
  EXPECT_FALSE(pid1.has_value());

  if (dedicated_process_manager_) {
    SimulateReadyProcess(/*creation_index=*/0);
  } else {
    for (std::unique_ptr<MockRenderProcessHost>& proc :
         *rph_factory_.GetProcesses()) {
      proc->SimulateReady();
    }
  }

  run_loop0.Run();
  EXPECT_TRUE(got_pid0);
  run_loop1.Run();
  EXPECT_TRUE(got_pid1);

  // Next attempt should be synchronous.
  std::optional<base::ProcessId> pid2 =
      handle->GetPid(base::BindOnce([](base::ProcessId pid) {
        ADD_FAILURE() << "Should not get to callback in pid2 case";
      }));
  EXPECT_EQ(expected_pid, pid2);

  // Reusing the process with another handle should also result in synchronous
  // PID lookups.
  auto handle2 = GetServiceExpectSuccess(kOriginA);
  std::optional<base::ProcessId> pid3 =
      handle2->GetPid(base::BindOnce([](base::ProcessId pid) {
        ADD_FAILURE() << "Should not get to callback in pid2 case";
      }));
  EXPECT_EQ(expected_pid, pid3);
}

TEST_P(SitePerProcessAuctionProcessManagerTest,
       PidLookupRendererProcessAlreadyRunning) {
  // There's no analog to a renderer process already existing in the dedicated
  // process world.
  if (GetProcessMode() == ProcessMode::kDedicated) {
    return;
  }

  // "Launch" the appropriate process before we even ask for it, and mark its
  // launch as completed. |frame_site_instance| will help keep it alive.
  scoped_refptr<SiteInstance> frame_site_instance =
      site_instance1_->GetRelatedSiteInstance(kOriginA.GetURL());
  frame_site_instance->GetOrCreateProcessForTesting()->Init();
  for (std::unique_ptr<MockRenderProcessHost>& proc :
       *rph_factory_.GetProcesses()) {
    proc->SimulateReady();
  }

  auto handle = GetServiceOfTypeExpectSuccess(GetWorkletType(), kOriginA,
                                              frame_site_instance);

  base::ProcessId expected_pid = base::Process::Current().Pid();

  // Request PID twice. Should happen asynchronously, but only use one RPC.
  std::optional<base::ProcessId> pid0 =
      handle->GetPid(base::BindOnce([](base::ProcessId pid) {
        ADD_FAILURE() << "Should not get to callback in pid0 case";
      }));
  ASSERT_TRUE(pid0.has_value());
  EXPECT_EQ(expected_pid, pid0.value());
  std::optional<base::ProcessId> pid1 =
      handle->GetPid(base::BindOnce([](base::ProcessId pid) {
        ADD_FAILURE() << "Should not get to callback in pid1 case";
      }));
  ASSERT_TRUE(pid1.has_value());
  EXPECT_EQ(expected_pid, pid1.value());
}

TEST_P(SharedRendererInRendererAuctionProcessManagerTest,
       MultipleSiteInstances) {
  base::HistogramTester histogram_tester;

  // Launch some services in different origins and browsing instances.
  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_a1 =
      GetServiceOfTypeExpectSuccess(GetWorkletType(), kOriginA,
                                    site_instance1_);
  int id_a1 = handle_a1->GetRenderProcessHostForTesting()->GetDeprecatedID();

  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_a2 =
      GetServiceOfTypeExpectSuccess(GetWorkletType(), kOriginA,
                                    site_instance2_);
  int id_a2 = handle_a2->GetRenderProcessHostForTesting()->GetDeprecatedID();

  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_b1 =
      GetServiceOfTypeExpectSuccess(GetWorkletType(), kOriginB,
                                    site_instance1_);
  int id_b1 = handle_b1->GetRenderProcessHostForTesting()->GetDeprecatedID();

  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_b2 =
      GetServiceOfTypeExpectSuccess(GetWorkletType(), kOriginB,
                                    site_instance2_);
  int id_b2 = handle_b2->GetRenderProcessHostForTesting()->GetDeprecatedID();

  // Non-site-isolation requiring origins can share processes, but not across
  // different browsing instances.
  EXPECT_NE(id_a1, id_a2);
  EXPECT_EQ(id_a1, id_b1);
  EXPECT_NE(id_a1, id_b2);
  EXPECT_NE(id_a2, id_b1);
  EXPECT_EQ(id_a2, id_b2);
  EXPECT_NE(id_b1, id_b2);
  histogram_tester.ExpectUniqueSample(
      RequestWorkletServiceOutcomeUmaName(),
      RequestWorkletServiceOutcome::kUsedSharedProcess, 4);

  // Site-isolation requiring origins are distinct from non-isolated ones, but
  // can share across browsing instances.
  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_i1 =
      GetServiceOfTypeExpectSuccess(GetWorkletType(), kIsolatedOrigin,
                                    site_instance1_);
  int id_i1 = handle_i1->GetRenderProcessHostForTesting()->GetDeprecatedID();

  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_i2 =
      GetServiceOfTypeExpectSuccess(GetWorkletType(), kIsolatedOrigin,
                                    site_instance2_);
  int id_i2 = handle_i2->GetRenderProcessHostForTesting()->GetDeprecatedID();

  EXPECT_EQ(id_i1, id_i2);
  EXPECT_NE(id_i1, id_a1);
  EXPECT_NE(id_i1, id_a2);
  EXPECT_NE(id_i1, id_b1);
  EXPECT_NE(id_i1, id_b2);
  histogram_tester.ExpectBucketCount(
      RequestWorkletServiceOutcomeUmaName(),
      RequestWorkletServiceOutcome::kCreatedNewDedicatedProcess, 1);
  histogram_tester.ExpectBucketCount(
      RequestWorkletServiceOutcomeUmaName(),
      RequestWorkletServiceOutcome::kUsedExistingDedicatedProcess, 1);
}

// Test that anticipatory processes are not created for origins that can use the
// shared renderer process.
TEST_P(SharedRendererInRendererAuctionProcessManagerTest,
       MaybeStartAnticipatoryProcess_DoesNotStartIfSharedProcessPossible) {
  MaybeStartAnticipatoryProcess(kOriginA, GetWorkletType());
  CheckOnlyIdleProcessesWithCount(0);
}

// Test that anticipatory processes can be created for isolated origins.
TEST_P(SharedRendererInRendererAuctionProcessManagerTest,
       MaybeStartAnticipatoryProcess_StartsProcessForIsolatedOrigin) {
  MaybeStartAnticipatoryProcess(kIsolatedOrigin);
  CheckOnlyIdleProcessesWithCount(1);

  // Don't use this process for an origin that can use a shared process.
  AuctionProcessManager::ProcessHandle handle1, handle2;
  RequestWorkletService(&handle1, kOriginA, GetWorkletType(),
                        /*expect_success=*/true,
                        RequestWorkletServiceOutcome::kUsedSharedProcess);
  CheckOnlyIdleProcessesWithCount(1);

  // Can use this process for the same isolated origin.
  RequestWorkletService(&handle2, kIsolatedOrigin, GetWorkletType(),
                        /*expect_success=*/true,
                        RequestWorkletServiceOutcome::kUsedIdleProcess);
  EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(), 0u);
  EXPECT_EQ(GetActiveProcessesOfWorkletType(GetWorkletType()), 1u);
}

// Tests the site-per-process sharing model, focusing on the multiple
// SiteInstances case, which should not affect process sharing.
TEST_P(SitePerProcessAuctionProcessManagerTest, MultipleSiteInstances) {
  base::HistogramTester histogram_tester;

  // Launch some services in different origins and browsing instances.
  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_a1 =
      GetServiceOfTypeExpectSuccess(GetWorkletType(), kOriginA,
                                    site_instance1_);
  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_a2 =
      GetServiceOfTypeExpectSuccess(GetWorkletType(), kOriginA,
                                    site_instance2_);
  // Despite having different SiteInstances, `handle_a1` and `handle_a2` should
  // share the same process and service, since they share an origin.
  EXPECT_EQ(handle_a1->worklet_process_for_testing(),
            handle_a2->worklet_process_for_testing());
  EXPECT_EQ(handle_a1->GetService(), handle_a2->GetService());

  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_b1 =
      GetServiceOfTypeExpectSuccess(GetWorkletType(), kOriginB,
                                    site_instance1_);
  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_b2 =
      GetServiceOfTypeExpectSuccess(GetWorkletType(), kOriginB,
                                    site_instance2_);
  // Similarly, `handle_b1` and `handle_b2` should share a process and service.
  EXPECT_EQ(handle_b1->worklet_process_for_testing(),
            handle_b2->worklet_process_for_testing());
  EXPECT_EQ(handle_b1->GetService(), handle_b2->GetService());

  // Since sites are partitioned by origin, the `a` handles and `b` handles
  // should use different processes and services.
  EXPECT_NE(handle_a1->worklet_process_for_testing(),
            handle_b1->worklet_process_for_testing());
  EXPECT_NE(handle_a1->GetService(), handle_b1->GetService());

  // If using InRendererMode, they should also use different RenderProcessHosts.
  if (GetProcessMode() != ProcessMode::kDedicated) {
    EXPECT_NE(handle_a1->GetRenderProcessHostForTesting()->GetDeprecatedID(),
              handle_b1->GetRenderProcessHostForTesting()->GetDeprecatedID());
  }

  histogram_tester.ExpectBucketCount(
      RequestWorkletServiceOutcomeUmaName(),
      RequestWorkletServiceOutcome::kCreatedNewDedicatedProcess, 2);
  histogram_tester.ExpectBucketCount(
      RequestWorkletServiceOutcomeUmaName(),
      RequestWorkletServiceOutcome::kUsedExistingDedicatedProcess, 2);

  // Stuff that's also isolated by explicit requests gets the same treatment.
  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_i1 =
      GetServiceOfTypeExpectSuccess(GetWorkletType(), kIsolatedOrigin,
                                    site_instance1_);
  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_i2 =
      GetServiceOfTypeExpectSuccess(GetWorkletType(), kIsolatedOrigin,
                                    site_instance2_);
  EXPECT_EQ(handle_i1->worklet_process_for_testing(),
            handle_i2->worklet_process_for_testing());
  EXPECT_EQ(handle_i1->GetService(), handle_i2->GetService());

  // If using InRendererMode, they should also use different RenderProcessHosts.
  if (GetProcessMode() != ProcessMode::kDedicated) {
    EXPECT_NE(handle_i1->GetRenderProcessHostForTesting()->GetDeprecatedID(),
              handle_a1->GetRenderProcessHostForTesting()->GetDeprecatedID());
    EXPECT_NE(handle_i1->GetRenderProcessHostForTesting()->GetDeprecatedID(),
              handle_b1->GetRenderProcessHostForTesting()->GetDeprecatedID());
  }

  histogram_tester.ExpectBucketCount(
      RequestWorkletServiceOutcomeUmaName(),
      RequestWorkletServiceOutcome::kCreatedNewDedicatedProcess, 3);
  histogram_tester.ExpectBucketCount(
      RequestWorkletServiceOutcomeUmaName(),
      RequestWorkletServiceOutcome::kUsedExistingDedicatedProcess, 3);
}

TEST_P(SharedRendererInRendererAuctionProcessManagerTest, PolicyChange) {
  // Launch site in default instance.
  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_a1 =
      GetServiceOfTypeExpectSuccess(GetWorkletType(), kOriginA,
                                    site_instance1_);
  EXPECT_FALSE(
      handle_a1->site_instance_for_testing()->RequiresDedicatedProcess());
  RenderProcessHost* shared_process =
      handle_a1->GetRenderProcessHostForTesting();

  // Change policy so that A can no longer use shared instances.
  SiteInstance::StartIsolatingSite(
      &test_browser_context_, kOriginA.GetURL(),
      ChildProcessSecurityPolicy::IsolatedOriginSource::TEST);
  site_instance1_ = SiteInstance::Create(&test_browser_context_);

  // Launch another A-origin worklet, this should get a different process.
  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_a2 =
      GetServiceOfTypeExpectSuccess(GetWorkletType(), kOriginA,
                                    site_instance1_);
  EXPECT_TRUE(
      handle_a2->site_instance_for_testing()->RequiresDedicatedProcess());
  EXPECT_NE(handle_a2->GetRenderProcessHostForTesting(), shared_process);

  // Destroy shared process and try to get another A one --- should reuse the
  // same non-shared process.
  handle_a1.reset();
  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_a3 =
      GetServiceOfTypeExpectSuccess(GetWorkletType(), kOriginA,
                                    site_instance1_);
  EXPECT_TRUE(
      handle_a3->site_instance_for_testing()->RequiresDedicatedProcess());
  EXPECT_EQ(handle_a2->GetRenderProcessHostForTesting(),
            handle_a3->GetRenderProcessHostForTesting());
  // Checking GetRenderProcessHostForTesting isn't enough since SiteInstance
  // can share it, too.
  EXPECT_EQ(handle_a2->worklet_process_for_testing(),
            handle_a3->worklet_process_for_testing());
}

TEST_P(SitePerProcessAuctionProcessManagerTest, TrustedSignalsCache) {
  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_a1 =
      GetServiceExpectSuccess(kOriginA);
  ValidateCacheRemote(*handle_a1, kOriginA);

  // Creating another handle to the same process should not result in another
  // cache pipe being passed to the AuctionWorkletService.
  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_a2 =
      GetServiceExpectSuccess(kOriginA);
  EXPECT_EQ(handle_a1->GetService(), handle_a2->GetService());
  // Cache remote should still be live.
  ValidateCacheRemote(*handle_a2, kOriginA);

  // Requesting a service from a different origin, however, results in a cache
  // pipe being passed to the new AuctionWorkletService.
  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_b =
      GetServiceExpectSuccess(kOriginB);
  EXPECT_NE(handle_a1->GetService(), handle_b->GetService());
  ValidateCacheRemote(*handle_b, kOriginB);
}

TEST_P(SitePerProcessAuctionProcessManagerTest,
       TrustedSignalsCacheSentToAnticipatoryProcess) {
  // Creating an anticipatory process and then getting a handle to it should
  // result in a cache pipe being sent to the AuctionWorkletService.
  MaybeStartAnticipatoryProcess(kOriginA);
  // This should not send a second cache pipe to the process.
  MaybeStartAnticipatoryProcess(kOriginA);

  EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(), 1u);
  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_a1 =
      GetServiceExpectSuccess(kOriginA);
  ValidateCacheRemote(*handle_a1, kOriginA);
  // Make sure the anticipatory process was actually used.
  EXPECT_EQ(auction_process_manager_->GetIdleProcessCountForTesting(), 0u);

  // Creating another handle to the same process should not result in another
  // cache pipe being passed to the AuctionWorkletService.
  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_a2 =
      GetServiceExpectSuccess(kOriginA);
  EXPECT_EQ(handle_a1->GetService(), handle_a2->GetService());
  ValidateCacheRemote(*handle_a2, kOriginA);

  // Trying to create an anticipatory process matching the existing process
  // should do nothing, including not sending a new pipe to the process.
  MaybeStartAnticipatoryProcess(kOriginA);
  ValidateCacheRemote(*handle_a1, kOriginA);
}

// Test that no cache pipe is sent, and there is no crash, when the trusted
// signals cache is disabled.
TEST_P(SitePerProcessAuctionProcessManagerTest, TrustedSignalsCacheDisabled) {
  // Create a new AuctionProcessManager without a TrustedSignalsCache.
  CreateAuctionProcessManager(/*trusted_signals_cache=*/nullptr);

  // Check there's no trusted signals cache in the base case.
  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_a =
      GetServiceExpectSuccess(kOriginA);
  ExpectNoCacheRemote(*handle_a);

  // Check there's no trusted siganls cache when creating anticipatory
  // processes.
  MaybeStartAnticipatoryProcess(kOriginB);
  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_b =
      GetServiceExpectSuccess(kOriginB);
  ExpectNoCacheRemote(*handle_b);
}

// Test the single shared renderer process case. Since anticipatory processes
// aren't created in that case, don't bother testing that case.
TEST_P(SharedRendererInRendererAuctionProcessManagerTest, TrustedSignalsCache) {
  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_a1 =
      GetServiceExpectSuccess(kOriginA);
  ValidateCacheRemote(*handle_a1, kOriginA);

  // Creating another handle with the same origin results in a pipe, instead of
  // reusing the old one, and a new cache remote should be passed to it.
  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_a2 =
      GetServiceExpectSuccess(kOriginA);
  EXPECT_NE(handle_a1->GetService(), handle_a2->GetService());
  ValidateCacheRemote(*handle_a2, kOriginA);

  // Requesting a service from a different origin, however, results in a cache
  // pipe being passed to the new AuctionWorkletService.
  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle_b =
      GetServiceExpectSuccess(kOriginB);
  ValidateCacheRemote(*handle_b, kOriginB);
}

// Test that no cache pipe is sent, and there is no crash, when the trusted
// signals cache is disabled.
TEST_P(SharedRendererInRendererAuctionProcessManagerTest,
       TrustedSignalsCacheDisabled) {
  // Create a new AuctionProcessManager without a TrustedSignalsCache.
  CreateAuctionProcessManager(/*trusted_signals_cache=*/nullptr);

  std::unique_ptr<AuctionProcessManager::ProcessHandle> handle =
      GetServiceExpectSuccess(kOriginA);
  ExpectNoCacheRemote(*handle);
}

}  // namespace
}  // namespace content