Ozone: Dont hardcode format to YUV when using Overlay Composition.

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 <drm_fourcc.h>
 
 #include <utility>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 33 matching lines @@
   DrmOverlayValidatorTest() {}
 
   void SetUp() override;
   void TearDown() override;
 
   void OnSwapBuffers(gfx::SwapResult result) {
     on_swap_buffers_count_++;
     last_swap_buffers_result_ = result;
   }
 
+  bool CopyBuffer(const scoped_refptr<ui::ScanoutBuffer>& source_buffer,
+                  scoped_refptr<ui::ScanoutBuffer>& target_buffer) {
+    return true;
+  }
+
  protected:
   scoped_ptr<base::MessageLoop> message_loop_;
   scoped_refptr<ui::MockDrmDevice> drm_;
   scoped_ptr<ui::MockScanoutBufferGenerator> buffer_generator_;
   scoped_ptr<ui::ScreenManager> screen_manager_;
   scoped_ptr<ui::DrmDeviceManager> drm_device_manager_;
   ui::MockHardwareDisplayPlaneManager* plane_manager_;
   ui::DrmWindow* window_;
   scoped_ptr<ui::DrmOverlayValidator> overlay_validator_;
   std::vector<ui::OverlayCheck_Params> overlay_params_;
   ui::OverlayPlaneList plane_list_;
+  ui::OverlayPlane::CopyBufferCallback copy_buffer_handler_;
 
   int on_swap_buffers_count_;
   gfx::SwapResult last_swap_buffers_result_;
   gfx::Rect overlay_rect_;
   gfx::Rect primary_rect_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DrmOverlayValidatorTest);
 };
 
 void DrmOverlayValidatorTest::SetUp() {
   on_swap_buffers_count_ = 0;
   last_swap_buffers_result_ = gfx::SwapResult::SWAP_FAILED;
+  copy_buffer_handler_ =
+      base::Bind(&DrmOverlayValidatorTest::CopyBuffer, base::Unretained(this));
 
   message_loop_.reset(new base::MessageLoopForUI);
   std::vector<uint32_t> crtcs;
   crtcs.push_back(kDefaultCrtc);
   drm_ = new ui::MockDrmDevice(false, crtcs, kPlanesPerCrtc);
   buffer_generator_.reset(new ui::MockScanoutBufferGenerator());
   screen_manager_.reset(new ui::ScreenManager(buffer_generator_.get()));
   screen_manager_->AddDisplayController(drm_, kDefaultCrtc, kDefaultConnector);
   screen_manager_->ConfigureDisplayController(
       drm_, kDefaultCrtc, kDefaultConnector, gfx::Point(), kDefaultMode);
@@ skipping 20 matching lines @@
   primary_candidate.buffer_size = primary_rect_.size();
   primary_candidate.display_rect = primary_rect_;
   overlay_params_.push_back(primary_candidate);
 
   ui::OverlayCheck_Params overlay_candidate;
   overlay_candidate.buffer_size = overlay_rect_.size();
   overlay_candidate.display_rect = overlay_rect_;
   overlay_candidate.plane_z_order = 1;
   overlay_params_.push_back(overlay_candidate);
 
+  scoped_refptr<ui::DrmDevice> drm =
+      window_->GetController()->GetAllocationDrmDevice();
   for (const auto& param : overlay_params_) {
-    ui::OverlayPlane plane(nullptr, param.plane_z_order, param.transform,
-                           param.display_rect, param.crop_rect);
+    scoped_refptr<ui::ScanoutBuffer> scanout_buffer =
+        buffer_generator_->Create(drm, param.format, param.buffer_size);
+    ui::OverlayPlane plane(std::move(scanout_buffer), param.plane_z_order,
+                           param.transform, param.display_rect, param.crop_rect,
+                           copy_buffer_handler_);
     plane_list_.push_back(plane);
   }
 }
 
 void DrmOverlayValidatorTest::TearDown() {
   scoped_ptr<ui::DrmWindow> window =
       screen_manager_->RemoveWindow(kDefaultWidgetHandle);
   window->Shutdown();
   message_loop_.reset();
 }
