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

#include "ui/ozone/platform/drm/gpu/drm_window.h"

#include <drm_fourcc.h>
#include <stdint.h>
#include <xf86drm.h>
#include <memory>
#include <string>
#include <utility>
#include <vector>

#include "base/files/platform_file.h"
#include "base/functional/bind.h"
#include "base/strings/string_number_conversions.h"
#include "base/test/task_environment.h"
#include "base/time/time.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/skia/include/core/SkCanvas.h"
#include "third_party/skia/include/core/SkColor.h"
#include "third_party/skia/include/core/SkImageInfo.h"
#include "third_party/skia/include/core/SkSurface.h"
#include "ui/gfx/geometry/size.h"
#include "ui/gfx/gpu_fence.h"
#include "ui/gfx/linux/gbm_buffer.h"
#include "ui/gfx/linux/test/mock_gbm_device.h"
#include "ui/gfx/presentation_feedback.h"
#include "ui/ozone/platform/drm/common/drm_util.h"
#include "ui/ozone/platform/drm/gpu/drm_device_generator.h"
#include "ui/ozone/platform/drm/gpu/drm_device_manager.h"
#include "ui/ozone/platform/drm/gpu/drm_framebuffer.h"
#include "ui/ozone/platform/drm/gpu/fake_drm_device.h"
#include "ui/ozone/platform/drm/gpu/hardware_display_controller.h"
#include "ui/ozone/platform/drm/gpu/page_flip_watchdog.h"
#include "ui/ozone/platform/drm/gpu/screen_manager.h"
#include "ui/ozone/public/surface_ozone_canvas.h"

namespace ui {

namespace {

// Mode of size 6x4.
const drmModeModeInfo kDefaultMode = {.hdisplay = 6, .vdisplay = 4};

const gfx::AcceleratedWidget kDefaultWidgetHandle = 1;
const int kDefaultCursorSize = 64;

std::vector<sk_sp<SkSurface>> GetCursorBuffers(
    const scoped_refptr<FakeDrmDevice> drm) {
  std::vector<sk_sp<SkSurface>> cursor_buffers;
  for (const auto& pair : drm->buffers()) {
    const auto& cursor_buffer = pair.second;
    if (cursor_buffer && cursor_buffer->width() == kDefaultCursorSize &&
        cursor_buffer->height() == kDefaultCursorSize) {
      cursor_buffers.push_back(cursor_buffer);
    }
  }

  return cursor_buffers;
}

SkBitmap AllocateBitmap(const gfx::Size& size) {
  SkBitmap image;
  SkImageInfo info = SkImageInfo::Make(size.width(), size.height(),
                                       kN32_SkColorType, kPremul_SkAlphaType);
  image.allocPixels(info);
  image.eraseColor(SK_ColorWHITE);
  return image;
}

}  // namespace

class DrmWindowTest : public testing::Test {
 public:
  DrmWindowTest() = default;

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

  void SetUp() override;
  void TearDown() override;

  void OnSubmission(gfx::SwapResult result, gfx::GpuFenceHandle release_fence) {
    last_swap_buffers_result_ = result;
  }

  void OnPresentation(const gfx::PresentationFeedback& feedback) {
    if (!feedback.failed())
      on_successful_swap_buffers_count_++;
    last_presentation_feedback_ = feedback;
  }

  scoped_refptr<DrmFramebuffer> CreateBuffer() {
    const gfx::Size window_size = ModeSize(kDefaultMode);
    std::unique_ptr<GbmBuffer> buffer = drm_->gbm_device()->CreateBuffer(
        DRM_FORMAT_XRGB8888, window_size, GBM_BO_USE_SCANOUT);
    return DrmFramebuffer::AddFramebuffer(drm_, buffer.get(), window_size);
  }

 protected:
  void InitializeDrmState(FakeDrmDevice* drm, bool is_atomic = true);

