// Copyright 2013 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/display/manager/display_change_observer.h"

#include <cmath>
#include <iterator>
#include <memory>
#include <optional>
#include <set>
#include <string>
#include <tuple>

#include "base/command_line.h"
#include "base/strings/stringprintf.h"
#include "base/test/gtest_util.h"
#include "base/test/scoped_command_line.h"
#include "base/test/scoped_feature_list.h"
#include "cc/base/math_util.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/display/display.h"
#include "ui/display/display_features.h"
#include "ui/display/display_switches.h"
#include "ui/display/manager/display_configurator.h"
#include "ui/display/manager/display_manager.h"
#include "ui/display/manager/managed_display_info.h"
#include "ui/display/manager/test/fake_display_snapshot.h"
#include "ui/display/manager/util/display_manager_util.h"
#include "ui/display/screen.h"
#include "ui/display/types/display_constants.h"
#include "ui/display/types/display_mode.h"
#include "ui/display/util/display_util.h"
#include "ui/events/devices/device_data_manager.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/rect_conversions.h"
#include "ui/gfx/geometry/rect_f.h"
#include "ui/gfx/geometry/rounded_corners_f.h"
#include "ui/gfx/geometry/size.h"
#include "ui/gfx/range/range_f.h"

namespace display {

namespace {

float ComputeDpi(float diagonal_inch, const gfx::Size& resolution) {
  // We assume that displays have square pixel.
  float diagonal_pixel = std::sqrt(std::pow(resolution.width(), 2) +
                                   std::pow(resolution.height(), 2));
  return diagonal_pixel / diagonal_inch;
}

float ComputeDeviceScaleFactor(float dpi, const gfx::Size& resolution) {
  return DisplayChangeObserver::FindDeviceScaleFactor(dpi, resolution);
}

std::unique_ptr<DisplayMode> MakeDisplayMode(
    int width,
    int height,
    bool is_interlaced,
    float refresh_rate,
    const std::optional<float>& vsync_rate_min = std::nullopt) {
  return std::make_unique<DisplayMode>(gfx::Size{width, height}, is_interlaced,
                                       refresh_rate, vsync_rate_min);
}

}  // namespace

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

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

  ~DisplayChangeObserverTestBase() override = default;

  // Pass through method to be called by individual test cases.
  ManagedDisplayInfo CreateManagedDisplayInfo(DisplayChangeObserver* observer,
                                              const DisplaySnapshot* snapshot,
                                              const DisplayMode* mode_info) {
    return observer->CreateManagedDisplayInfoInternal(snapshot, mode_info);
  }

 protected:
  base::test::ScopedFeatureList scoped_feature_list_;
};

class DisplayChangeObserverTest : public DisplayChangeObserverTestBase,
                                  public testing::WithParamInterface<bool> {
 public:
  DisplayChangeObserverTest() = default;

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

  ~DisplayChangeObserverTest() override = default;

  // DisplayChangeObserverTestBase:
  void SetUp() override {
    if (GetParam()) {
      scoped_feature_list_.InitAndEnableFeature(features::kListAllDisplayModes);
    } else {
      scoped_feature_list_.InitAndDisableFeature(
          features::kListAllDisplayModes);
    }

    DisplayChangeObserverTestBase::SetUp();
  }
};

class DisplayChangeObserverPanelRadiiTest
    : public DisplayChangeObserverTestBase {
 public:
  DisplayChangeObserverPanelRadiiTest() = default;

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

  ~DisplayChangeObserverPanelRadiiTest() override = default;

  // testing::Test:
  void SetUp() override {
    display_manager_ = std::make_unique<DisplayManager>(/*screen=*/nullptr);
    default_display_mode_ = MakeDisplayMode(1920, 1080, true, 60);

    ui::DeviceDataManager::CreateInstance();
    DisplayChangeObserverTestBase::SetUp();
  }

  void InitializeDisplayChangeObserver() {
    display_change_observer_ =
        std::make_unique<DisplayChangeObserver>(display_manager_.get());
  }

 protected:
  base::test::ScopedCommandLine command_line_;
  std::unique_ptr<DisplayManager> display_manager_;
  std::unique_ptr<DisplayChangeObserver> display_change_observer_;
  std::unique_ptr<DisplayMode> default_display_mode_;
};

TEST_F(DisplayChangeObserverPanelRadiiTest, RadiiSpecifiedForInternalDisplay) {
  command_line_.GetProcessCommandLine()->AppendSwitchASCII(
      switches::kDisplayProperties,
      "[{\"connector-type\": 14, \"rounded-corners\": {\"bottom-left\": 15, "
      "\"bottom-right\": 15, \"top-left\": 16, \"top-right\": 16}}]");

  InitializeDisplayChangeObserver();

  // Radii specified for the connection protocol.
  std::unique_ptr<DisplaySnapshot> display_snapshot =
      FakeDisplaySnapshot::Builder()
          .SetId(123)
          .SetNativeMode(MakeDisplayMode(1920, 1080, true, 60))
          .SetType(
              display::DisplayConnectionType::DISPLAY_CONNECTION_TYPE_INTERNAL)
          .Build();

  const ManagedDisplayInfo display_info = CreateManagedDisplayInfo(
      display_change_observer_.get(), display_snapshot.get(),
      default_display_mode_.get());

  EXPECT_EQ(display_info.panel_corners_radii(),
            gfx::RoundedCornersF(16, 16, 15, 15));
}

