(NotForReview) Enable YUV video overlay on Skylake ChromeOS.

ui/ozone/platform/drm/gpu/drm_overlay_validator_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // 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_overlay_validator.h"
 
 #include <drm_fourcc.h>
 
 #include <memory>
 #include <utility>
@@ skipping 173 matching lines @@
   EXPECT_TRUE(validated_params.front().is_overlay_candidate);
   EXPECT_FALSE(validated_params.back().is_overlay_candidate);
 }
 
 TEST_F(DrmOverlayValidatorTest, ClearCacheOnReset) {
   // This test checks if we invalidate cache when Reset is called.
   overlay_params_.back().buffer_size = overlay_rect_.size();
   overlay_params_.back().display_rect = overlay_rect_;
   plane_list_.back().display_bounds = overlay_rect_;
   std::vector<uint32_t> xrgb_yuv_packed_formats = {DRM_FORMAT_XRGB8888,
-                                                   DRM_FORMAT_UYVY};
+                                                   DRM_FORMAT_YUYV};
 
   ui::FakePlaneInfo primary_plane_info(
       100, 1 << 0, std::vector<uint32_t>(1, DRM_FORMAT_XRGB8888));
   ui::FakePlaneInfo overlay_info(101, 1 << 0, xrgb_yuv_packed_formats);
   std::vector<ui::FakePlaneInfo> planes_info{primary_plane_info, overlay_info};
   plane_manager_->SetPlaneProperties(planes_info);
   overlay_validator_->ClearCache();
 
   overlay_validator_->TestPageFlip(overlay_params_, ui::OverlayPlaneList());
 
@@ skipping 12 matching lines @@
 
 TEST_F(DrmOverlayValidatorTest, ClearCacheOnResetWithScaling) {
   // This test checks if we invalidate cache when Reset is called.
   gfx::RectF crop_rect = gfx::RectF(0, 0, 0.5, 0.5);
   overlay_params_.back().buffer_size = overlay_rect_.size();
   overlay_params_.back().display_rect = overlay_rect_;
   overlay_params_.back().crop_rect = crop_rect;
   plane_list_.back().display_bounds = overlay_rect_;
   plane_list_.back().crop_rect = crop_rect;
   std::vector<uint32_t> xrgb_yuv_packed_formats = {DRM_FORMAT_XRGB8888,
-                                                   DRM_FORMAT_UYVY};
+                                                   DRM_FORMAT_YUYV};
 
   ui::FakePlaneInfo primary_plane_info(
       100, 1 << 0, std::vector<uint32_t>(1, DRM_FORMAT_XRGB8888));
   ui::FakePlaneInfo overlay_info(101, 1 << 0, xrgb_yuv_packed_formats);
   std::vector<ui::FakePlaneInfo> planes_info{primary_plane_info, overlay_info};
   plane_manager_->SetPlaneProperties(planes_info);
   overlay_validator_->ClearCache();
 
   overlay_validator_->TestPageFlip(overlay_params_, ui::OverlayPlaneList());
 
   ui::OverlayPlaneList plane_list =
       overlay_validator_->PrepareBuffersForPageFlip(plane_list_);
   // Scaling allows format conversion.
