TestPDMFactorySupport.cpp

Enable keyboard shortcuts

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "PDMFactorySupport.h"

#include "VideoUtils.h"

#include "gtest/gtest.h"

#include "mozilla/Preferences.h"

#include "mozilla/SpinEventLoopUntil.h"

#include "mozilla/TaskQueue.h"

#include "mozilla/gfx/gfxVars.h"

#include "mozilla/gtest/WaitFor.h"

using namespace mozilla;

// Lazy construction: first `Instance()` builds, repeated calls share the same

// underlying object until something invalidates it.

TEST(PDMFactorySupport, LazyConstruction)

  PDMFactorySupport::Invalidate();

  RefPtr<PDMFactorySupport> first = PDMFactorySupport::Instance();

  RefPtr<PDMFactorySupport> second = PDMFactorySupport::Instance();

  EXPECT_TRUE(first);

  EXPECT_TRUE(second);

  EXPECT_EQ(first.get(), second.get());

// Toggling a registered pref must drop the cached instance so the next

// `Instance()` call rebuilds it.

TEST(PDMFactorySupport, PrefChangeInvalidatesCache)

  PDMFactorySupport::Invalidate();

  RefPtr<PDMFactorySupport> before = PDMFactorySupport::Instance();

  ASSERT_TRUE(before);

  const bool original = Preferences::GetBool("media.use-blank-decoder", false);

  Preferences::SetBool("media.use-blank-decoder", !original);

  RefPtr<PDMFactorySupport> after = PDMFactorySupport::Instance();

  EXPECT_TRUE(after);

  EXPECT_NE(before.get(), after.get());

  Preferences::SetBool("media.use-blank-decoder", original);

// Toggling a registered `gfxVar` must drop the cached instance so the next

// `Instance()` call rebuilds it. The hardware-decoding `gfxVar` is registered

// on every platform.