TEST_F(DisplayChangeObserverPanelRadiiTest, IgnoreRadiiIfNotInternalDisplay) {
  command_line_.GetProcessCommandLine()->AppendSwitchASCII(
      switches::kDisplayProperties,
      "[{\"connector-type\": 15, \"rounded-corners\": {\"bottom-left\": 15, "
      "\"bottom-right\": 15, \"top-left\": 16, \"top-right\": 16}}]");

  InitializeDisplayChangeObserver();

  // The snapshot is of a display that is not a internal display.
  std::unique_ptr<DisplaySnapshot> display_snapshot =
      FakeDisplaySnapshot::Builder()
          .SetId(123)
          .SetNativeMode(MakeDisplayMode(1920, 1080, true, 60))
          .SetType(display::DisplayConnectionType::DISPLAY_CONNECTION_TYPE_HDMI)
          .Build();

  const ManagedDisplayInfo display_info = CreateManagedDisplayInfo(
      display_change_observer_.get(), display_snapshot.get(),
      default_display_mode_.get());

  EXPECT_TRUE(display_info.panel_corners_radii().IsEmpty());
}

TEST_P(DisplayChangeObserverTest, GetExternalManagedDisplayModeList) {
  std::unique_ptr<DisplaySnapshot> display_snapshot =
      FakeDisplaySnapshot::Builder()
          .SetId(123)
          .SetNativeMode(MakeDisplayMode(1920, 1200, false, 60))
          // Same size as native mode but with higher refresh rate.
          .AddMode(MakeDisplayMode(1920, 1200, false, 75))
          // All non-interlaced (as would be seen with different refresh rates).
          .AddMode(MakeDisplayMode(1920, 1080, false, 80))
          .AddMode(MakeDisplayMode(1920, 1080, false, 70))
          .AddMode(MakeDisplayMode(1920, 1080, false, 60))
          // Interlaced vs non-interlaced.
          .AddMode(MakeDisplayMode(1280, 720, true, 60))
          .AddMode(MakeDisplayMode(1280, 720, false, 60))
          // Interlaced only.
          .AddMode(MakeDisplayMode(1024, 768, true, 70))
          .AddMode(MakeDisplayMode(1024, 768, true, 60))
          // Mixed.
          .AddMode(MakeDisplayMode(1024, 600, true, 60))
          .AddMode(MakeDisplayMode(1024, 600, false, 70))
          .AddMode(MakeDisplayMode(1024, 600, false, 60))
          // Just one interlaced mode.
          .AddMode(MakeDisplayMode(640, 480, true, 60))
          .Build();

  ManagedDisplayInfo::ManagedDisplayModeList display_modes =
      DisplayChangeObserver::GetExternalManagedDisplayModeList(
          *display_snapshot);

  const bool listing_all_modes = GetParam();
  if (listing_all_modes) {
    ASSERT_EQ(13u, display_modes.size());
    EXPECT_EQ(gfx::Size(640, 480), display_modes[0].size());
    EXPECT_TRUE(display_modes[0].is_interlaced());
    EXPECT_EQ(display_modes[0].refresh_rate(), 60);

    EXPECT_EQ(gfx::Size(1024, 600), display_modes[1].size());
    EXPECT_FALSE(display_modes[1].is_interlaced());
    EXPECT_EQ(display_modes[1].refresh_rate(), 60);
    EXPECT_EQ(gfx::Size(1024, 600), display_modes[2].size());
    EXPECT_TRUE(display_modes[2].is_interlaced());
    EXPECT_EQ(display_modes[2].refresh_rate(), 60);
    EXPECT_EQ(gfx::Size(1024, 600), display_modes[3].size());
    EXPECT_FALSE(display_modes[3].is_interlaced());
    EXPECT_EQ(display_modes[3].refresh_rate(), 70);

    EXPECT_EQ(gfx::Size(1024, 768), display_modes[4].size());
    EXPECT_TRUE(display_modes[4].is_interlaced());
    EXPECT_EQ(display_modes[4].refresh_rate(), 60);
    EXPECT_EQ(gfx::Size(1024, 768), display_modes[5].size());
    EXPECT_TRUE(display_modes[5].is_interlaced());
    EXPECT_EQ(display_modes[5].refresh_rate(), 70);

    EXPECT_EQ(gfx::Size(1280, 720), display_modes[6].size());
    EXPECT_FALSE(display_modes[6].is_interlaced());
    EXPECT_EQ(display_modes[6].refresh_rate(), 60);
    EXPECT_EQ(gfx::Size(1280, 720), display_modes[7].size());
    EXPECT_TRUE(display_modes[7].is_interlaced());
    EXPECT_EQ(display_modes[7].refresh_rate(), 60);

    EXPECT_EQ(gfx::Size(1920, 1080), display_modes[8].size());
    EXPECT_FALSE(display_modes[8].is_interlaced());
    EXPECT_EQ(display_modes[8].refresh_rate(), 60);
    EXPECT_EQ(gfx::Size(1920, 1080), display_modes[9].size());
    EXPECT_FALSE(display_modes[9].is_interlaced());
    EXPECT_EQ(display_modes[9].refresh_rate(), 70);
    EXPECT_EQ(gfx::Size(1920, 1080), display_modes[10].size());
    EXPECT_FALSE(display_modes[10].is_interlaced());
    EXPECT_EQ(display_modes[10].refresh_rate(), 80);

    EXPECT_EQ(gfx::Size(1920, 1200), display_modes[11].size());
    EXPECT_FALSE(display_modes[11].is_interlaced());
    EXPECT_EQ(display_modes[11].refresh_rate(), 60);

    EXPECT_EQ(gfx::Size(1920, 1200), display_modes[12].size());
    EXPECT_FALSE(display_modes[12].is_interlaced());
    EXPECT_EQ(display_modes[12].refresh_rate(), 75);
  } else {
    ASSERT_EQ(6u, display_modes.size());
    EXPECT_EQ(gfx::Size(640, 480), display_modes[0].size());
    EXPECT_TRUE(display_modes[0].is_interlaced());
    EXPECT_EQ(display_modes[0].refresh_rate(), 60);

    EXPECT_EQ(gfx::Size(1024, 600), display_modes[1].size());
    EXPECT_FALSE(display_modes[1].is_interlaced());
    EXPECT_EQ(display_modes[1].refresh_rate(), 70);

    EXPECT_EQ(gfx::Size(1024, 768), display_modes[2].size());
    EXPECT_TRUE(display_modes[2].is_interlaced());
    EXPECT_EQ(display_modes[2].refresh_rate(), 70);

    EXPECT_EQ(gfx::Size(1280, 720), display_modes[3].size());
    EXPECT_FALSE(display_modes[3].is_interlaced());
    EXPECT_EQ(display_modes[3].refresh_rate(), 60);

    EXPECT_EQ(gfx::Size(1920, 1080), display_modes[4].size());
    EXPECT_FALSE(display_modes[4].is_interlaced());
    EXPECT_EQ(display_modes[4].refresh_rate(), 80);

    EXPECT_EQ(gfx::Size(1920, 1200), display_modes[5].size());
    EXPECT_FALSE(display_modes[5].is_interlaced());
    EXPECT_EQ(display_modes[5].refresh_rate(), 60);
  }
}

