ozone: Add overlay candidate implementation that queries support via IPC

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

 // Copyright 2014 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_window.h"
 
 #include "base/trace_event/trace_event.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkDevice.h"
 #include "third_party/skia/include/core/SkSurface.h"
+#include "ui/ozone/common/gpu/ozone_gpu_message_params.h"
 #include "ui/ozone/platform/drm/gpu/drm_buffer.h"
 #include "ui/ozone/platform/drm/gpu/drm_device.h"
 #include "ui/ozone/platform/drm/gpu/drm_device_manager.h"
+#include "ui/ozone/platform/drm/gpu/scanout_buffer.h"
 #include "ui/ozone/platform/drm/gpu/screen_manager.h"
 
 namespace ui {
 
 namespace {
 
 #ifndef DRM_CAP_CURSOR_WIDTH
 #define DRM_CAP_CURSOR_WIDTH 0x8
 #endif
 
 #ifndef DRM_CAP_CURSOR_HEIGHT
 #define DRM_CAP_CURSOR_HEIGHT 0x9
 #endif
 
+void EmptyFlipCallback(gfx::SwapResult) {
+}
+
 void UpdateCursorImage(DrmBuffer* cursor, const SkBitmap& image) {
   SkRect damage;
   image.getBounds(&damage);
 
   // Clear to transparent in case |image| is smaller than the canvas.
   SkCanvas* canvas = cursor->GetCanvas();
   canvas->clear(SK_ColorTRANSPARENT);
 
   SkRect clip;
   clip.set(0, 0, canvas->getDeviceSize().width(),
@@ skipping 94 matching lines @@
 
   if (controller_) {
     return controller_->SchedulePageFlip(last_submitted_planes_, is_sync, false,
                                          callback);
   }
 
   callback.Run(gfx::SwapResult::SWAP_ACK);
   return true;
 }
 
+bool DrmWindow::TestPageFlip(const std::vector<OverlayCheck_Params>& overlays,
+                             ScanoutBufferGenerator* buffer_generator) {
+  if (!controller_)
+    return true;
+  for (const auto& overlay : overlays) {
+    // It is possible that the cc rect we get actually falls off the edge of
+    // the screen. Usually this is prevented via things like status bars
+    // blocking overlaying or cc clipping it, but in case it wasn't properly
+    // clipped (since GL will render this situation fine) just ignore it here.
+    // This should be an extremely rare occurrance.
+    if (overlay.plane_z_order != 0 && !bounds().Contains(overlay.display_rect))
+      return false;
+  }
+
+  scoped_refptr<DrmDevice> drm = controller_->GetAllocationDrmDevice();
+  OverlayPlaneList planes;
+  for (const auto& overlay : overlays) {
+    gfx::Size size =
+        (overlay.plane_z_order == 0) ? bounds().size() : overlay.buffer_size;
+    scoped_refptr<ScanoutBuffer> buffer = buffer_generator->Create(drm, size);
+    if (!buffer)
+      return false;
+    planes.push_back(OverlayPlane(buffer, overlay.plane_z_order,
+                                  overlay.transform, overlay.display_rect,
+                                  gfx::RectF(gfx::Size(1, 1))));
+  }
+  return controller_->SchedulePageFlip(planes, true, true,
+                                       base::Bind(&EmptyFlipCallback));
+}
+
 const OverlayPlane* DrmWindow::GetLastModesetBuffer() {
   return OverlayPlane::GetPrimaryPlane(last_submitted_planes_);
 }
 
 void DrmWindow::ResetCursor(bool bitmap_only) {
   if (!controller_)
     return;
 
   if (cursor_bitmaps_.size()) {
     // Draw new cursor into backbuffer.
@@ skipping 53 matching lines @@
       if (!cursor_buffers_[i]->Initialize(
               info, false /* should_register_framebuffer */)) {
         LOG(FATAL) << "Failed to initialize cursor buffer";
         return;
       }
     }
   }
 }
 
 }  // namespace ui