@@ skipping 45 matching lines @@
   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(),
                                    buffer_generator_.get());
 
-  uint32_t optimal_format = overlay_validator_->GetOptimalBufferFormat(
-      plane_list_.back(), plane_list_);
-  EXPECT_EQ(DRM_FORMAT_UYVY, optimal_format);
+  ui::OverlayPlaneList plane_list =
+      overlay_validator_->ValidatePlanesForPageFlip(plane_list_,
+                                                    buffer_generator_.get());
+  EXPECT_EQ(DRM_FORMAT_UYVY,
+            plane_list.back().buffer->GetFramebufferPixelFormat());
   // Check if ClearCache actually clears the cache.
   overlay_validator_->ClearCache();
-  optimal_format = overlay_validator_->GetOptimalBufferFormat(
-      plane_list_.back(), plane_list_);
+  plane_list = overlay_validator_->ValidatePlanesForPageFlip(
+      plane_list_, buffer_generator_.get());
   // There should be no entry in cache for this configuration and should return
   // default value of DRM_FORMAT_XRGB8888.
-  EXPECT_EQ(DRM_FORMAT_XRGB8888, optimal_format);
+  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};
   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(),
                                    buffer_generator_.get());
-  uint32_t optimal_format = overlay_validator_->GetOptimalBufferFormat(
-      plane_list_.back(), plane_list_);
-  EXPECT_EQ(DRM_FORMAT_XRGB8888, optimal_format);
+  ui::OverlayPlaneList plane_list =
+      overlay_validator_->ValidatePlanesForPageFlip(plane_list_,
+                                                    buffer_generator_.get());
+  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};
 
   // 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(),
                                    buffer_generator_.get());
-  uint32_t optimal_format = overlay_validator_->GetOptimalBufferFormat(
-      plane_list_.back(), plane_list_);
+  ui::OverlayPlaneList plane_list =
+      overlay_validator_->ValidatePlanesForPageFlip(plane_list_,
+                                                    buffer_generator_.get());
 #if defined(USE_DRM_ATOMIC)
-  EXPECT_EQ(DRM_FORMAT_UYVY, optimal_format);
+  EXPECT_EQ(DRM_FORMAT_UYVY,
+            plane_list.back().buffer->GetFramebufferPixelFormat());
 #else
   // If Atomic support is disabled, ensure we choose DRM_FORMAT_XRGB8888 as the
   // optimal format even if other packed formats are supported by Primary.
-  EXPECT_EQ(DRM_FORMAT_XRGB8888, optimal_format);
+  EXPECT_EQ(DRM_FORMAT_XRGB8888,
+            plane_list.back().buffer->GetFramebufferPixelFormat());
 #endif
 }
 
 TEST_F(DrmOverlayValidatorTest, OverlayPreferredFormat_YUV) {
   plane_manager_->ResetPlaneCount();
   // This test checks for optimal format in case of non full screen video case.
   // Prefer YUV as optimal format when Overlay supports 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, 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(),
                                        buffer_generator_.get());
 
   for (const auto& param : validated_params)
     EXPECT_EQ(true, param.is_overlay_candidate);
 
   EXPECT_EQ(5, plane_manager_->plane_count());
 
-  uint32_t optimal_format = overlay_validator_->GetOptimalBufferFormat(
-      plane_list_.back(), plane_list_);
-  EXPECT_EQ(DRM_FORMAT_UYVY, optimal_format);
+  ui::OverlayPlaneList plane_list =
+      overlay_validator_->ValidatePlanesForPageFlip(plane_list_,
+                                                    buffer_generator_.get());
+  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 =
       overlay_validator_->TestPageFlip(overlay_params_, ui::OverlayPlaneList(),
                                        buffer_generator_.get());