TEST_P(DisplayChangeObserverTest, GetEmptyExternalManagedDisplayModeList) {
  DisplaySnapshot::ColorInfo color_info;
  FakeDisplaySnapshot display_snapshot(
      /*display_id=*/123, /*port_display_id=*/123, /*edid_display_id=*/456,
      /*connector_index=*/0x0001, gfx::Point(), gfx::Size(),
      DISPLAY_CONNECTION_TYPE_UNKNOWN,
      /*base_connector_id=*/1u, /*path_topology=*/{}, false, false,
      PrivacyScreenState::kNotSupported, false, std::string(), base::FilePath(),
      {}, nullptr, nullptr, 0, gfx::Size(), color_info,
      VariableRefreshRateState::kVrrNotCapable, DrmFormatsAndModifiers());

  ManagedDisplayInfo::ManagedDisplayModeList display_modes =
      DisplayChangeObserver::GetExternalManagedDisplayModeList(
          display_snapshot);
  EXPECT_EQ(0u, display_modes.size());
}

bool IsDpiOutOfRange(float dpi) {
  // http://go/cros-ppi-spectrum
  constexpr gfx::RangeF good_ranges[] = {
      {125.f, 165.f},
      {180.f, 210.f},
      {220.f, 265.f},
      {270.f, 350.f},
  };
  for (auto& range : good_ranges) {
    if (range.start() <= dpi && range.end() > dpi)
      return true;
  }
  return false;
}

// Check if a display with a specific size and resolution have an expected
// scale factor and screenshot size.
void CheckDisplayConfig(const DisplayData entry) {
  SCOPED_TRACE(base::StringPrintf(
      "%dx%d, diag=%1.3f inch, expected=%1.10f", entry.resolution.width(),
      entry.resolution.height(), entry.diagonal_size, entry.expected_dsf));

  float dpi = ComputeDpi(entry.diagonal_size, entry.resolution);
  // Check ScaleFactor.
  float scale_factor = ComputeDeviceScaleFactor(dpi, entry.resolution);
  EXPECT_EQ(entry.expected_dsf, scale_factor);
  bool bad_range = !IsDpiOutOfRange(dpi);
  EXPECT_EQ(bad_range, entry.bad_range);

  // Check DP size.
  gfx::ScaleToCeiledSize(entry.resolution, 1.f / scale_factor);

  const gfx::Size dp_size =
      gfx::ScaleToCeiledSize(entry.resolution, 1.f / scale_factor);

  // Check Screenshot size.
  EXPECT_EQ(entry.expected_dp_size, dp_size);
  gfx::Transform transform;
  transform.Scale(scale_factor, scale_factor);
  const gfx::Size screenshot_size =
      cc::MathUtil::MapEnclosingClippedRect(transform, gfx::Rect(dp_size))
          .size();
  switch (entry.screenshot_size_error) {
    case kEpsilon: {
      EXPECT_NE(entry.resolution, screenshot_size);
      constexpr float kEpsilon = 0.001f;
      EXPECT_EQ(entry.resolution,
                cc::MathUtil::MapEnclosingClippedRectIgnoringError(
                    transform, gfx::Rect(dp_size), kEpsilon)
                    .size());
      break;
    }
    case kExact:
      EXPECT_EQ(entry.resolution, screenshot_size);
      break;
    case kSkip:
      break;
  }
}

