ozone: introduce OverlayCheckReturn_Params

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 139 matching lines @@
       screen_manager_->RemoveWindow(kDefaultWidgetHandle);
   window->Shutdown();
   message_loop_.reset();
 }
 
 TEST_F(DrmOverlayValidatorTest, WindowWithNoController) {
   // We should never promote layers to overlay when controller is not
   // present.
   ui::HardwareDisplayController* controller = window_->GetController();
   window_->SetController(nullptr);
-  std::vector<ui::OverlayCheck_Params> validated_params =
+  std::vector<ui::OverlayCheckReturn_Params> returns =
       overlay_validator_->TestPageFlip(overlay_params_, ui::OverlayPlaneList());
-  EXPECT_FALSE(validated_params.front().is_overlay_candidate);
-  EXPECT_FALSE(validated_params.back().is_overlay_candidate);
+  EXPECT_EQ(returns.front().status, ui::OverlayCheckReturn_Params::Status::Not);
+  EXPECT_EQ(returns.back().status, ui::OverlayCheckReturn_Params::Status::Not);
   window_->SetController(controller);
 }
 
 TEST_F(DrmOverlayValidatorTest, DontPromoteMoreLayersThanAvailablePlanes) {
-  std::vector<ui::OverlayCheck_Params> validated_params =
+  std::vector<ui::OverlayCheckReturn_Params> returns =
       overlay_validator_->TestPageFlip(overlay_params_, ui::OverlayPlaneList());
-  EXPECT_TRUE(validated_params.front().is_overlay_candidate);
-  EXPECT_FALSE(validated_params.back().is_overlay_candidate);
+  EXPECT_EQ(returns.front().status,
+            ui::OverlayCheckReturn_Params::Status::Able);
+  EXPECT_EQ(returns.back().status, ui::OverlayCheckReturn_Params::Status::Not);
 }
 
 TEST_F(DrmOverlayValidatorTest, DontCollapseOverlayToPrimaryInFullScreen) {
   // Overlay Validator should not collapse planes during validation.
   overlay_params_.back().buffer_size = primary_rect_.size();
   overlay_params_.back().display_rect = primary_rect_;
   plane_list_.back().display_bounds = primary_rect_;
 
-  std::vector<ui::OverlayCheck_Params> validated_params =
+  std::vector<ui::OverlayCheckReturn_Params> returns =
       overlay_validator_->TestPageFlip(overlay_params_, ui::OverlayPlaneList());
   // Second candidate should be marked as Invalid as we have only one plane
   // per CRTC.
-  EXPECT_TRUE(validated_params.front().is_overlay_candidate);
-  EXPECT_FALSE(validated_params.back().is_overlay_candidate);
+  EXPECT_EQ(returns.front().status,
+            ui::OverlayCheckReturn_Params::Status::Able);
+  EXPECT_EQ(returns.back().status, ui::OverlayCheckReturn_Params::Status::Not);
 }
 
 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};
 
@@ skipping 111 matching lines @@
 
   std::vector<uint32_t> xrgb_yuv_packed_formats = {DRM_FORMAT_XRGB8888,
                                                    DRM_FORMAT_UYVY};
   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 =
+  std::vector<ui::OverlayCheckReturn_Params> returns =
       overlay_validator_->TestPageFlip(overlay_params_, ui::OverlayPlaneList());
 
-  for (const auto& param : validated_params)
-    EXPECT_TRUE(param.is_overlay_candidate);
+  for (const auto& param : returns)
+    EXPECT_EQ(param.status, ui::OverlayCheckReturn_Params::Status::Able);
 
   EXPECT_EQ(3, plane_manager_->plane_count());
 
   ui::OverlayPlaneList plane_list =
       overlay_validator_->PrepareBuffersForPageFlip(plane_list_);
   EXPECT_EQ(DRM_FORMAT_XRGB8888,
             plane_list.back().buffer->GetFramebufferPixelFormat());
 }
 
 TEST_F(DrmOverlayValidatorTest, OverlayPreferredFormat_YUV) {
@@ skipping 10 matching lines @@
 
   std::vector<uint32_t> xrgb_yuv_packed_formats = {DRM_FORMAT_XRGB8888,
                                                    DRM_FORMAT_UYVY};
   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 =
+  std::vector<ui::OverlayCheckReturn_Params> returns =
       overlay_validator_->TestPageFlip(overlay_params_, ui::OverlayPlaneList());
 
-  for (const auto& param : validated_params)
-    EXPECT_TRUE(param.is_overlay_candidate);
+  for (const auto& param : returns)
+    EXPECT_EQ(param.status, ui::OverlayCheckReturn_Params::Status::Able);
 
   EXPECT_EQ(5, plane_manager_->plane_count());
 
   ui::OverlayPlaneList plane_list =
       overlay_validator_->PrepareBuffersForPageFlip(plane_list_);
   EXPECT_EQ(DRM_FORMAT_UYVY,
             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};
   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 =
+  std::vector<ui::OverlayCheckReturn_Params> returns =
       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);