-  EXPECT_EQ(DRM_FORMAT_UYVY,
+  EXPECT_EQ(DRM_FORMAT_YUYV,
             plane_list.back().buffer->GetFramebufferPixelFormat());
   // Check if ClearCache actually clears the cache.
   overlay_validator_->ClearCache();
   plane_list = overlay_validator_->PrepareBuffersForPageFlip(plane_list_);
   // There should be no entry in cache for this configuration and should return
   // default value of DRM_FORMAT_XRGB8888.
   EXPECT_EQ(DRM_FORMAT_XRGB8888,
             plane_list.back().buffer->GetFramebufferPixelFormat());
 }
 
 TEST_F(DrmOverlayValidatorTest, OptimalFormatForOverlayInFullScreen_XRGB) {
   // Optimal format for Overlay configuration should be XRGB, when primary plane
   // supports only XRGB and overlay obscures primary.
   overlay_params_.back().buffer_size = primary_rect_.size();
   overlay_params_.back().display_rect = primary_rect_;
   plane_list_.back().display_bounds = primary_rect_;
 
   // Check optimal format for Overlay.
   ui::FakePlaneInfo primary_plane_info(
       100, 1 << 0, std::vector<uint32_t>(1, DRM_FORMAT_XRGB8888));
   std::vector<uint32_t> xrgb_yuv_packed_formats = {DRM_FORMAT_XRGB8888,
-                                                   DRM_FORMAT_UYVY};
+                                                   DRM_FORMAT_YUYV};
   ui::FakePlaneInfo plane_info(101, 1 << 0, xrgb_yuv_packed_formats);
 
   std::vector<ui::FakePlaneInfo> planes{primary_plane_info, plane_info};
   plane_manager_->SetPlaneProperties(planes);
   overlay_validator_->ClearCache();
 
   overlay_validator_->TestPageFlip(overlay_params_, ui::OverlayPlaneList());
   ui::OverlayPlaneList plane_list =
       overlay_validator_->PrepareBuffersForPageFlip(plane_list_);
   EXPECT_EQ(DRM_FORMAT_XRGB8888,
             plane_list.back().buffer->GetFramebufferPixelFormat());
 }
 
 TEST_F(DrmOverlayValidatorTest, OptimalFormatForOverlayInFullScreen_YUV) {
   overlay_params_.back().buffer_size = primary_rect_.size();
   overlay_params_.back().display_rect = primary_rect_;
   plane_list_.back().display_bounds = primary_rect_;
   std::vector<uint32_t> xrgb_yuv_packed_formats = {DRM_FORMAT_XRGB8888,
-                                                   DRM_FORMAT_UYVY};
+                                                   DRM_FORMAT_YUYV};
 
   // We should prefer YUV when primary can support it.
   ui::FakePlaneInfo primary_plane_info(100, 1 << 0, xrgb_yuv_packed_formats);
   ui::FakePlaneInfo plane_info(101, 1 << 0, xrgb_yuv_packed_formats);
 
   std::vector<ui::FakePlaneInfo> planes{primary_plane_info, plane_info};
   plane_manager_->SetPlaneProperties(planes);
   overlay_validator_->ClearCache();
 
   overlay_validator_->TestPageFlip(overlay_params_, ui::OverlayPlaneList());
   ui::OverlayPlaneList plane_list =
       overlay_validator_->PrepareBuffersForPageFlip(plane_list_);
-  // TODO(dcastagna): If Atomic support is enabled, a packed format (UYVY) might
+  // TODO(dcastagna): If Atomic support is enabled, a packed format (YUYV) might
   // be the optimal one and should be preferred.
   EXPECT_EQ(DRM_FORMAT_XRGB8888,
             plane_list.back().buffer->GetFramebufferPixelFormat());
 }
 
 TEST_F(DrmOverlayValidatorTest, OverlayPreferredFormat) {
   plane_manager_->ResetPlaneCount();
   // This test checks for optimal format in case of non full screen video case.
   overlay_params_.back().buffer_size = overlay_rect_.size();
   overlay_params_.back().display_rect = overlay_rect_;
   plane_list_.back().display_bounds = overlay_rect_;
 
   std::vector<uint32_t> xrgb_yuv_packed_formats = {DRM_FORMAT_XRGB8888,
-                                                   DRM_FORMAT_UYVY};
+                                                   DRM_FORMAT_YUYV};
   ui::FakePlaneInfo primary_plane_info(
       100, 1 << 0, std::vector<uint32_t>(1, DRM_FORMAT_XRGB8888));
   ui::FakePlaneInfo overlay_info(101, 1 << 0, xrgb_yuv_packed_formats);
   std::vector<ui::FakePlaneInfo> planes_info{primary_plane_info, overlay_info};
   plane_manager_->SetPlaneProperties(planes_info);
   overlay_validator_->ClearCache();
 
   std::vector<ui::OverlayCheck_Params> validated_params =
       overlay_validator_->TestPageFlip(overlay_params_, ui::OverlayPlaneList());
 