TEST_P(DisplayChangeObserverTest, FindDeviceScaleFactor) {
  // Validation check
  EXPECT_EQ(1.25f,
            DisplayChangeObserver::FindDeviceScaleFactor(150, gfx::Size()));
  EXPECT_EQ(1.6f,
            DisplayChangeObserver::FindDeviceScaleFactor(180, gfx::Size()));
  EXPECT_EQ(kDsf_1_777,
            DisplayChangeObserver::FindDeviceScaleFactor(220, gfx::Size()));
  EXPECT_EQ(2.f,
            DisplayChangeObserver::FindDeviceScaleFactor(230, gfx::Size()));
  EXPECT_EQ(2.4f,
            DisplayChangeObserver::FindDeviceScaleFactor(270, gfx::Size()));
  EXPECT_EQ(kDsf_2_252, DisplayChangeObserver::FindDeviceScaleFactor(
                            0, gfx::Size(3000, 2000)));
  EXPECT_EQ(kDsf_2_666,
            DisplayChangeObserver::FindDeviceScaleFactor(310, gfx::Size()));

  // Loop through the known LCD displays and check if the expected scale factor
  // is applied.
  std::set<std::tuple<float, int, int>> dup_check;
  for (const DisplayData& entry : lcd_display_configs) {
    std::tuple<float, int, int> key{entry.diagonal_size,
                                    entry.resolution.width(),
                                    entry.resolution.height()};
    DCHECK(!dup_check.count(key));
    dup_check.emplace(key);
    CheckDisplayConfig(entry);
  }

  float max_scale_factor = kDsf_2_666;
  // Erroneous values should still work.
  EXPECT_EQ(1.0f,
            DisplayChangeObserver::FindDeviceScaleFactor(-100.0f, gfx::Size()));
  EXPECT_EQ(1.0f,
            DisplayChangeObserver::FindDeviceScaleFactor(0.0f, gfx::Size()));
  EXPECT_EQ(max_scale_factor, DisplayChangeObserver::FindDeviceScaleFactor(
                                  10000.0f, gfx::Size()));
}

TEST_P(DisplayChangeObserverTest, FindOledDeviceScaleFactor) {
  // This test is the same as the `FindDeviceScaleFactor` test but with
  // kOledScaleFactorEnabled set to true.
  base::test::ScopedFeatureList feature_list_;
  feature_list_.InitAndEnableFeature(
      display::features::kOledScaleFactorEnabled);

  // validation
  EXPECT_EQ(1.25f,
            DisplayChangeObserver::FindDeviceScaleFactor(140, gfx::Size()));
  EXPECT_EQ(kDsf_1_333,
            DisplayChangeObserver::FindDeviceScaleFactor(160, gfx::Size()));

  // Loop through the known Oled displays and check if the expected scale factor
  // is applied.
  std::set<std::tuple<float, int, int>> dup_check;
  for (const DisplayData& entry : oled_display_configs) {
    std::tuple<float, int, int> key{entry.diagonal_size,
                                    entry.resolution.width(),
                                    entry.resolution.height()};
    DCHECK(!dup_check.count(key));
    dup_check.emplace(key);
    CheckDisplayConfig(entry);
  }
}

TEST_P(DisplayChangeObserverTest,
       FindExternalDisplayNativeModeWhenOverwritten) {
  std::unique_ptr<DisplaySnapshot> display_snapshot =
      FakeDisplaySnapshot::Builder()
          .SetId(123)
          .SetNativeMode(MakeDisplayMode(1920, 1080, true, 60))
          .AddMode(MakeDisplayMode(1920, 1080, false, 60))
          .Build();

  ManagedDisplayInfo::ManagedDisplayModeList display_modes =
      DisplayChangeObserver::GetExternalManagedDisplayModeList(
          *display_snapshot);

  const bool listing_all_modes = GetParam();

  if (listing_all_modes) {
    ASSERT_EQ(2u, display_modes.size());
    EXPECT_EQ(gfx::Size(1920, 1080), display_modes[0].size());
    EXPECT_FALSE(display_modes[0].is_interlaced());
    EXPECT_FALSE(display_modes[0].native());
    EXPECT_EQ(display_modes[0].refresh_rate(), 60);

    EXPECT_EQ(gfx::Size(1920, 1080), display_modes[1].size());
    EXPECT_TRUE(display_modes[1].is_interlaced());
    EXPECT_TRUE(display_modes[1].native());
    EXPECT_EQ(display_modes[1].refresh_rate(), 60);
  } else {
    // Only the native mode will be listed.
    ASSERT_EQ(1u, display_modes.size());
    EXPECT_EQ(gfx::Size(1920, 1080), display_modes[0].size());
    EXPECT_TRUE(display_modes[0].is_interlaced());
    EXPECT_TRUE(display_modes[0].native());
    EXPECT_EQ(display_modes[0].refresh_rate(), 60);
  }
}

