Ozone overlay candidates

ui/ozone/platform/dri/gbm_surface_factory.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/dri/gbm_surface_factory.h"
 
 #include <gbm.h>
 
+#include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "third_party/khronos/EGL/egl.h"
 #include "ui/ozone/platform/dri/gbm_buffer.h"
 #include "ui/ozone/platform/dri/gbm_surface.h"
 #include "ui/ozone/platform/dri/gbm_surfaceless.h"
 #include "ui/ozone/platform/dri/screen_manager.h"
 #include "ui/ozone/public/native_pixmap.h"
+#include "ui/ozone/public/overlay_candidates_ozone.h"
+#include "ui/ozone/public/ozone_switches.h"
 #include "ui/ozone/public/surface_ozone_egl.h"
 
 namespace ui {
+namespace {
+
+class SingleOverlay : public OverlayCandidatesOzone {
+ public:
+  SingleOverlay() {}
+  virtual ~SingleOverlay() {}
+
+  virtual void CheckOverlaySupport(OverlaySurfaceCandidateList* candidates) {
+    if (candidates->size() == 2) {
+      OverlayCandidatesOzone::OverlaySurfaceCandidate* first =
+          &(*candidates)[0];
+      OverlayCandidatesOzone::OverlaySurfaceCandidate* second =
+          &(*candidates)[1];
+      OverlayCandidatesOzone::OverlaySurfaceCandidate* overlay;
+      if (first->plane_z_order == 0) {
+        overlay = second;
+      } else if (second->plane_z_order == 0) {
+        overlay = first;
+      } else {
+        NOTREACHED();
+        return;
+      }
+      if (overlay->plane_z_order > 0 &&
+          IsTransformSupported(overlay->transform)) {
+        overlay->overlay_handled = true;
+      }
+    }
+  }
+
+ private:
+  bool IsTransformSupported(gfx::OverlayTransform transform) {
+    switch (transform) {
+      case gfx::OVERLAY_TRANSFORM_NONE:
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(SingleOverlay);
+};
+
+}  // namespace
 
 GbmSurfaceFactory::GbmSurfaceFactory(bool allow_surfaceless)
     : DriSurfaceFactory(NULL, NULL),
       device_(NULL),
       allow_surfaceless_(allow_surfaceless) {
 }
 
 GbmSurfaceFactory::~GbmSurfaceFactory() {}
 
 void GbmSurfaceFactory::InitializeGpu(
@@ skipping 89 matching lines @@
     gfx::Size size,
     BufferFormat format) {
   scoped_refptr<GbmBuffer> buffer = GbmBuffer::CreateBuffer(
       drm_, device_, format, size, true);
   if (!buffer)
     return NULL;
 
   return scoped_refptr<GbmPixmap>(new GbmPixmap(buffer));
 }
 
+OverlayCandidatesOzone* GbmSurfaceFactory::GetOverlayCandidates(
+    gfx::AcceleratedWidget w) {
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kOzoneTestSingleOverlaySupport))
+    return new SingleOverlay();
+  return new OverlayCandidatesOzone();

[alexst (slow to review), 2014/08/22 20:41:59]

If we can't support single overlay, we should return NULL because

void OverlayCandidatesOzone::CheckOverlaySupport(
    OverlaySurfaceCandidateList* surfaces) {
  NOTREACHED();
}

Default implementation is only there as a guard against breaking upstream
implementers' build with interface changes.

+}
+
 bool GbmSurfaceFactory::ScheduleOverlayPlane(
     gfx::AcceleratedWidget widget,
     int plane_z_order,
     gfx::OverlayTransform plane_transform,
     scoped_refptr<NativePixmap> buffer,
     const gfx::Rect& display_bounds,
     const gfx::RectF& crop_rect) {
   scoped_refptr<GbmPixmap> pixmap = static_cast<GbmPixmap*>(buffer.get());
   if (!pixmap) {
     LOG(ERROR) << "ScheduleOverlayPlane passed NULL buffer.";
     return false;
   }
   base::WeakPtr<HardwareDisplayController> hdc =
       screen_manager_->GetDisplayController(widget);
   if (!hdc)
     return true;
   hdc->QueueOverlayPlane(OverlayPlane(pixmap->buffer(),
                                       plane_z_order,
                                       plane_transform,
                                       display_bounds,
                                       crop_rect));
   return true;
 }
 
 bool GbmSurfaceFactory::CanShowPrimaryPlaneAsOverlay() {
   return allow_surfaceless_;
 }
 
 }  // namespace ui