@@ skipping 14 matching lines @@
   // Prefer YUV as optimal format when Overlay supports it and scaling is
   // needed.
   gfx::RectF crop_rect = gfx::RectF(0, 0, 0.5, 0.5);
   overlay_params_.back().buffer_size = overlay_rect_.size();
   overlay_params_.back().display_rect = overlay_rect_;
   overlay_params_.back().crop_rect = crop_rect;
   plane_list_.back().display_bounds = overlay_rect_;
   plane_list_.back().crop_rect = crop_rect;
 
   std::vector<uint32_t> xrgb_yuv_packed_formats = {DRM_FORMAT_XRGB8888,
-                                                   DRM_FORMAT_UYVY};
+                                                   DRM_FORMAT_YUYV};
   ui::FakePlaneInfo primary_plane_info(
       100, 1 << 0, std::vector<uint32_t>(1, DRM_FORMAT_XRGB8888));
   ui::FakePlaneInfo overlay_info(101, 1 << 0, xrgb_yuv_packed_formats);
   std::vector<ui::FakePlaneInfo> planes_info{primary_plane_info, overlay_info};
   plane_manager_->SetPlaneProperties(planes_info);
   overlay_validator_->ClearCache();
 
   std::vector<ui::OverlayCheck_Params> validated_params =
       overlay_validator_->TestPageFlip(overlay_params_, ui::OverlayPlaneList());
 
   for (const auto& param : validated_params)
     EXPECT_TRUE(param.is_overlay_candidate);
 
   EXPECT_EQ(5, plane_manager_->plane_count());
 
   ui::OverlayPlaneList plane_list =
       overlay_validator_->PrepareBuffersForPageFlip(plane_list_);
-  EXPECT_EQ(DRM_FORMAT_UYVY,
+  EXPECT_EQ(DRM_FORMAT_YUYV,
             plane_list.back().buffer->GetFramebufferPixelFormat());
 }
 
 TEST_F(DrmOverlayValidatorTest, OverlayPreferredFormat_XRGB) {
   plane_manager_->ResetPlaneCount();
   // This test checks for optimal format in case of non full screen video case.
   // This should be XRGB when overlay doesn't support YUV.
   overlay_params_.back().buffer_size = overlay_rect_.size();
   overlay_params_.back().display_rect = overlay_rect_;
   plane_list_.back().display_bounds = overlay_rect_;
 
   std::vector<uint32_t> xrgb_yuv_packed_formats = {DRM_FORMAT_XRGB8888,
-                                                   DRM_FORMAT_UYVY};
+                                                   DRM_FORMAT_YUYV};
   ui::FakePlaneInfo primary_plane_info(100, 1 << 0, xrgb_yuv_packed_formats);
   ui::FakePlaneInfo overlay_info(101, 1 << 0,
                                  std::vector<uint32_t>(1, DRM_FORMAT_XRGB8888));
   std::vector<ui::FakePlaneInfo> planes_info{primary_plane_info, overlay_info};
   plane_manager_->SetPlaneProperties(planes_info);
   overlay_validator_->ClearCache();
 
   std::vector<ui::OverlayCheck_Params> validated_params =
       overlay_validator_->TestPageFlip(overlay_params_, ui::OverlayPlaneList());
   ui::OverlayPlaneList plane_list =
       overlay_validator_->PrepareBuffersForPageFlip(plane_list_);
   EXPECT_EQ(DRM_FORMAT_XRGB8888,
             plane_list.back().buffer->GetFramebufferPixelFormat());
   EXPECT_EQ(3, plane_manager_->plane_count());
   for (const auto& param : validated_params)
     EXPECT_TRUE(param.is_overlay_candidate);
 }
 
 TEST_F(DrmOverlayValidatorTest, RejectYUVBuffersIfNotSupported) {
   plane_manager_->ResetPlaneCount();
-  // Check case where buffer storage format is already UYVY but planes dont
+  // Check case where buffer storage format is already YUYV but planes dont
   // support it.
   overlay_params_.back().buffer_size = overlay_rect_.size();
   overlay_params_.back().display_rect = overlay_rect_;
   plane_list_.back().display_bounds = overlay_rect_;
 
   std::vector<uint32_t> xrgb_yuv_packed_formats = {DRM_FORMAT_XRGB8888,
-                                                   DRM_FORMAT_UYVY};
+                                                   DRM_FORMAT_YUYV};
   ui::FakePlaneInfo primary_plane_info(100, 1 << 0, xrgb_yuv_packed_formats);
   ui::FakePlaneInfo overlay_info(101, 1 << 0,
                                  std::vector<uint32_t>(1, DRM_FORMAT_XRGB8888));
   std::vector<ui::FakePlaneInfo> planes_info{primary_plane_info, overlay_info};
   plane_manager_->SetPlaneProperties(planes_info);
   overlay_validator_->ClearCache();
 
   std::vector<ui::OverlayCheck_Params> validated_params = overlay_params_;