TEST_P(DisplayChangeObserverTest, InvalidDisplayColorSpaces) {
  const std::unique_ptr<DisplaySnapshot> display_snapshot =
      FakeDisplaySnapshot::Builder()
          .SetId(123)
          .SetName("AmazingFakeDisplay")
          .SetNativeMode(MakeDisplayMode(1920, 1080, true, 60))
          .SetColorSpace(gfx::ColorSpace())
          .Build();

  ui::DeviceDataManager::CreateInstance();
  DisplayManager manager(nullptr);
  const auto display_mode = MakeDisplayMode(1920, 1080, true, 60);
  DisplayChangeObserver observer(&manager);
  const ManagedDisplayInfo display_info = CreateManagedDisplayInfo(
      &observer, display_snapshot.get(), display_mode.get());

  EXPECT_EQ(display_info.bits_per_channel(), 8u);
  const auto display_color_spaces = display_info.display_color_spaces();
  EXPECT_FALSE(display_color_spaces.SupportsHDR());

  EXPECT_EQ(
      DisplaySnapshot::PrimaryFormat(),
      display_color_spaces.GetOutputBufferFormat(gfx::ContentColorUsage::kSRGB,
                                                 /*needs_alpha=*/true));

  const auto color_space = display_color_spaces.GetRasterColorSpace();
  // DisplayColorSpaces will fix an invalid ColorSpace to return sRGB.
  EXPECT_TRUE(color_space.IsValid());
  EXPECT_EQ(color_space, gfx::ColorSpace::CreateSRGB());
}

TEST_P(DisplayChangeObserverTest, SDRDisplayColorSpaces) {
  const std::unique_ptr<DisplaySnapshot> display_snapshot =
      FakeDisplaySnapshot::Builder()
          .SetId(123)
          .SetName("AmazingFakeDisplay")
          .SetNativeMode(MakeDisplayMode(1920, 1080, true, 60))
          .SetColorSpace(gfx::ColorSpace::CreateSRGB())
          .Build();

  ui::DeviceDataManager::CreateInstance();
  DisplayManager manager(nullptr);
  const auto display_mode = MakeDisplayMode(1920, 1080, true, 60);
  DisplayChangeObserver observer(&manager);
  const ManagedDisplayInfo display_info = CreateManagedDisplayInfo(
      &observer, display_snapshot.get(), display_mode.get());

  EXPECT_EQ(display_info.bits_per_channel(), 8u);

  const auto display_color_spaces = display_info.display_color_spaces();
  EXPECT_FALSE(display_color_spaces.SupportsHDR());

  EXPECT_EQ(
      DisplaySnapshot::PrimaryFormat(),
      display_color_spaces.GetOutputBufferFormat(gfx::ContentColorUsage::kSRGB,
                                                 /*needs_alpha=*/true));

  const auto color_space = display_color_spaces.GetRasterColorSpace();
  EXPECT_TRUE(color_space.IsValid());
  EXPECT_EQ(color_space.GetPrimaryID(), gfx::ColorSpace::PrimaryID::BT709);
  EXPECT_EQ(color_space.GetTransferID(), gfx::ColorSpace::TransferID::SRGB);
}

TEST_P(DisplayChangeObserverTest, WCGDisplayColorSpaces) {
  const std::unique_ptr<DisplaySnapshot> display_snapshot =
      FakeDisplaySnapshot::Builder()
          .SetId(123)
          .SetName("AmazingFakeDisplay")
          .SetNativeMode(MakeDisplayMode(1920, 1080, true, 60))
          .SetColorSpace(gfx::ColorSpace::CreateDisplayP3D65())
          .Build();

  ui::DeviceDataManager::CreateInstance();
  DisplayManager manager(nullptr);
  const auto display_mode = MakeDisplayMode(1920, 1080, true, 60);
  DisplayChangeObserver observer(&manager);
  const ManagedDisplayInfo display_info = CreateManagedDisplayInfo(
      &observer, display_snapshot.get(), display_mode.get());

  EXPECT_EQ(display_info.bits_per_channel(), 8u);

  const auto display_color_spaces = display_info.display_color_spaces();
  EXPECT_FALSE(display_color_spaces.SupportsHDR());

  EXPECT_EQ(
      DisplaySnapshot::PrimaryFormat(),
      display_color_spaces.GetOutputBufferFormat(gfx::ContentColorUsage::kSRGB,
                                                 /*needs_alpha=*/true));

  const auto color_space = display_color_spaces.GetRasterColorSpace();
  EXPECT_TRUE(color_space.IsValid());
  EXPECT_EQ(color_space.GetPrimaryID(), gfx::ColorSpace::PrimaryID::BT709);
  EXPECT_EQ(color_space.GetTransferID(), gfx::ColorSpace::TransferID::SRGB);
}

