[Ozone-DRI] Convert HardwareDisplayController to use scanout buffers

ui/ozone/platform/dri/hardware_display_controller_unittest.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 "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/ozone/platform/dri/dri_buffer.h"
-#include "ui/ozone/platform/dri/dri_surface.h"
 #include "ui/ozone/platform/dri/dri_wrapper.h"
 #include "ui/ozone/platform/dri/hardware_display_controller.h"
 #include "ui/ozone/platform/dri/test/mock_dri_wrapper.h"
 #include "ui/ozone/public/native_pixmap.h"
 
 namespace {
 
 // Create a basic mode for a 6x4 screen.
 const drmModeModeInfo kDefaultMode =
     {0, 6, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, {'\0'}};
 
 const gfx::Size kDefaultModeSize(kDefaultMode.hdisplay, kDefaultMode.vdisplay);
 const gfx::SizeF kDefaultModeSizeF(1.0, 1.0);
 
+class MockScanoutBuffer : public ui::ScanoutBuffer {
+ public:
+  MockScanoutBuffer(const gfx::Size& size) : size_(size) {}
+
+  // ScanoutBuffer:
+  virtual uint32_t GetFramebufferId() const OVERRIDE {return 0; }
+  virtual uint32_t GetHandle() const OVERRIDE { return 0; }
+  virtual gfx::Size GetSize() const OVERRIDE { return size_; }
+
+ private:
+  virtual ~MockScanoutBuffer() {}
+
+  gfx::Size size_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockScanoutBuffer);
+};
+
 }  // namespace
 
 class HardwareDisplayControllerTest : public testing::Test {
  public:
   HardwareDisplayControllerTest() {}
   virtual ~HardwareDisplayControllerTest() {}
 
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
  protected:
   scoped_ptr<ui::HardwareDisplayController> controller_;
   scoped_ptr<ui::MockDriWrapper> drm_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(HardwareDisplayControllerTest);
 };
 
 void HardwareDisplayControllerTest::SetUp() {
   drm_.reset(new ui::MockDriWrapper(3));
   controller_.reset(new ui::HardwareDisplayController(drm_.get(), 1, 1));
 }
 
 void HardwareDisplayControllerTest::TearDown() {
   controller_.reset();
   drm_.reset();
 }
 