-  validated_params.back().format = gfx::BufferFormat::UYVY_422;
+  validated_params.back().format = gfx::BufferFormat::YUYV_422;
   plane_manager_->ResetPlaneCount();
   validated_params = overlay_validator_->TestPageFlip(validated_params,
                                                       ui::OverlayPlaneList());
 
   EXPECT_FALSE(validated_params.back().is_overlay_candidate);
 }
 
 TEST_F(DrmOverlayValidatorTest,
        RejectYUVBuffersIfNotSupported_MirroredControllers) {
   std::vector<uint32_t> crtcs{kDefaultCrtc, kSecondaryCrtc};
   plane_manager_->SetCrtcInfo(crtcs);
 
   std::vector<uint32_t> only_rgb_format{DRM_FORMAT_XRGB8888};
   std::vector<uint32_t> xrgb_yuv_packed_formats{DRM_FORMAT_XRGB8888,
-                                                DRM_FORMAT_UYVY};
+                                                DRM_FORMAT_YUYV};
   ui::HardwareDisplayController* controller = window_->GetController();
   controller->AddCrtc(std::unique_ptr<ui::CrtcController>(
       new ui::CrtcController(drm_.get(), kSecondaryCrtc, kSecondaryConnector)));
   ui::OverlayPlane plane1(scoped_refptr<ui::ScanoutBuffer>(
       new ui::MockScanoutBuffer(primary_rect_.size())));
   EXPECT_TRUE(controller->Modeset(plane1, kDefaultMode));
 
   gfx::RectF crop_rect = gfx::RectF(0, 0, 0.5, 0.5);
   overlay_params_.back().buffer_size = overlay_rect_.size();
   overlay_params_.back().display_rect = overlay_rect_;
   overlay_params_.back().crop_rect = crop_rect;
   plane_list_.back().display_bounds = overlay_rect_;
   plane_list_.back().crop_rect = crop_rect;
 
   ui::FakePlaneInfo primary_crtc_primary_plane(100, 1 << 0, only_rgb_format);
   ui::FakePlaneInfo primary_crtc_overlay(101, 1 << 0, xrgb_yuv_packed_formats);
   ui::FakePlaneInfo secondary_crtc_primary_plane(102, 1 << 1, only_rgb_format);
   ui::FakePlaneInfo secondary_crtc_overlay(103, 1 << 1,
                                            xrgb_yuv_packed_formats);
 
   std::vector<ui::FakePlaneInfo> planes_info{
       primary_crtc_primary_plane, primary_crtc_overlay,
       secondary_crtc_primary_plane, secondary_crtc_overlay};
   plane_manager_->SetPlaneProperties(planes_info);
   overlay_validator_->ClearCache();
 
   std::vector<ui::OverlayCheck_Params> validated_params = overlay_params_;