TEST(PDMFactorySupport, GfxVarChangeInvalidatesCache)

  if (!gfx::gfxVars::IsInitialized()) {

    GTEST_SKIP() << "gfxVars not initialized in this gtest environment";

  PDMFactorySupport::Invalidate();

  RefPtr<PDMFactorySupport> before = PDMFactorySupport::Instance();

  ASSERT_TRUE(before);

  const bool original = gfx::gfxVars::CanUseHardwareVideoDecoding();

  gfx::gfxVars::SetCanUseHardwareVideoDecoding(!original);

  RefPtr<PDMFactorySupport> after = PDMFactorySupport::Instance();

  EXPECT_TRUE(after);

  EXPECT_NE(before.get(), after.get());

  gfx::gfxVars::SetCanUseHardwareVideoDecoding(original);

// Concurrent first calls from multiple threads must all converge on the same

// instance. With a single registration of pref/`gfxVar` listeners, no double

// registration occurs.

TEST(PDMFactorySupport, ConcurrentInstanceCalls)

  PDMFactorySupport::Invalidate();

  constexpr int kThreads = 4;

  AutoTArray<RefPtr<TaskQueue>, kThreads> queues;

  AutoTArray<RefPtr<GenericPromise>, kThreads> promises;

  AutoTArray<RefPtr<PDMFactorySupport>, kThreads> results;

  results.SetLength(kThreads);

  for (int i = 0; i < kThreads; ++i) {

    queues.AppendElement(

        TaskQueue::Create(GetMediaThreadPool(MediaThreadType::SUPERVISOR),

                          "TestPDMFactorySupportConcurrent"));

    promises.AppendElement(InvokeAsync(queues[i], __func__, [&results, i]() {

      results[i] = PDMFactorySupport::Instance();

      return GenericPromise::CreateAndResolve(true, __func__);

    }));

  (void)WaitFor(

      GenericPromise::All(GetMainThreadSerialEventTarget(), promises));

  for (int i = 0; i < kThreads; ++i) {

    queues[i]->BeginShutdown();

    queues[i]->AwaitShutdownAndIdle();

    EXPECT_TRUE(results[i]);

  for (int i = 1; i < kThreads; ++i) {

    EXPECT_EQ(results[0].get(), results[i].get());

// `Invalidate()` is the public path used by `PDMFactory::Supported(true)`

// after a GPU-process restart and by tests that swap the environment.

TEST(PDMFactorySupport, ExplicitInvalidate)

  PDMFactorySupport::Invalidate();

  RefPtr<PDMFactorySupport> first = PDMFactorySupport::Instance();

  ASSERT_TRUE(first);

  PDMFactorySupport::Invalidate();

  RefPtr<PDMFactorySupport> second = PDMFactorySupport::Instance();

  ASSERT_TRUE(second);

  EXPECT_NE(first.get(), second.get());

// A `RefPtr` taken before invalidation must remain alive past the

// invalidation. The held instance is released on scope exit; if its

// underlying object had been freed by the singleton swap, the `Release()`

// call would touch freed memory and crash under ASAN.

TEST(PDMFactorySupport, StaleReferenceSurvivesInvalidation)

  PDMFactorySupport::Invalidate();

  RefPtr<PDMFactorySupport> stale = PDMFactorySupport::Instance();

  ASSERT_TRUE(stale);

  PDMFactorySupport::Invalidate();

  RefPtr<PDMFactorySupport> fresh = PDMFactorySupport::Instance();

  ASSERT_TRUE(fresh);

  EXPECT_NE(stale.get(), fresh.get());

// `Invalidate()` may fire concurrently with `Instance()` — pref and `gfxVar`

// listeners run on whatever thread triggered the change, and that thread can

// race with another caller currently building the inner factory. This test

// stress-tests that interleaving: a worker thread floods `Invalidate()` while

// the main thread repeatedly calls `Instance()`. Every returned `RefPtr` must

// be valid and queryable, and once the storm is over, the next `Instance()`

// call drains the lingering staleness so two back-to-back calls after the

// storm share the same underlying object.

TEST(PDMFactorySupport, ConcurrentInvalidateAndInstance)

  PDMFactorySupport::Invalidate();

  RefPtr<PDMFactorySupport> seed = PDMFactorySupport::Instance();

  ASSERT_TRUE(seed);

  // Worker thread floods `Invalidate()` for the duration of the test.

  Atomic<bool> stop{false};

  RefPtr<TaskQueue> invalidator =

      TaskQueue::Create(GetMediaThreadPool(MediaThreadType::SUPERVISOR),

                        "TestPDMFactorySupportInvalidator");

  RefPtr<GenericPromise> invalidatorDone =

      InvokeAsync(invalidator, __func__, [&stop]() {

        while (!stop) {

          PDMFactorySupport::Invalidate();

        return GenericPromise::CreateAndResolve(true, __func__);

});

  // Main thread hammers `Instance()` while invalidations stream in. Every

  // returned instance must be non-null and survive its scope.

  for (int i = 0; i < 200; ++i) {

    RefPtr<PDMFactorySupport> got = PDMFactorySupport::Instance();

    ASSERT_TRUE(got);

  stop = true;

  (void)WaitFor(invalidatorDone);

  invalidator->BeginShutdown();

  invalidator->AwaitShutdownAndIdle();

  // After the storm, two consecutive `Instance()` calls must return the same

  // pointer — confirming `sStale` is fully drained on `Instance()` return.

  PDMFactorySupport::Invalidate();

  RefPtr<PDMFactorySupport> a = PDMFactorySupport::Instance();

  RefPtr<PDMFactorySupport> b = PDMFactorySupport::Instance();

  ASSERT_TRUE(a);

  ASSERT_TRUE(b);

  EXPECT_EQ(a.get(), b.get());

// Calling `Instance()` from a non-main thread must complete the listener

// registration via `SyncRunnable` and return a valid instance.

TEST(PDMFactorySupport, OffMainThreadInstance)

  PDMFactorySupport::Invalidate();

  RefPtr<TaskQueue> taskQueue =

      TaskQueue::Create(GetMediaThreadPool(MediaThreadType::SUPERVISOR),

                        "TestPDMFactorySupportOffMainThread");

  RefPtr<PDMFactorySupport> result;

  (void)WaitFor(InvokeAsync(taskQueue, __func__, [&result]() {

    result = PDMFactorySupport::Instance();

    return GenericPromise::CreateAndResolve(true, __func__);

  }));

  taskQueue->BeginShutdown();

  taskQueue->AwaitShutdownAndIdle();

  EXPECT_TRUE(result);