TEST_P(DisplayChangeObserverTest, HDRDisplayColorSpaces) {
  // TODO(crbug.com/40652358): Remove this flag and provision when HDR is fully
  // supported on ChromeOS.
  base::test::ScopedFeatureList scoped_feature_list;
  scoped_feature_list.InitAndEnableFeature(
      features::kEnableExternalDisplayHDR10Mode);

  const auto display_color_space = gfx::ColorSpace::CreateHDR10();
  const std::unique_ptr<DisplaySnapshot> display_snapshot =
      FakeDisplaySnapshot::Builder()
          .SetId(123)
          .SetName("AmazingFakeDisplay")
          .SetNativeMode(MakeDisplayMode(1920, 1080, true, 60))
          .SetColorSpace(display_color_space)
          .SetBitsPerChannel(10u)
          .SetHDRStaticMetadata(
              {609.0, 500.0, 0.01,
               gfx::HDRStaticMetadata::EotfMask({
                   gfx::HDRStaticMetadata::Eotf::kGammaSdrRange,
                   gfx::HDRStaticMetadata::Eotf::kPq,
               })})
          .Build();

  ui::DeviceDataManager::CreateInstance();
  DisplayManager manager(nullptr);
  const auto display_mode = MakeDisplayMode(1920, 1080, true, 60);
  DisplayChangeObserver observer(&manager);
  const ManagedDisplayInfo display_info = CreateManagedDisplayInfo(
      &observer, display_snapshot.get(), display_mode.get());

  EXPECT_EQ(display_info.bits_per_channel(), 10u);

  const auto display_color_spaces = display_info.display_color_spaces();
  EXPECT_TRUE(display_color_spaces.SupportsHDR());

  // Ensure that all spaces be HDR10, and have headroom of 3x (609/203).
  EXPECT_EQ(
      gfx::BufferFormat::RGBA_1010102,
      display_color_spaces.GetOutputBufferFormat(gfx::ContentColorUsage::kSRGB,
                                                 /*needs_alpha=*/true));
  EXPECT_EQ(
      gfx::ColorSpace::CreateHDR10(),
      display_color_spaces.GetOutputColorSpace(gfx::ContentColorUsage::kSRGB,
                                               /*needs_alpha=*/true));
  EXPECT_EQ(
      gfx::BufferFormat::RGBA_1010102,
      display_color_spaces.GetOutputBufferFormat(gfx::ContentColorUsage::kHDR,
                                                 /*needs_alpha=*/true));
  EXPECT_EQ(
      gfx::ColorSpace::CreateHDR10(),
      display_color_spaces.GetOutputColorSpace(gfx::ContentColorUsage::kHDR,
                                               /*needs_alpha=*/true));
  EXPECT_EQ(kDefaultHdrMaxLuminanceRelative,
            display_color_spaces.GetHDRMaxLuminanceRelative());
}

TEST_P(DisplayChangeObserverTest, VSyncRateMin) {
  ui::DeviceDataManager::CreateInstance();
  DisplayManager manager(nullptr);
  DisplayChangeObserver observer(&manager);

  // Verify that vsync_rate_min is absent from DisplayInfo when it is not
  // present from the DisplayMode.
  {
    const std::unique_ptr<DisplaySnapshot> display_snapshot =
        FakeDisplaySnapshot::Builder()
            .SetId(123)
            .SetName("AmazingFakeDisplay")
            .SetNativeMode(MakeDisplayMode(1920, 1080, true, 60))
            .Build();
    const std::unique_ptr<DisplayMode> display_mode =
        MakeDisplayMode(1920, 1080, true, 60);
    const ManagedDisplayInfo display_info = CreateManagedDisplayInfo(
        &observer, display_snapshot.get(), display_mode.get());

    EXPECT_EQ(display_info.vsync_rate_min(), std::nullopt);
  }

  // Verify that the value of vsync_rate_min is correctly taken from the display
  // mode.
  {
    const std::unique_ptr<DisplaySnapshot> display_snapshot =
        FakeDisplaySnapshot::Builder()
            .SetId(123)
            .SetName("AmazingFakeDisplay")
            .SetNativeMode(MakeDisplayMode(1920, 1080, true, 60))
            .Build();
    const std::unique_ptr<DisplayMode> display_mode =
        MakeDisplayMode(1920, 1080, true, 60, 48.000488f);
    const ManagedDisplayInfo display_info = CreateManagedDisplayInfo(
        &observer, display_snapshot.get(), display_mode.get());

    EXPECT_EQ(display_info.vsync_rate_min(), 48.000488f);
  }
}