-  validated_params.back().format = gfx::BufferFormat::UYVY_422;
+  validated_params.back().format = gfx::BufferFormat::YUYV_422;
   plane_manager_->ResetPlaneCount();
   validated_params = overlay_validator_->TestPageFlip(validated_params,
                                                       ui::OverlayPlaneList());
 
   EXPECT_TRUE(validated_params.back().is_overlay_candidate);
 
-  // Both controllers have Overlay which support DRM_FORMAT_UYVY, and scaling is
+  // Both controllers have Overlay which support DRM_FORMAT_YUYV, and scaling is
   // needed, hence this should be picked as the optimal format.
   ui::OverlayPlaneList plane_list =
       overlay_validator_->PrepareBuffersForPageFlip(plane_list_);
-  EXPECT_EQ(DRM_FORMAT_UYVY,
+  EXPECT_EQ(DRM_FORMAT_YUYV,
             plane_list.back().buffer->GetFramebufferPixelFormat());
 
   // This configuration should not be promoted to Overlay when either of the
-  // controllers dont support UYVY format.
+  // controllers dont support YUYV format.
 
   // Check case where we dont have support for packed formats in Mirrored CRTC.
   planes_info.back().allowed_formats = only_rgb_format;
   plane_manager_->SetPlaneProperties(planes_info);
   overlay_validator_->ClearCache();
 
   validated_params = overlay_validator_->TestPageFlip(validated_params,
                                                       ui::OverlayPlaneList());
   EXPECT_FALSE(validated_params.back().is_overlay_candidate);
 
@@ skipping 20 matching lines @@
       new ui::CrtcController(drm_.get(), kSecondaryCrtc, kSecondaryConnector)));
   ui::OverlayPlane plane1(scoped_refptr<ui::ScanoutBuffer>(
       new ui::MockScanoutBuffer(primary_rect_.size())));
   EXPECT_TRUE(controller->Modeset(plane1, kDefaultMode));
 
   overlay_params_.back().buffer_size = overlay_rect_.size();
   overlay_params_.back().display_rect = overlay_rect_;
   plane_list_.back().display_bounds = overlay_rect_;
   std::vector<uint32_t> only_rgb_format = {DRM_FORMAT_XRGB8888};
   std::vector<uint32_t> xrgb_yuv_packed_formats = {DRM_FORMAT_XRGB8888,
-                                                   DRM_FORMAT_UYVY};
+                                                   DRM_FORMAT_YUYV};
 
   ui::FakePlaneInfo primary_crtc_primary_plane(100, 1 << 0, only_rgb_format);
   ui::FakePlaneInfo primary_crtc_overlay(101, 1 << 0, xrgb_yuv_packed_formats);
   ui::FakePlaneInfo secondary_crtc_primary_plane(102, 1 << 1, only_rgb_format);
   ui::FakePlaneInfo secondary_crtc_overlay(103, 1 << 1,
                                            xrgb_yuv_packed_formats);
 
   std::vector<ui::FakePlaneInfo> planes_info{
       primary_crtc_primary_plane, primary_crtc_overlay,
       secondary_crtc_primary_plane, secondary_crtc_overlay};
@@ skipping 43 matching lines @@
 TEST_F(DrmOverlayValidatorTest, OptimizeOnlyIfProcessingCallbackPresent) {
   // This test checks that we dont manipulate overlay buffers in case Processing
   // callback is not present.
   gfx::RectF crop_rect = gfx::RectF(0, 0, 0.5, 0.5);
   overlay_params_.back().buffer_size = overlay_rect_.size();
   overlay_params_.back().display_rect = overlay_rect_;
   overlay_params_.back().crop_rect = crop_rect;
   plane_list_.back().display_bounds = overlay_rect_;
   plane_list_.back().crop_rect = crop_rect;
   std::vector<uint32_t> xrgb_yuv_packed_formats = {DRM_FORMAT_XRGB8888,
-                                                   DRM_FORMAT_UYVY};
+                                                   DRM_FORMAT_YUYV};
 
   ui::FakePlaneInfo primary_plane_info(
       100, 1 << 0, std::vector<uint32_t>(1, DRM_FORMAT_XRGB8888));
   ui::FakePlaneInfo overlay_info(101, 1 << 0, xrgb_yuv_packed_formats);
   std::vector<ui::FakePlaneInfo> planes_info{primary_plane_info, overlay_info};
   plane_manager_->SetPlaneProperties(planes_info);
   overlay_validator_->ClearCache();
 
   overlay_validator_->TestPageFlip(overlay_params_, ui::OverlayPlaneList());
 
   ui::OverlayPlaneList plane_list =
       overlay_validator_->PrepareBuffersForPageFlip(plane_list_);
   // Scaling allows format conversion.