-  uint32_t optimal_format = overlay_validator_->GetOptimalBufferFormat(
-      plane_list_.back(), plane_list_);
-
-  EXPECT_EQ(DRM_FORMAT_XRGB8888, optimal_format);
+  ui::OverlayPlaneList plane_list =
+      overlay_validator_->ValidatePlanesForPageFlip(plane_list_,
+                                                    buffer_generator_.get());
+  EXPECT_EQ(DRM_FORMAT_XRGB8888,
+            plane_list.back().buffer->GetFramebufferPixelFormat());
   EXPECT_EQ(3, plane_manager_->plane_count());
   for (const auto& param : validated_params)
     EXPECT_EQ(true, param.is_overlay_candidate);
 }
 
 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();
@@ skipping 52 matching lines @@
   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(), buffer_generator_.get());
 
   EXPECT_EQ(true, validated_params.back().is_overlay_candidate);
 
   // Both controllers have Overlay which support DRM_FORMAT_UYVY, hence this
   // should be picked as the optimal format.
-  uint32_t optimal_format = overlay_validator_->GetOptimalBufferFormat(
-      plane_list_.back(), plane_list_);
-  EXPECT_EQ(DRM_FORMAT_UYVY, optimal_format);
+  ui::OverlayPlaneList plane_list =
+      overlay_validator_->ValidatePlanesForPageFlip(plane_list_,
+                                                    buffer_generator_.get());
+  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(
@@ skipping 45 matching lines @@
   overlay_validator_->ClearCache();
 
   plane_manager_->ResetPlaneCount();
   std::vector<ui::OverlayCheck_Params> validated_params =
       overlay_validator_->TestPageFlip(overlay_params_, ui::OverlayPlaneList(),
                                        buffer_generator_.get());
 
   EXPECT_EQ(true, validated_params.back().is_overlay_candidate);
   // Both controllers have Overlay which support DRM_FORMAT_UYVY, hence this
   // should be picked as the optimal format.
-  uint32_t optimal_format = overlay_validator_->GetOptimalBufferFormat(
-      plane_list_.back(), plane_list_);
-  EXPECT_EQ(DRM_FORMAT_UYVY, optimal_format);
+  ui::OverlayPlaneList plane_list =
+      overlay_validator_->ValidatePlanesForPageFlip(plane_list_,
+                                                    buffer_generator_.get());
+  EXPECT_EQ(DRM_FORMAT_UYVY,
+            plane_list.back().buffer->GetFramebufferPixelFormat());
 
   // DRM_FORMAT_XRGB8888 should be the preferred format 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(
       overlay_params_, ui::OverlayPlaneList(), buffer_generator_.get());
   EXPECT_EQ(true, validated_params.back().is_overlay_candidate);
 
-  optimal_format = overlay_validator_->GetOptimalBufferFormat(
-      plane_list_.back(), plane_list_);
-  EXPECT_EQ(DRM_FORMAT_XRGB8888, optimal_format);
+  plane_list = overlay_validator_->ValidatePlanesForPageFlip(
+      plane_list_, buffer_generator_.get());
+  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 = overlay_validator_->TestPageFlip(
       overlay_params_, ui::OverlayPlaneList(), buffer_generator_.get());
   EXPECT_EQ(true, validated_params.back().is_overlay_candidate);
 
-  optimal_format = overlay_validator_->GetOptimalBufferFormat(
-      plane_list_.back(), plane_list_);
-  EXPECT_EQ(DRM_FORMAT_XRGB8888, optimal_format);
+  plane_list = overlay_validator_->ValidatePlanesForPageFlip(
+      plane_list_, buffer_generator_.get());
+  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.
+  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, 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(),
+                                   buffer_generator_.get());
+
+  ui::OverlayPlaneList plane_list =
+      overlay_validator_->ValidatePlanesForPageFlip(plane_list_,
+                                                    buffer_generator_.get());
+  EXPECT_EQ(DRM_FORMAT_UYVY,
+            plane_list.back().buffer->GetFramebufferPixelFormat());
+  plane_list_.back().processing_callback.Reset();
+  plane_list = overlay_validator_->ValidatePlanesForPageFlip(
+      plane_list_, buffer_generator_.get());
+  EXPECT_EQ(plane_list_.back().buffer->GetFramebufferPixelFormat(),
+            plane_list.back().buffer->GetFramebufferPixelFormat());
+  plane_list_.back().processing_callback = copy_buffer_handler_;
+}