TEST_P(DisplayChangeObserverTest, DisplayModeNativeCalculation) {
  ui::DeviceDataManager::CreateInstance();
  DisplayManager manager(nullptr);
  DisplayChangeObserver observer(&manager);

  // For external display, verify that native attribute is determined by
  // comparing current mode with the DisplaySnapshot's native mode. Native is
  // true when they are the same.
  {
    const std::unique_ptr<DisplaySnapshot> display_snapshot =
        FakeDisplaySnapshot::Builder()
            .SetId(123)
            .SetType(DISPLAY_CONNECTION_TYPE_DISPLAYPORT)
            .SetNativeMode(MakeDisplayMode(1920, 1080, true, 60))
            .SetCurrentMode(MakeDisplayMode(1920, 1080, true, 60))
            .Build();

    const DisplayMode* display_mode = display_snapshot->current_mode();
    const ManagedDisplayInfo display_info = CreateManagedDisplayInfo(
        &observer, display_snapshot.get(), display_mode);

    EXPECT_TRUE(display_info.native());
  }

  // For external display, verify that native attribute is determined by
  // comparing current mode with the DisplaySnapshot's native mode. Native is
  // false when they are different.
  {
    const std::unique_ptr<DisplaySnapshot> display_snapshot =
        FakeDisplaySnapshot::Builder()
            .SetId(123)
            .SetType(DISPLAY_CONNECTION_TYPE_DISPLAYPORT)
            .SetNativeMode(MakeDisplayMode(3840, 2160, true, 60))
            .SetCurrentMode(MakeDisplayMode(1920, 1080, true, 60))
            .Build();

    const DisplayMode* display_mode = display_snapshot->current_mode();
    const ManagedDisplayInfo display_info = CreateManagedDisplayInfo(
        &observer, display_snapshot.get(), display_mode);

    EXPECT_FALSE(display_info.native());
  }

  // For internal display, verify that native attribute is always true.
  {
    const std::unique_ptr<DisplaySnapshot> display_snapshot =
        FakeDisplaySnapshot::Builder()
            .SetId(123)
            .SetType(DISPLAY_CONNECTION_TYPE_INTERNAL)
            .SetCurrentMode(MakeDisplayMode(1920, 1080, true, 60))
            .Build();

    const DisplayMode* display_mode = display_snapshot->current_mode();
    const ManagedDisplayInfo display_info = CreateManagedDisplayInfo(
        &observer, display_snapshot.get(), display_mode);

    EXPECT_TRUE(display_info.native());
  }
}

TEST_P(DisplayChangeObserverTest, OPSDisplayScaleFactor) {
  base::test::ScopedFeatureList scoped_feature_list;
  scoped_feature_list.InitAndEnableFeature(features::kOpsDisplayScaleFactor);
  // Since the only way to set the physical size of FakeDisplaySnapshot is to
  // use dpi, these are the calculated dpis for some common displays from 50 in
  // to 110 in.
  struct OpsTestParam {
    gfx::Size resolution;
    float dpi;
    float expected_scale_factor;
  };
  const OpsTestParam testing_params[] = {
      {k4K_UHD, 80.11f, 2.0f},         // 55"
      {k4K_UHD, 67.78f, 1.6f},         // 65"
      {k4K_UHD, 58.74f, kDsf_1_333},   // 75"
      {k4K_UHD, 51.23f, 1.25f},        // 86"
      {k4K_UHD, 40.05f, 1.0f},         // 110"
      {k4K_WUHD, 60.4f, 1.6f},         // 92"
      {k4K_WUHD, 52.92f, kDsf_1_333},  // 105"
      {k8k_UHD, 160.21f, kDsf_2_666},  // 55"
      {k8k_UHD, 135.56f, kDsf_2_666},  // 65"
      {k8k_UHD, 80.11f, 2.0f},         // 110"
  };
  ui::DeviceDataManager::CreateInstance();
  DisplayManager manager(nullptr);
  DisplayChangeObserver observer(&manager);
  for (const OpsTestParam param : testing_params) {
    const auto snapshot = FakeDisplaySnapshot::Builder()
                              .SetId(10)
                              .SetType(DISPLAY_CONNECTION_TYPE_HDMI)
                              .SetNativeMode(param.resolution)
                              .SetCurrentMode(param.resolution)
                              .SetDPI(param.dpi)
                              .Build();

    const ManagedDisplayInfo managed_display_info = CreateManagedDisplayInfo(
        &observer, snapshot.get(), snapshot->current_mode());

    EXPECT_EQ(managed_display_info.GetEffectiveDeviceScaleFactor(),
              param.expected_scale_factor);
  }
}

INSTANTIATE_TEST_SUITE_P(All,
                         DisplayChangeObserverTest,
                         ::testing::Values(false, true));

using DisplayResolutionTest = testing::Test;

auto CreateDisplay = [](const ManagedDisplayInfo& managed_display_info) {
  Display display(/*id=*/1);
  const float effective_scale =
      managed_display_info.GetEffectiveDeviceScaleFactor();
  display.SetScaleAndBounds(effective_scale,
                            managed_display_info.bounds_in_native());
  EXPECT_EQ(effective_scale, display.device_scale_factor());
  return display;
};

