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

#include "media/gpu/android/codec_allocator.h"

#include <stdint.h>

#include <memory>

#include "base/check.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/memory/raw_ptr.h"
#include "base/task/sequenced_task_runner.h"
#include "base/task/single_thread_task_runner.h"
#include "base/test/simple_test_tick_clock.h"
#include "base/test/task_environment.h"
#include "base/threading/thread.h"
#include "base/time/tick_clock.h"
#include "base/time/time.h"
#include "media/base/android/mock_media_codec_bridge.h"
#include "media/base/subsample_entry.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

using testing::_;
using testing::Invoke;
using testing::NiceMock;
using testing::ReturnRef;

namespace media {

class CodecAllocatorTest : public testing::Test {
 public:
  CodecAllocatorTest() : allocator_thread_("AllocatorThread") {
    // Don't start the clock at null.
    tick_clock_.Advance(base::Seconds(1));
    allocator_ = new CodecAllocator(
        base::BindRepeating(&MockMediaCodecBridge::CreateVideoDecoder),
        base::SequencedTaskRunner::GetCurrentDefault());
    allocator_->tick_clock_ = &tick_clock_;
  }

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

  ~CodecAllocatorTest() override {
    if (allocator_thread_.IsRunning()) {
      // Don't leave any threads hung, or this will hang too. It would be nice
      // if we could let a unique ptr handle this, but the destructor is
      // private.  We also have to destroy it on the right thread.
      allocator_thread_.task_runner()->PostTask(
          FROM_HERE,
          base::BindOnce([](CodecAllocator* allocator) { delete allocator; },
                         allocator_));

      allocator_thread_.Stop();
      return;
    }

    delete allocator_;
  }

  void CreateAllocatorOnAnotherThread() {
    delete allocator_;

    // Start a thread for the allocator.  This would normally be the GPU main
    // thread.
    CHECK(allocator_thread_.Start());
    allocator_ = new CodecAllocator(
        base::BindRepeating(&MockMediaCodecBridge::CreateVideoDecoder),
        allocator_thread_.task_runner());
    allocator_->tick_clock_ = &tick_clock_;
  }

  void OnCodecCreatedInternal(base::OnceClosure quit_closure,
                              std::unique_ptr<MediaCodecBridge> codec) {
    // This should always be called on the main thread, despite whatever thread
    // the allocator happens to be running on.
    ASSERT_TRUE(
        task_environment_.GetMainThreadTaskRunner()->BelongsToCurrentThread());

    last_created_codec_.reset(
        reinterpret_cast<MockMediaCodecBridge*>(codec.release()));

    OnCodecCreated(last_created_codec_->GetCodecType());
    std::move(quit_closure).Run();
  }

  void OnCodecReleasedInternal(base::OnceClosure quit_closure) {
    // This should always be called on the main thread, despite whatever thread
    // the allocator happens to be running on.
    ASSERT_TRUE(
        task_environment_.GetMainThreadTaskRunner()->BelongsToCurrentThread());
    OnCodecReleased();
    std::move(quit_closure).Run();
  }

  bool IsPrimaryTaskRunnerLikelyHung() const {
    CHECK(!allocator_thread_.IsRunning());
    return allocator_->IsPrimaryTaskRunnerLikelyHung();
  }

  void VerifyOnPrimaryTaskRunner() {
    ASSERT_TRUE(allocator_->primary_task_runner_->RunsTasksInCurrentSequence());
  }

  void VerifyOnSecondaryTaskRunner() {
    ASSERT_TRUE(
        allocator_->secondary_task_runner_->RunsTasksInCurrentSequence());
  }

  MOCK_METHOD1(OnCodecCreated, void(CodecType));
  MOCK_METHOD0(OnCodecReleased, void());

  // Allocate and return a config that allows any codec, and is suitable for
  // hardware decode.
  std::unique_ptr<VideoCodecConfig> CreateConfig() {
    auto config = std::make_unique<VideoCodecConfig>();
    config->codec_type = CodecType::kAny;
    config->initial_expected_coded_size =
        CodecAllocator::kMinHardwareResolution;
    return config;
  }