  base::test::SingleThreadTaskEnvironment task_environment_{
      base::test::TaskEnvironment::TimeSource::MOCK_TIME,
      base::test::SingleThreadTaskEnvironment::MainThreadType::UI};
  scoped_refptr<FakeDrmDevice> drm_;
  scoped_refptr<FakeDrmDevice> drm2_;
  std::unique_ptr<ScreenManager> screen_manager_;
  std::unique_ptr<DrmDeviceManager> drm_device_manager_;

  int on_successful_swap_buffers_count_;
  gfx::SwapResult last_swap_buffers_result_;
  gfx::PresentationFeedback last_presentation_feedback_;

  uint32_t crtc_id_ = 0;
  uint32_t connector_id_ = 0;
};

void DrmWindowTest::SetUp() {
  on_successful_swap_buffers_count_ = 0;
  last_swap_buffers_result_ = gfx::SwapResult::SWAP_FAILED;

  auto gbm_device = std::make_unique<MockGbmDevice>();
  drm_ = new FakeDrmDevice(std::move(gbm_device));
  screen_manager_ = std::make_unique<ScreenManager>();

  InitializeDrmState(drm_.get());
  crtc_id_ = drm_->crtc_property(0).id;
  connector_id_ = drm_->connector_property(0).id;

  screen_manager_->AddDisplayController(drm_, crtc_id_, connector_id_);
  std::vector<ControllerConfigParams> controllers_to_enable;
  controllers_to_enable.emplace_back(
      1 /*display_id*/, drm_, crtc_id_, connector_id_, gfx::Point(),
      std::make_unique<drmModeModeInfo>(kDefaultMode));
  screen_manager_->ConfigureDisplayControllers(
      controllers_to_enable, {display::ModesetFlag::kTestModeset,
                              display::ModesetFlag::kCommitModeset});

  drm_device_manager_ = std::make_unique<DrmDeviceManager>(nullptr);

  std::unique_ptr<DrmWindow> window(new DrmWindow(
      kDefaultWidgetHandle, drm_device_manager_.get(), screen_manager_.get()));
  window->Initialize();
  window->SetBounds(
      gfx::Rect(gfx::Size(kDefaultMode.hdisplay, kDefaultMode.vdisplay)));
  screen_manager_->AddWindow(kDefaultWidgetHandle, std::move(window));

  // Secondary DrmDevice for test cases that need it.
  drm2_ = new FakeDrmDevice(std::make_unique<MockGbmDevice>());
}

void DrmWindowTest::TearDown() {
  std::unique_ptr<DrmWindow> window =
      screen_manager_->RemoveWindow(kDefaultWidgetHandle);
  window->Shutdown();
  // Ensure DrmWindow is destroyed before ScreenManager.
  window = nullptr;

  screen_manager_ = nullptr;
  drm_->ResetPlaneManagerForTesting();
  drm2_->ResetPlaneManagerForTesting();
}

void DrmWindowTest::InitializeDrmState(FakeDrmDevice* drm, bool is_atomic) {
  drm->ResetStateWithDefaultObjects(
      /*crtc_count=*/1, /*planes_per_crtc=*/1);
  drm->InitializeState(/*use_atomic=*/false);
}

TEST_F(DrmWindowTest, SetCursorImage) {
  const gfx::Size cursor_size(6, 4);
  screen_manager_->GetWindow(kDefaultWidgetHandle)
      ->SetCursor(std::vector<SkBitmap>(1, AllocateBitmap(cursor_size)),
                  gfx::Point(4, 2), base::TimeDelta());

  SkBitmap cursor;
  std::vector<sk_sp<SkSurface>> cursor_buffers = GetCursorBuffers(drm_);
  EXPECT_EQ(2u, cursor_buffers.size());

  // Buffers 0 is the cursor backbuffer we just drew in.
  cursor.allocPixels(cursor_buffers[0]->getCanvas()->imageInfo());
  EXPECT_TRUE(cursor_buffers[0]->getCanvas()->readPixels(cursor, 0, 0));

  // Check that the frontbuffer is displaying the right image as set above.
  for (int i = 0; i < cursor.height(); ++i) {
    for (int j = 0; j < cursor.width(); ++j) {
      if (j < cursor_size.width() && i < cursor_size.height())
        EXPECT_EQ(SK_ColorWHITE, cursor.getColor(j, i));
      else
        EXPECT_EQ(static_cast<SkColor>(SK_ColorTRANSPARENT),
                  cursor.getColor(j, i));
    }
  }
}

TEST_F(DrmWindowTest, CheckCursorSurfaceAfterChangingDevice) {
  const gfx::Size cursor_size(6, 4);
  screen_manager_->GetWindow(kDefaultWidgetHandle)
      ->SetCursor(std::vector<SkBitmap>(1, AllocateBitmap(cursor_size)),
                  gfx::Point(4, 2), base::TimeDelta());

  // Add another device.
  InitializeDrmState(drm2_.get());

  screen_manager_->AddDisplayController(drm2_, crtc_id_, connector_id_);

  std::vector<ControllerConfigParams> controllers_to_enable;
  controllers_to_enable.emplace_back(
      /*display_id=*/2, drm2_, crtc_id_, connector_id_,
      gfx::Point(0, kDefaultMode.vdisplay),
      std::make_unique<drmModeModeInfo>(kDefaultMode));
  screen_manager_->ConfigureDisplayControllers(
      controllers_to_enable, {display::ModesetFlag::kTestModeset,
                              display::ModesetFlag::kCommitModeset});

  // Move window to the display on the new device.
  screen_manager_->GetWindow(kDefaultWidgetHandle)
      ->SetBounds(gfx::Rect(0, kDefaultMode.vdisplay, kDefaultMode.hdisplay,
                            kDefaultMode.vdisplay));

  EXPECT_EQ(2u, GetCursorBuffers(drm2_).size());
  // Make sure the cursor is showing on the new display.
  EXPECT_NE(0u, drm2_->get_cursor_handle_for_crtc(crtc_id_));
}

TEST_F(DrmWindowTest, CheckPageflipSuccessOnSuccessfulSwap) {
  DrmOverlayPlaneList planes;
  planes.push_back(DrmOverlayPlane::TestPlane(CreateBuffer()));

  // Window was re-sized, so the expectation is to re-create the buffers first.
  DrmWindow* window = screen_manager_->GetWindow(kDefaultWidgetHandle);
  drm_->set_page_flip_expectation(false);
  window->SchedulePageFlip(
      DrmOverlayPlane::Clone(planes),
      base::BindOnce(&DrmWindowTest::OnSubmission, base::Unretained(this)),
      base::BindOnce(&DrmWindowTest::OnPresentation, base::Unretained(this)));
  drm_->RunCallbacks();
  EXPECT_EQ(0, on_successful_swap_buffers_count_);
  EXPECT_EQ(gfx::SwapResult::SWAP_NAK_RECREATE_BUFFERS,
            last_swap_buffers_result_);
  EXPECT_EQ(static_cast<uint32_t>(gfx::PresentationFeedback::Flags::kFailure),
            last_presentation_feedback_.flags);

  // Page flip succeeds, so GPU self-destruct should not engage.
  drm_->set_page_flip_expectation(true);
  window->SchedulePageFlip(
      DrmOverlayPlane::Clone(planes),
      base::BindOnce(&DrmWindowTest::OnSubmission, base::Unretained(this)),
      base::BindOnce(&DrmWindowTest::OnPresentation, base::Unretained(this)));
  drm_->RunCallbacks();
  EXPECT_EQ(1, on_successful_swap_buffers_count_);
  EXPECT_EQ(gfx::SwapResult::SWAP_ACK, last_swap_buffers_result_);

  // Ensure self-destruct time runs out without process death.
  task_environment_.FastForwardBy(kWaitForModesetTimeout);
}

TEST_F(DrmWindowTest, CheckPageflipFailureOnFailedSwap) {
  DrmOverlayPlaneList planes;
  planes.push_back(DrmOverlayPlane::TestPlane(CreateBuffer()));

  // Window was re-sized, so the expectation is to re-create the buffers first.
  DrmWindow* window = screen_manager_->GetWindow(kDefaultWidgetHandle);
  drm_->set_page_flip_expectation(false);
  window->SchedulePageFlip(
      DrmOverlayPlane::Clone(planes),
      base::BindOnce(&DrmWindowTest::OnSubmission, base::Unretained(this)),
      base::BindOnce(&DrmWindowTest::OnPresentation, base::Unretained(this)));
  drm_->RunCallbacks();
  EXPECT_EQ(0, on_successful_swap_buffers_count_);
  EXPECT_EQ(gfx::SwapResult::SWAP_NAK_RECREATE_BUFFERS,
            last_swap_buffers_result_);
  EXPECT_EQ(static_cast<uint32_t>(gfx::PresentationFeedback::Flags::kFailure),
            last_presentation_feedback_.flags);

  // Page flip still fails, so we expect GPU self-destruct timer to kick in.
  window->SchedulePageFlip(
      DrmOverlayPlane::Clone(planes),
      base::BindOnce(&DrmWindowTest::OnSubmission, base::Unretained(this)),
      base::BindOnce(&DrmWindowTest::OnPresentation, base::Unretained(this)));
  drm_->RunCallbacks();
  EXPECT_EQ(0, on_successful_swap_buffers_count_);
  EXPECT_EQ(gfx::SwapResult::SWAP_FAILED, last_swap_buffers_result_);
  EXPECT_EQ(static_cast<uint32_t>(gfx::PresentationFeedback::Flags::kFailure),
            last_presentation_feedback_.flags);

  // Since no modeset event was detected, death occurs after
  // |kWaitForModesetTimeout| seconds.
  const std::string gpu_crash_log =
      "Failed to modeset within " +
      base::NumberToString(kWaitForModesetTimeout.InSeconds()) +
      " s of the first page flip failure. Crashing GPU process.";
  EXPECT_DEATH_IF_SUPPORTED(
      task_environment_.FastForwardBy(kWaitForModesetTimeout), gpu_crash_log);
}

TEST_F(DrmWindowTest, CheckPageflipFailureOnDrmMasterDropped) {
  DrmOverlayPlaneList planes;
  planes.push_back(DrmOverlayPlane::TestPlane(CreateBuffer()));

  // Window was re-sized, so the expectation is to re-create the buffers first.
  DrmWindow* window = screen_manager_->GetWindow(kDefaultWidgetHandle);
  drm_->set_page_flip_expectation(false);
  window->SchedulePageFlip(
      DrmOverlayPlane::Clone(planes),
      base::BindOnce(&DrmWindowTest::OnSubmission, base::Unretained(this)),
      base::BindOnce(&DrmWindowTest::OnPresentation, base::Unretained(this)));
  drm_->RunCallbacks();
  EXPECT_EQ(0, on_successful_swap_buffers_count_);
  EXPECT_EQ(gfx::SwapResult::SWAP_NAK_RECREATE_BUFFERS,
            last_swap_buffers_result_);
  EXPECT_EQ(static_cast<uint32_t>(gfx::PresentationFeedback::Flags::kFailure),
            last_presentation_feedback_.flags);

  drm_->DropMaster();
  ASSERT_FALSE(drm_->has_master());

  // DRM master was dropped, so expect no pageflip commits.
  drm_->set_page_flip_expectation(false);
  window->SchedulePageFlip(
      DrmOverlayPlane::Clone(planes),
      base::BindOnce(&DrmWindowTest::OnSubmission, base::Unretained(this)),
      base::BindOnce(&DrmWindowTest::OnPresentation, base::Unretained(this)));
  drm_->RunCallbacks();
  EXPECT_EQ(0, on_successful_swap_buffers_count_);
  EXPECT_EQ(gfx::SwapResult::SWAP_ACK, last_swap_buffers_result_);
  EXPECT_EQ(static_cast<uint32_t>(gfx::PresentationFeedback::Flags::kFailure),
            last_presentation_feedback_.flags);
}

}  // namespace ui