+  for (const auto& param : returns)
+    EXPECT_EQ(param.status, ui::OverlayCheckReturn_Params::Status::Able);
 }
 
 TEST_F(DrmOverlayValidatorTest, RejectYUVBuffersIfNotSupported) {
   plane_manager_->ResetPlaneCount();
   // Check case where buffer storage format is already UYVY 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};
   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;
   plane_manager_->ResetPlaneCount();
-  validated_params = overlay_validator_->TestPageFlip(validated_params,
-                                                      ui::OverlayPlaneList());
+  std::vector<ui::OverlayCheckReturn_Params> returns =
+      overlay_validator_->TestPageFlip(validated_params,
+                                       ui::OverlayPlaneList());
 
-  EXPECT_FALSE(validated_params.back().is_overlay_candidate);
+  EXPECT_EQ(returns.back().status, ui::OverlayCheckReturn_Params::Status::Not);
 }
 
 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};
@@ skipping 19 matching lines @@
 
   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;
   plane_manager_->ResetPlaneCount();
-  validated_params = overlay_validator_->TestPageFlip(validated_params,
-                                                      ui::OverlayPlaneList());
+  std::vector<ui::OverlayCheckReturn_Params> returns =
+      overlay_validator_->TestPageFlip(validated_params,
+                                       ui::OverlayPlaneList());
 
-  EXPECT_TRUE(validated_params.back().is_overlay_candidate);
+  EXPECT_EQ(returns.back().status, ui::OverlayCheckReturn_Params::Status::Able);
 
   // Both controllers have Overlay which support DRM_FORMAT_UYVY, 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,
             plane_list.back().buffer->GetFramebufferPixelFormat());
 
   // This configuration should not be promoted to Overlay when either of the
   // controllers dont support UYVY 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);
+  returns = overlay_validator_->TestPageFlip(validated_params,
+                                             ui::OverlayPlaneList());
+  EXPECT_EQ(returns.back().status, ui::OverlayCheckReturn_Params::Status::Not);
 
   // Check case where we dont have support for packed formats in primary
   // display.
   planes_info.back().allowed_formats = xrgb_yuv_packed_formats;
   planes_info[1].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);
+  returns = overlay_validator_->TestPageFlip(validated_params,
+                                             ui::OverlayPlaneList());
+  EXPECT_EQ(returns.back().status, ui::OverlayCheckReturn_Params::Status::Not);
   controller->RemoveCrtc(drm_, kSecondaryCrtc);
 }
 
 TEST_F(DrmOverlayValidatorTest, OptimalFormatYUV_MirroredControllers) {
   std::vector<uint32_t> crtcs{kDefaultCrtc, kSecondaryCrtc};
   plane_manager_->SetCrtcInfo(crtcs);
   overlay_validator_->ClearCache();
 
   ui::HardwareDisplayController* controller = window_->GetController();
   controller->AddCrtc(std::unique_ptr<ui::CrtcController>(
@@ skipping 15 matching lines @@
   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();
 
   plane_manager_->ResetPlaneCount();
-  std::vector<ui::OverlayCheck_Params> validated_params =
+  std::vector<ui::OverlayCheckReturn_Params> returns =
       overlay_validator_->TestPageFlip(overlay_params_, ui::OverlayPlaneList());
 
-  EXPECT_TRUE(validated_params.back().is_overlay_candidate);
+  EXPECT_EQ(returns.back().status, ui::OverlayCheckReturn_Params::Status::Able);
   ui::OverlayPlaneList plane_list =
       overlay_validator_->PrepareBuffersForPageFlip(plane_list_);
   EXPECT_EQ(DRM_FORMAT_XRGB8888,
             plane_list.back().buffer->GetFramebufferPixelFormat());
 
   // 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 =
+  returns =
       overlay_validator_->TestPageFlip(overlay_params_, ui::OverlayPlaneList());
-  EXPECT_TRUE(validated_params.back().is_overlay_candidate);
+  EXPECT_EQ(returns.back().status, ui::OverlayCheckReturn_Params::Status::Able);
 
   plane_list = overlay_validator_->PrepareBuffersForPageFlip(plane_list_);
   EXPECT_EQ(DRM_FORMAT_XRGB8888,
             plane_list.back().buffer->GetFramebufferPixelFormat());
 
   // Check case where we dont have support for packed formats in primary
   // display.
   planes_info.back().allowed_formats = xrgb_yuv_packed_formats;
   planes_info[1].allowed_formats = only_rgb_format;
   plane_manager_->SetPlaneProperties(planes_info);
   overlay_validator_->ClearCache();
 
-  validated_params =
+  returns =
       overlay_validator_->TestPageFlip(overlay_params_, ui::OverlayPlaneList());
-  EXPECT_TRUE(validated_params.back().is_overlay_candidate);
+  EXPECT_EQ(returns.back().status, ui::OverlayCheckReturn_Params::Status::Able);
 
   plane_list = overlay_validator_->PrepareBuffersForPageFlip(plane_list_);
   EXPECT_EQ(DRM_FORMAT_XRGB8888,
             plane_list.back().buffer->GetFramebufferPixelFormat());
   controller->RemoveCrtc(drm_, kSecondaryCrtc);
 }
 
 TEST_F(DrmOverlayValidatorTest, OptimizeOnlyIfProcessingCallbackPresent) {
   // This test checks that we dont manipulate overlay buffers in case Processing
   // callback is not present.
@@ skipping 61 matching lines @@
             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 =
+  std::vector<ui::OverlayCheckReturn_Params> returns =
       overlay_validator_->TestPageFlip(overlay_params_, ui::OverlayPlaneList());
-  EXPECT_FALSE(validated_params.front().is_overlay_candidate);
+  EXPECT_EQ(returns.front().status, ui::OverlayCheckReturn_Params::Status::Not);
 }