-  EXPECT_EQ(DRM_FORMAT_UYVY,
+  EXPECT_EQ(DRM_FORMAT_YUYV,
             plane_list.back().buffer->GetFramebufferPixelFormat());
   plane_list_.back().processing_callback.Reset();
   plane_list = overlay_validator_->PrepareBuffersForPageFlip(plane_list_);
   EXPECT_EQ(plane_list_.back().buffer->GetFramebufferPixelFormat(),
             plane_list.back().buffer->GetFramebufferPixelFormat());
   plane_list_.back().processing_callback = process_buffer_handler_;
 }
 
 TEST_F(DrmOverlayValidatorTest, DontResetOriginalBufferIfProcessedIsInvalid) {
   // This test checks that we dont manipulate overlay buffers in case Processing
   // callback is not present.
   gfx::RectF crop_rect = gfx::RectF(0, 0, 0.5, 0.5);
   overlay_params_.back().buffer_size = overlay_rect_.size();
   overlay_params_.back().display_rect = overlay_rect_;
   overlay_params_.back().crop_rect = crop_rect;
   plane_list_.back().display_bounds = overlay_rect_;
   plane_list_.back().crop_rect = crop_rect;
   std::vector<uint32_t> xrgb_yuv_packed_formats = {DRM_FORMAT_XRGB8888,
-                                                   DRM_FORMAT_UYVY};
+                                                   DRM_FORMAT_YUYV};
 
   ui::FakePlaneInfo primary_plane_info(
       100, 1 << 0, std::vector<uint32_t>(1, DRM_FORMAT_XRGB8888));
   ui::FakePlaneInfo overlay_info(101, 1 << 0, xrgb_yuv_packed_formats);
   std::vector<ui::FakePlaneInfo> planes_info{primary_plane_info, overlay_info};
   plane_manager_->SetPlaneProperties(planes_info);
   overlay_validator_->ClearCache();
 
   overlay_validator_->TestPageFlip(overlay_params_, ui::OverlayPlaneList());
 
   ui::OverlayPlaneList plane_list =
       overlay_validator_->PrepareBuffersForPageFlip(plane_list_);
   // Scaling allows format conversion.
-  EXPECT_EQ(DRM_FORMAT_UYVY,
+  EXPECT_EQ(DRM_FORMAT_YUYV,
             plane_list.back().buffer->GetFramebufferPixelFormat());
   plane_list_.back().processing_callback = base::Bind(
       &DrmOverlayValidatorTest::ReturnNullBuffer, base::Unretained(this));
 
   plane_list = overlay_validator_->PrepareBuffersForPageFlip(plane_list_);
   EXPECT_EQ(plane_list_.back().buffer->GetFramebufferPixelFormat(),
             plane_list.back().buffer->GetFramebufferPixelFormat());
   plane_list_.back().processing_callback = base::Bind(
       &DrmOverlayValidatorTest::ProcessBuffer, base::Unretained(this));
 }
 
 TEST_F(DrmOverlayValidatorTest, RejectBufferAllocationFail) {
   // Buffer allocation for scanout might fail.
   // In that case we should reject the overlay candidate.
   buffer_generator_->set_allocation_failure(true);
 
   std::vector<ui::OverlayCheck_Params> validated_params =
       overlay_validator_->TestPageFlip(overlay_params_, ui::OverlayPlaneList());
   EXPECT_FALSE(validated_params.front().is_overlay_candidate);
 }