-TEST_F(HardwareDisplayControllerTest, CheckStateAfterSurfaceIsBound) {
-  scoped_ptr<ui::ScanoutSurface> surface(
-      new ui::DriSurface(drm_.get(), kDefaultModeSize));
+TEST_F(HardwareDisplayControllerTest, CheckModesettingResult) {
+  ui::OverlayPlane plane(scoped_refptr<ui::ScanoutBuffer>(
+      new MockScanoutBuffer(kDefaultModeSize)));
 
-  EXPECT_TRUE(surface->Initialize());
-  EXPECT_TRUE(controller_->BindSurfaceToController(surface.Pass(),
-                                                   kDefaultMode));
-  EXPECT_TRUE(controller_->surface() != NULL);
+  EXPECT_TRUE(controller_->Modeset(plane, kDefaultMode));
+  EXPECT_FALSE(plane.buffer->HasOneRef());
 }
 
 TEST_F(HardwareDisplayControllerTest, CheckStateAfterPageFlip) {
-  scoped_ptr<ui::ScanoutSurface> surface(
-      new ui::DriSurface(drm_.get(), kDefaultModeSize));
+  ui::OverlayPlane plane1(scoped_refptr<ui::ScanoutBuffer>(
+      new MockScanoutBuffer(kDefaultModeSize)));
 
-  EXPECT_TRUE(surface->Initialize());
-  EXPECT_TRUE(controller_->BindSurfaceToController(surface.Pass(),
-                                                   kDefaultMode));
+  EXPECT_TRUE(controller_->Modeset(plane1, kDefaultMode));
+
+  ui::OverlayPlane plane2(scoped_refptr<ui::ScanoutBuffer>(
+      new MockScanoutBuffer(kDefaultModeSize)));
   EXPECT_TRUE(controller_->SchedulePageFlip(
-      std::vector<ui::OzoneOverlayPlane>(), NULL));
-  EXPECT_TRUE(controller_->surface() != NULL);
+      std::vector<ui::OverlayPlane>(1, plane2)));
+  controller_->WaitForPageFlipEvent();
+  EXPECT_TRUE(plane1.buffer->HasOneRef());
+  EXPECT_FALSE(plane2.buffer->HasOneRef());
+
+  EXPECT_EQ(1, drm_->get_page_flip_call_count());
+  EXPECT_EQ(0, drm_->get_overlay_flip_call_count());
 }
 
 TEST_F(HardwareDisplayControllerTest, CheckStateIfModesetFails) {
   drm_->set_set_crtc_expectation(false);
 
-  scoped_ptr<ui::ScanoutSurface> surface(
-      new ui::DriSurface(drm_.get(), kDefaultModeSize));
+  ui::OverlayPlane plane(scoped_refptr<ui::ScanoutBuffer>(new MockScanoutBuffer(
+      kDefaultModeSize)));
 
-  EXPECT_TRUE(surface->Initialize());
-  EXPECT_FALSE(controller_->BindSurfaceToController(surface.Pass(),
-                                                    kDefaultMode));
-  EXPECT_EQ(NULL, controller_->surface());
+  EXPECT_FALSE(controller_->Modeset(plane, kDefaultMode));
+  EXPECT_TRUE(plane.buffer->HasOneRef());
 }
 
 TEST_F(HardwareDisplayControllerTest, CheckStateIfPageFlipFails) {
   drm_->set_page_flip_expectation(false);
 
-  scoped_ptr<ui::ScanoutSurface> surface(
-      new ui::DriSurface(drm_.get(), kDefaultModeSize));
+  ui::OverlayPlane plane1(scoped_refptr<ui::ScanoutBuffer>(
+      new MockScanoutBuffer(kDefaultModeSize)));
 
-  EXPECT_TRUE(surface->Initialize());
-  EXPECT_TRUE(controller_->BindSurfaceToController(surface.Pass(),
-                                                   kDefaultMode));
+  EXPECT_TRUE(controller_->Modeset(plane1, kDefaultMode));
+
+  ui::OverlayPlane plane2(scoped_refptr<ui::ScanoutBuffer>(
+      new MockScanoutBuffer(kDefaultModeSize)));
   EXPECT_FALSE(controller_->SchedulePageFlip(
-      std::vector<ui::OzoneOverlayPlane>(), NULL));
+      std::vector<ui::OverlayPlane>(1, plane2)));
+  EXPECT_FALSE(plane1.buffer->HasOneRef());
+  EXPECT_TRUE(plane2.buffer->HasOneRef());
 }
 
 TEST_F(HardwareDisplayControllerTest, VerifyNoDRMCallsWhenDisabled) {
-  scoped_ptr<ui::ScanoutSurface> surface(
-      new ui::DriSurface(drm_.get(), kDefaultModeSize));
+  ui::OverlayPlane plane1(scoped_refptr<ui::ScanoutBuffer>(
+      new MockScanoutBuffer(kDefaultModeSize)));
 
-  EXPECT_TRUE(surface->Initialize());
-  EXPECT_TRUE(controller_->BindSurfaceToController(surface.Pass(),
-                                                   kDefaultMode));
+  EXPECT_TRUE(controller_->Modeset(plane1, kDefaultMode));
   controller_->Disable();
+  ui::OverlayPlane plane2(scoped_refptr<ui::ScanoutBuffer>(
+      new MockScanoutBuffer(kDefaultModeSize)));
   EXPECT_TRUE(controller_->SchedulePageFlip(
-      std::vector<ui::OzoneOverlayPlane>(), NULL));
+      std::vector<ui::OverlayPlane>(1, plane2)));
+  controller_->WaitForPageFlipEvent();
   EXPECT_EQ(0, drm_->get_page_flip_call_count());
 