TEST_F(DisplayResolutionTest, CheckEffectiveResolutionUMAIndex) {
  std::map<int, gfx::Size> logical_resolutions;
  for (const auto& display_config : lcd_display_configs) {
    gfx::Size size = display_config.resolution;
    if (size.width() < size.height())
      size = gfx::Size(size.height(), size.width());

    const float dsf = display_config.expected_dsf;

    std::array<float, kNumOfZoomFactors> zoom_levels;
    bool found = false;
    if (dsf == 1.f) {
      for (const ZoomListBucket& zoom_list_bucket : kZoomListBuckets) {
        if (size.width() >= zoom_list_bucket.first) {
          zoom_levels = zoom_list_bucket.second;
          found = true;
        }
      }
    } else {
      for (const ZoomListBucketDsf& zoom_list_bucket : kZoomListBucketsForDsf) {
        if (cc::MathUtil::IsWithinEpsilon(dsf, zoom_list_bucket.first)) {
          zoom_levels = zoom_list_bucket.second;
          found = true;
        }
      }
    }
    EXPECT_TRUE(found);
    for (float zoom_level : zoom_levels) {
      ManagedDisplayInfo info;
      info.set_device_scale_factor(dsf);
      info.set_zoom_factor(zoom_level);
      info.SetBounds(gfx::Rect(size));

      Display display = CreateDisplay(info);

      gfx::Size logical_resolution = display.size();
      gfx::Size portrait_logical_resolution = logical_resolution;
      portrait_logical_resolution.Transpose();

      const int landscape_key =
          logical_resolution.width() * logical_resolution.height();
      const int portrait_key = landscape_key - 1;

      auto it = logical_resolutions.find(landscape_key);
      if (it != logical_resolutions.end()) {
        EXPECT_EQ(it->second, logical_resolution);
      } else {
        logical_resolutions[landscape_key] = logical_resolution;
      }

      it = logical_resolutions.find(portrait_key);
      if (it != logical_resolutions.end()) {
        EXPECT_EQ(it->second, portrait_logical_resolution);
      } else {
        logical_resolutions[portrait_key] = portrait_logical_resolution;
      }
    }
  }

#if 0
  //  Enable this code to re-generate the "EffectiveResolution" in enums.xml.
  for (auto pair : logical_resolutions) {
    std::cout << "  <int value=\"" << pair.first << "\" label=\""
               << pair.second.width() << " x " << pair.second.height()
              << "\"/>" << std::endl;
  }
#endif

  // With the current set of display configs and zoom levels, there are only 356
  // possible effective resolutions for internal displays in chromebooks. Update
  // this value when adding a new display config, and re-generate the
  // EffectiveResolution value in enum.xml.
  EXPECT_EQ(logical_resolutions.size(), 356ul);
}

// Make sure that when display zoom is applied, the effective device scale
// factor (device_scale_factor * zoomfactor) and the rational number (pixel
// width / logical with) is close enough (<kDeviceScaleFactorErrorTolerance).
TEST_F(DisplayResolutionTest, DisplayZoom) {
  // For internal displays
  for (auto& config : lcd_display_configs) {
    const float dpi = ComputeDpi(config.diagonal_size, config.resolution);
    const auto snapshot = FakeDisplaySnapshot::Builder()
                              .SetId(10)
                              .SetType(DISPLAY_CONNECTION_TYPE_INTERNAL)
                              .SetNativeMode(config.resolution)
                              .SetCurrentMode(config.resolution)
                              .SetDPI(dpi)
                              .Build();
    const auto* native_mode = snapshot->native_mode();
    auto managed_display_info = DisplayChangeObserver::CreateManagedDisplayInfo(
        snapshot.get(), native_mode,
        /*native=*/true, config.expected_dsf, dpi, std::string());
    const std::vector<float> zooms =
        GetDisplayZoomFactors(managed_display_info.display_modes()[0]);
    // For default scale factor, they should be the same.
    EXPECT_NEAR(config.expected_dsf,
                managed_display_info.GetEffectiveDeviceScaleFactor(),
                0.0000001);

    for (auto zoom : zooms) {
      managed_display_info.set_zoom_factor(zoom);
      const Display display = CreateDisplay(managed_display_info);

      // Emulate how arc computes the scale factor.
      const float scale_factor = config.resolution.width() /
                                 static_cast<float>(display.size().width());
      EXPECT_NEAR(scale_factor, display.device_scale_factor(),
                  kDeviceScaleFactorErrorTolerance);
    }
  }

  // Typical external display sizes.
  constexpr gfx::Size kExternalDisplaySizes[] = {
      {4096, 2160}, {3840, 2160}, {3440, 1440}, {2560, 1600}, {2560, 1440},
      {1920, 1200}, {1920, 1080}, {1600, 900},  {1440, 900}};
  for (auto& size : kExternalDisplaySizes) {
    const auto snapshot = FakeDisplaySnapshot::Builder()
                              .SetId(10)
                              .SetType(DISPLAY_CONNECTION_TYPE_HDMI)
                              .SetNativeMode(size)
                              .SetCurrentMode(size)
                              .Build();
    const auto* native_mode = snapshot->native_mode();
    auto managed_display_info = DisplayChangeObserver::CreateManagedDisplayInfo(
        snapshot.get(), native_mode,
        /*native=*/true, /*device_scale_factor=*/1.0f, /*dpi=*/160,
        std::string());
    const std::vector<float> zooms =
        GetDisplayZoomFactors(managed_display_info.display_modes()[0]);

    for (auto zoom : zooms) {
      managed_display_info.set_zoom_factor(zoom);
      const Display display = CreateDisplay(managed_display_info);

      // Emulate how arc computes the scale factor.
      const float scale_factor =
          size.width() / static_cast<float>(display.size().width());
      EXPECT_NEAR(scale_factor, display.device_scale_factor(),
                  kDeviceScaleFactorErrorTolerance);
    }
  }
}

}  // namespace display