ozone: introduce OverlayCheckReturn_Params

ui/ozone/platform/drm/gpu/drm_overlay_validator.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 "ui/gfx/geometry/size_conversions.h"
 #include "ui/ozone/platform/drm/common/drm_util.h"
@@ skipping 86 matching lines @@
 
 DrmOverlayValidator::DrmOverlayValidator(
     DrmWindow* window,
     ScanoutBufferGenerator* buffer_generator)
     : window_(window),
       buffer_generator_(buffer_generator),
       overlay_hints_cache_(kMaxCacheSize) {}
 
 DrmOverlayValidator::~DrmOverlayValidator() {}
 
-std::vector<OverlayCheck_Params> DrmOverlayValidator::TestPageFlip(
+std::vector<OverlayCheckReturn_Params> DrmOverlayValidator::TestPageFlip(
     const std::vector<OverlayCheck_Params>& params,
     const OverlayPlaneList& last_used_planes) {
-  std::vector<OverlayCheck_Params> validated_params = params;
+  std::vector<OverlayCheckReturn_Params> returns(params.size());
   HardwareDisplayController* controller = window_->GetController();
   if (!controller) {
-    // Nothing much we can do here.
-    for (auto& overlay : validated_params)
-      overlay.is_overlay_candidate = false;
+    // The controller is not yet installed.
+    for (auto& param : returns)
+      param.status = OverlayCheckReturn_Params::Status::NOT;
 
-    return validated_params;
+    return returns;
   }
 
   OverlayPlaneList test_list;
   std::vector<scoped_refptr<ScanoutBuffer>> reusable_buffers;
   scoped_refptr<DrmDevice> drm = controller->GetAllocationDrmDevice();
 
   for (const auto& plane : last_used_planes)
     reusable_buffers.push_back(plane.buffer);
 
-  for (auto& overlay : validated_params) {
-    if (!overlay.is_overlay_candidate)
+  for (size_t i = 0; i < params.size(); ++i) {
+    if (!params[i].is_overlay_candidate) {
+      returns[i].status = OverlayCheckReturn_Params::Status::NOT;
       continue;
+    }
 
     gfx::Size scaled_buffer_size = GetScaledSize(
-        overlay.buffer_size, overlay.display_rect, overlay.crop_rect);
+        params[i].buffer_size, params[i].display_rect, params[i].crop_rect);
 
     uint32_t original_format =
-        overlay.plane_z_order
-            ? GetFourCCFormatFromBufferFormat(overlay.format)
-            : GetFourCCFormatForOpaqueFramebuffer(overlay.format);
+        params[i].plane_z_order
+            ? GetFourCCFormatFromBufferFormat(params[i].format)
+            : GetFourCCFormatForOpaqueFramebuffer(params[i].format);
     scoped_refptr<ScanoutBuffer> buffer =
-        GetBufferForPageFlipTest(drm, overlay.buffer_size, original_format,
+        GetBufferForPageFlipTest(drm, params[i].buffer_size, original_format,
                                  buffer_generator_, &reusable_buffers);
 
-    OverlayPlane plane(buffer, overlay.plane_z_order, overlay.transform,
-                       overlay.display_rect, overlay.crop_rect);
+    OverlayPlane plane(buffer, params[i].plane_z_order, params[i].transform,
+                       params[i].display_rect, params[i].crop_rect);
     test_list.push_back(plane);
 
     if (buffer && controller->TestPageFlip(test_list)) {
-      overlay.is_overlay_candidate = true;
+      returns[i].status = OverlayCheckReturn_Params::Status::ABLE;
 
       // If size scaling is needed, find an optimal format.
-      if (overlay.plane_z_order && scaled_buffer_size != overlay.buffer_size) {
+      if (params[i].plane_z_order &&
+          scaled_buffer_size != params[i].buffer_size) {
         uint32_t optimal_format = FindOptimalBufferFormat(
-            original_format, overlay.plane_z_order, overlay.display_rect,
+            original_format, params[i].plane_z_order, params[i].display_rect,
             window_->bounds(), controller);
 
         if (original_format != optimal_format) {
           OverlayPlane original_plain = test_list.back();
           test_list.pop_back();
           scoped_refptr<ScanoutBuffer> optimal_buffer =
               GetBufferForPageFlipTest(drm, scaled_buffer_size, optimal_format,
                                        buffer_generator_, &reusable_buffers);
           DCHECK(optimal_buffer);
 
-          OverlayPlane optimal_plane(optimal_buffer, overlay.plane_z_order,
-                                     overlay.transform, overlay.display_rect,
-                                     overlay.crop_rect);
+          OverlayPlane optimal_plane(
+              optimal_buffer, params[i].plane_z_order, params[i].transform,
+              params[i].display_rect, params[i].crop_rect);
           test_list.push_back(optimal_plane);
 
           // If test failed here, it means even though optimal_format is
           // supported, platform cannot support it with current combination of
           // layers. This is usually the case when optimal_format needs certain
           // capabilites (i.e. conversion, scaling etc) and needed hardware
           // resources might be already in use. Fall back to original format.
           if (!controller->TestPageFlip(test_list)) {
             test_list.pop_back();
             test_list.push_back(original_plain);
           }
         }
       }
     } else {
       // If test failed here, platform cannot support this configuration
       // with current combination of layers. This is usually the case when this
       // plane has requested post processing capability which needs additional
       // hardware resources and they might be already in use by other planes.
       // For example this plane has requested scaling capabilities and all
       // available scalars are already in use by other planes.
-      overlay.is_overlay_candidate = false;
+      returns[i].status = OverlayCheckReturn_Params::Status::NOT;
       test_list.pop_back();
     }
   }
 
   UpdateOverlayHintsCache(test_list);
 
-  return validated_params;
+  return returns;
 }
 
 OverlayPlaneList DrmOverlayValidator::PrepareBuffersForPageFlip(
     const OverlayPlaneList& planes) {
   if (planes.size() <= 1)
     return planes;
 
   HardwareDisplayController* controller = window_->GetController();
   if (!controller)
     return planes;
@@ skipping 60 matching lines @@
 
     // Make sure we dont hold reference to buffer when caching this plane list.
     plane.buffer = nullptr;
   }
 
   DCHECK(hints_plane_list.size() == overlay_hints.size());
   overlay_hints_cache_.Put(hints_plane_list, overlay_hints);
 }
 
 }  // namespace ui