-  surface.reset(new ui::DriSurface(drm_.get(), kDefaultModeSize));
-
-  EXPECT_TRUE(surface->Initialize());
-  EXPECT_TRUE(controller_->BindSurfaceToController(surface.Pass(),
-                                                   kDefaultMode));
+  EXPECT_TRUE(controller_->Modeset(plane1, kDefaultMode));
   EXPECT_TRUE(controller_->SchedulePageFlip(
-      std::vector<ui::OzoneOverlayPlane>(), NULL));
+      std::vector<ui::OverlayPlane>(1, plane2)));
+  controller_->WaitForPageFlipEvent();
   EXPECT_EQ(1, drm_->get_page_flip_call_count());
 }
 
-TEST_F(HardwareDisplayControllerTest, CheckOverlayMainSurfaceReplacement) {
-  scoped_ptr<ui::ScanoutSurface> surface(
-      new ui::DriSurface(drm_.get(), kDefaultModeSize));
-  scoped_ptr<ui::ScanoutSurface> overlay(
-      new ui::DriSurface(drm_.get(), kDefaultModeSize));
+TEST_F(HardwareDisplayControllerTest, CheckOverlayPresent) {
+  ui::OverlayPlane plane1(scoped_refptr<ui::ScanoutBuffer>(
+      new MockScanoutBuffer(kDefaultModeSize)));
+  ui::OverlayPlane plane2(
+      scoped_refptr<ui::ScanoutBuffer>(new MockScanoutBuffer(kDefaultModeSize)),
+      1,
+      gfx::OVERLAY_TRANSFORM_NONE,
+      gfx::Rect(kDefaultModeSize),
+      gfx::RectF(kDefaultModeSizeF));
+  plane2.overlay_plane = 1;  // Force association with a plane.
 
-  EXPECT_TRUE(surface->Initialize());
-  EXPECT_TRUE(
-      controller_->BindSurfaceToController(surface.Pass(), kDefaultMode));
-  EXPECT_TRUE(overlay->Initialize());
+  EXPECT_TRUE(controller_->Modeset(plane1, kDefaultMode));
 
-  std::vector<ui::OzoneOverlayPlane> overlays;
-  std::vector<scoped_refptr<ui::NativePixmap> > overlay_refs;
+  std::vector<ui::OverlayPlane> overlays;
+  overlays.push_back(plane1);
+  overlays.push_back(plane2);
 
-  overlays.push_back(ui::OzoneOverlayPlane(overlay.get(),
-                                           0,
-                                           gfx::OVERLAY_TRANSFORM_NONE,
-                                           gfx::Rect(kDefaultModeSize),
-                                           gfx::RectF(kDefaultModeSizeF)));
-
-  EXPECT_TRUE(controller_->SchedulePageFlip(overlays, &overlay_refs));
-  EXPECT_EQ(1, drm_->get_page_flip_call_count());
-  EXPECT_EQ(0, drm_->get_overlay_flip_call_count());
-}
-
-TEST_F(HardwareDisplayControllerTest, CheckOverlayPresent) {
-  scoped_ptr<ui::ScanoutSurface> surface(
-      new ui::DriSurface(drm_.get(), kDefaultModeSize));
-  scoped_ptr<ui::ScanoutSurface> overlay(
-      new ui::DriSurface(drm_.get(), kDefaultModeSize));
-
-  EXPECT_TRUE(surface->Initialize());
-  EXPECT_TRUE(
-      controller_->BindSurfaceToController(surface.Pass(), kDefaultMode));
-  EXPECT_TRUE(overlay->Initialize());
-
-  std::vector<ui::OzoneOverlayPlane> overlays;
-  std::vector<scoped_refptr<ui::NativePixmap> > overlay_refs;
-
-  overlays.push_back(ui::OzoneOverlayPlane(overlay.get(),
-                                           1,
-                                           gfx::OVERLAY_TRANSFORM_NONE,
-                                           gfx::Rect(kDefaultModeSize),
-                                           gfx::RectF(kDefaultModeSizeF)));
-  overlays.back().overlay_plane = 1;  // Force association with a plane.
-
-  EXPECT_TRUE(controller_->SchedulePageFlip(overlays, &overlay_refs));
+  EXPECT_TRUE(controller_->SchedulePageFlip(overlays));
+  controller_->WaitForPageFlipEvent();
   EXPECT_EQ(1, drm_->get_page_flip_call_count());
   EXPECT_EQ(1, drm_->get_overlay_flip_call_count());
 }