 protected:
  // So that we can get the thread's task runner.
  base::test::TaskEnvironment task_environment_;

  base::Thread allocator_thread_;

  // The test params for |allocator_|.
  base::SimpleTestTickClock tick_clock_;

  // Allocators that we own. They are not unique_ptrs because the destructor is
  // private and they need to be destructed on the right thread.
  raw_ptr<CodecAllocator> allocator_ = nullptr;

  std::unique_ptr<MockMediaCodecBridge> last_created_codec_;
};

TEST_F(CodecAllocatorTest, NormalCreation) {
  ASSERT_FALSE(IsPrimaryTaskRunnerLikelyHung());

  auto config = CreateConfig();

  base::RunLoop run_loop;
  allocator_->CreateMediaCodecAsync(
      base::BindOnce(&CodecAllocatorTest::OnCodecCreatedInternal,
                     base::Unretained(this), run_loop.QuitClosure()),
      std::move(config));

  EXPECT_CALL(*this, OnCodecCreated(CodecType::kAny));
  run_loop.Run();
  ASSERT_FALSE(IsPrimaryTaskRunnerLikelyHung());
}

TEST_F(CodecAllocatorTest, NormalSecureCreation) {
  ASSERT_FALSE(IsPrimaryTaskRunnerLikelyHung());

  auto config = CreateConfig();
  config->codec_type = CodecType::kSecure;

  base::RunLoop run_loop;
  allocator_->CreateMediaCodecAsync(
      base::BindOnce(&CodecAllocatorTest::OnCodecCreatedInternal,
                     base::Unretained(this), run_loop.QuitClosure()),
      std::move(config));

  EXPECT_CALL(*this, OnCodecCreated(CodecType::kSecure));
  run_loop.Run();
  ASSERT_FALSE(IsPrimaryTaskRunnerLikelyHung());
}

TEST_F(CodecAllocatorTest, MultipleCreation) {
  ASSERT_FALSE(IsPrimaryTaskRunnerLikelyHung());

  auto config = CreateConfig();

  base::RunLoop run_loop;
  allocator_->CreateMediaCodecAsync(
      base::BindOnce(&CodecAllocatorTest::OnCodecCreatedInternal,
                     base::Unretained(this), base::DoNothing()),
      std::move(config));

  // Advance some time, but not enough to trigger hang detection.
  ASSERT_FALSE(IsPrimaryTaskRunnerLikelyHung());
  tick_clock_.Advance(base::Milliseconds(400));
  ASSERT_FALSE(IsPrimaryTaskRunnerLikelyHung());

  auto config_secure = CreateConfig();
  config_secure->codec_type = CodecType::kSecure;

  allocator_->CreateMediaCodecAsync(
      base::BindOnce(&CodecAllocatorTest::OnCodecCreatedInternal,
                     base::Unretained(this), run_loop.QuitClosure()),
      std::move(config_secure));

  EXPECT_CALL(*this, OnCodecCreated(CodecType::kAny));
  EXPECT_CALL(*this, OnCodecCreated(CodecType::kSecure));

  run_loop.Run();
  ASSERT_FALSE(IsPrimaryTaskRunnerLikelyHung());
}

TEST_F(CodecAllocatorTest, MultipleRelease) {
  ASSERT_FALSE(IsPrimaryTaskRunnerLikelyHung());

  base::RunLoop run_loop;
  allocator_->ReleaseMediaCodec(
      std::make_unique<MockMediaCodecBridge>(),
      base::BindOnce(&CodecAllocatorTest::OnCodecReleasedInternal,
                     base::Unretained(this), base::DoNothing()));

  // Advance some time, but not enough to trigger hang detection.
  ASSERT_FALSE(IsPrimaryTaskRunnerLikelyHung());
  tick_clock_.Advance(base::Milliseconds(400));
  ASSERT_FALSE(IsPrimaryTaskRunnerLikelyHung());

  allocator_->ReleaseMediaCodec(
      std::make_unique<MockMediaCodecBridge>(),
      base::BindOnce(&CodecAllocatorTest::OnCodecReleasedInternal,
                     base::Unretained(this), run_loop.QuitClosure()));

  EXPECT_CALL(*this, OnCodecReleased()).Times(2);

  run_loop.Run();
  ASSERT_FALSE(IsPrimaryTaskRunnerLikelyHung());
}

TEST_F(CodecAllocatorTest, StalledReleaseCountsAsHung) {
  ASSERT_FALSE(IsPrimaryTaskRunnerLikelyHung());

  // Release null codec, but don't pump message loop.
  allocator_->ReleaseMediaCodec(std::make_unique<MockMediaCodecBridge>(),
                                base::DoNothing());
  tick_clock_.Advance(base::Seconds(1));
  ASSERT_TRUE(IsPrimaryTaskRunnerLikelyHung());
}

TEST_F(CodecAllocatorTest, StalledCreateCountsAsHung) {
  ASSERT_FALSE(IsPrimaryTaskRunnerLikelyHung());

  // Create codec, but don't pump message loop.
  auto config = CreateConfig();
  config->codec_type = CodecType::kSecure;
  allocator_->CreateMediaCodecAsync(base::DoNothing(), std::move(config));
  tick_clock_.Advance(base::Seconds(1));
  ASSERT_TRUE(IsPrimaryTaskRunnerLikelyHung());
}

TEST_F(CodecAllocatorTest, SecureCreationFailsWhenHung) {
  ASSERT_FALSE(IsPrimaryTaskRunnerLikelyHung());

  // Release null codec, but don't pump message loop.
  allocator_->ReleaseMediaCodec(std::make_unique<MockMediaCodecBridge>(),
                                base::DoNothing());
  tick_clock_.Advance(base::Seconds(1));
  ASSERT_TRUE(IsPrimaryTaskRunnerLikelyHung());

  // Secure creation should fail since we're now using software codecs.
  auto config = CreateConfig();
  config->codec_type = CodecType::kSecure;
  base::RunLoop run_loop;
  allocator_->CreateMediaCodecAsync(
      base::BindOnce(
          [](base::OnceClosure quit_closure,
             std::unique_ptr<MediaCodecBridge> codec) {
            ASSERT_FALSE(codec);
            std::move(quit_closure).Run();
          },
          run_loop.QuitClosure()),
      std::move(config));
  run_loop.Run();

  // QuitClosure may run before the initial release processes, so RunUntilIdle
  // here such that hung status is cleared.
  task_environment_.RunUntilIdle();

  // Running the loop should clear hung status.
  ASSERT_FALSE(IsPrimaryTaskRunnerLikelyHung());
}

TEST_F(CodecAllocatorTest, SoftwareCodecUsedWhenHung) {
  ASSERT_FALSE(IsPrimaryTaskRunnerLikelyHung());

  // Release null codec, but don't pump message loop.
  allocator_->ReleaseMediaCodec(std::make_unique<MockMediaCodecBridge>(),
                                base::DoNothing());
  tick_clock_.Advance(base::Seconds(1));
  ASSERT_TRUE(IsPrimaryTaskRunnerLikelyHung());

  // Creation should fall back to software.
  auto config = CreateConfig();
  base::RunLoop run_loop;
  allocator_->CreateMediaCodecAsync(
      base::BindOnce(&CodecAllocatorTest::OnCodecCreatedInternal,
                     base::Unretained(this), run_loop.QuitClosure()),
      std::move(config));

  EXPECT_CALL(*this, OnCodecCreated(CodecType::kSoftware));
  run_loop.Run();

  // QuitClosure may run before the initial release processes, so RunUntilIdle
  // here such that hung status is cleared.
  task_environment_.RunUntilIdle();

  // Running the loop should clear hung status.
  ASSERT_FALSE(IsPrimaryTaskRunnerLikelyHung());
}

// Verifies that software codecs are released on the secondary task runner when
// hung and that non-sw codecs are always released on the primary task runner.
TEST_F(CodecAllocatorTest, CodecReleasedOnRightTaskRunnerWhenHung) {
  ASSERT_FALSE(IsPrimaryTaskRunnerLikelyHung());

  // Release null codec, but don't pump message loop.
  allocator_->ReleaseMediaCodec(std::make_unique<MockMediaCodecBridge>(),
                                base::DoNothing());
  tick_clock_.Advance(base::Seconds(1));
  ASSERT_TRUE(IsPrimaryTaskRunnerLikelyHung());

  // Release software codec, ensure it runs on secondary task runner.
  auto config = CreateConfig();
  config->codec_type = CodecType::kSoftware;
  auto sw_codec = MockMediaCodecBridge::CreateVideoDecoder(*config);
  reinterpret_cast<MockMediaCodecBridge*>(sw_codec.get())
      ->destruction_cb.ReplaceClosure(
          base::BindOnce(&CodecAllocatorTest::VerifyOnSecondaryTaskRunner,
                         base::Unretained(this)));
  allocator_->ReleaseMediaCodec(std::move(sw_codec), base::DoNothing());

  // Release hardware codec, ensure it runs on primary task runner.
  config->codec_type = CodecType::kAny;
  auto hw_codec = MockMediaCodecBridge::CreateVideoDecoder(*config);
  reinterpret_cast<MockMediaCodecBridge*>(hw_codec.get())
      ->destruction_cb.ReplaceClosure(
          base::BindOnce(&CodecAllocatorTest::VerifyOnPrimaryTaskRunner,
                         base::Unretained(this)));
  allocator_->ReleaseMediaCodec(std::move(hw_codec), base::DoNothing());

  // Release secure (hardware) codec, ensure it runs on primary task runner.
  config->codec_type = CodecType::kSecure;
  auto secure_codec = MockMediaCodecBridge::CreateVideoDecoder(*config);
  reinterpret_cast<MockMediaCodecBridge*>(secure_codec.get())
      ->destruction_cb.ReplaceClosure(
          base::BindOnce(&CodecAllocatorTest::VerifyOnPrimaryTaskRunner,
                         base::Unretained(this)));
  allocator_->ReleaseMediaCodec(std::move(secure_codec), base::DoNothing());

  // QuitClosure may run before the initial release processes, so RunUntilIdle
  // here such that hung status is cleared.
  task_environment_.RunUntilIdle();

  // Running the loop should clear hung status.
  ASSERT_FALSE(IsPrimaryTaskRunnerLikelyHung());
}

// Make sure that allocating / freeing a codec on the allocator's thread
// completes, and doesn't DCHECK.
TEST_F(CodecAllocatorTest, AllocateAndDestroyCodecOnAllocatorThread) {
  CreateAllocatorOnAnotherThread();

  {
    base::RunLoop run_loop;
    auto config = CreateConfig();

    allocator_->CreateMediaCodecAsync(
        base::BindOnce(&CodecAllocatorTest::OnCodecCreatedInternal,
                       base::Unretained(this), run_loop.QuitClosure()),
        std::move(config));
    EXPECT_CALL(*this, OnCodecCreated(CodecType::kAny));
    run_loop.Run();
  }

  {
    base::RunLoop run_loop;
    allocator_->ReleaseMediaCodec(
        std::move(last_created_codec_),
        base::BindOnce(&CodecAllocatorTest::OnCodecReleasedInternal,
                       base::Unretained(this), run_loop.QuitClosure()));
    EXPECT_CALL(*this, OnCodecReleased());
    run_loop.Run();
  }
}

TEST_F(CodecAllocatorTest, LowResolutionGetsSoftware) {
  auto config = CreateConfig();
  config->initial_expected_coded_size =
      CodecAllocator::kMinHardwareResolution - gfx::Size(1, 1);
  base::RunLoop run_loop;
  allocator_->CreateMediaCodecAsync(
      base::BindOnce(&CodecAllocatorTest::OnCodecCreatedInternal,
                     base::Unretained(this), run_loop.QuitClosure()),
      std::move(config));

  EXPECT_CALL(*this, OnCodecCreated(CodecType::kSoftware));
  run_loop.Run();
}

}  // namespace media