src/ui/ozone/platform/dri/hardware_display_controller_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "testing/gtest/include/gtest/gtest.h"
   6 #include "third_party/skia/include/core/SkCanvas.h"
   7 #include "ui/ozone/platform/dri/crtc_state.h"
   8 #include "ui/ozone/platform/dri/dri_buffer.h"
   9 #include "ui/ozone/platform/dri/dri_wrapper.h"
  10 #include "ui/ozone/platform/dri/hardware_display_controller.h"
  11 #include "ui/ozone/platform/dri/test/mock_dri_wrapper.h"
  12 #include "ui/ozone/public/native_pixmap.h"
  13
  14 namespace {
  15
  16 // Create a basic mode for a 6x4 screen.
  17 const drmModeModeInfo kDefaultMode =
  18     {0, 6, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, {'\0'}};
  19
  20 const uint32_t kPrimaryCrtc = 1;
  21 const uint32_t kPrimaryConnector = 2;
  22 const uint32_t kSecondaryCrtc = 3;
  23 const uint32_t kSecondaryConnector = 4;
  24
  25 const gfx::Size kDefaultModeSize(kDefaultMode.hdisplay, kDefaultMode.vdisplay);
  26 const gfx::SizeF kDefaultModeSizeF(1.0, 1.0);
  27
  28 class MockScanoutBuffer : public ui::ScanoutBuffer {
  29  public:
  30   MockScanoutBuffer(const gfx::Size& size) : size_(size) {}
  31
  32   // ScanoutBuffer:
  33   virtual uint32_t GetFramebufferId() const OVERRIDE {return 0; }
  34   virtual uint32_t GetHandle() const OVERRIDE { return 0; }
  35   virtual gfx::Size GetSize() const OVERRIDE { return size_; }
  36
  37  private:
  38   virtual ~MockScanoutBuffer() {}
  39
  40   gfx::Size size_;
  41
  42   DISALLOW_COPY_AND_ASSIGN(MockScanoutBuffer);
  43 };
  44
  45 }  // namespace
  46
  47 class HardwareDisplayControllerTest : public testing::Test {
  48  public:
  49   HardwareDisplayControllerTest() {}
  50   virtual ~HardwareDisplayControllerTest() {}
  51
  52   virtual void SetUp() OVERRIDE;
  53   virtual void TearDown() OVERRIDE;
  54  protected:
  55   scoped_ptr<ui::HardwareDisplayController> controller_;
  56   scoped_ptr<ui::MockDriWrapper> drm_;
  57
  58  private:
  59   DISALLOW_COPY_AND_ASSIGN(HardwareDisplayControllerTest);
  60 };
  61
  62 void HardwareDisplayControllerTest::SetUp() {
  63   drm_.reset(new ui::MockDriWrapper(3));
  64   controller_.reset(new ui::HardwareDisplayController(
  65       drm_.get(),
  66       scoped_ptr<ui::CrtcState>(
  67           new ui::CrtcState(drm_.get(), kPrimaryCrtc, kPrimaryConnector))));
  68 }
  69
  70 void HardwareDisplayControllerTest::TearDown() {
  71   controller_.reset();
  72   drm_.reset();
  73 }
  74
  75 TEST_F(HardwareDisplayControllerTest, CheckModesettingResult) {
  76   ui::OverlayPlane plane(scoped_refptr<ui::ScanoutBuffer>(
  77       new MockScanoutBuffer(kDefaultModeSize)));
  78
  79   EXPECT_TRUE(controller_->Modeset(plane, kDefaultMode));
  80   EXPECT_FALSE(plane.buffer->HasOneRef());
  81 }
  82
  83 TEST_F(HardwareDisplayControllerTest, CheckStateAfterPageFlip) {
  84   ui::OverlayPlane plane1(scoped_refptr<ui::ScanoutBuffer>(
  85       new MockScanoutBuffer(kDefaultModeSize)));
  86
  87   EXPECT_TRUE(controller_->Modeset(plane1, kDefaultMode));
  88
  89   ui::OverlayPlane plane2(scoped_refptr<ui::ScanoutBuffer>(
  90       new MockScanoutBuffer(kDefaultModeSize)));
  91   controller_->QueueOverlayPlane(plane2);
  92   EXPECT_TRUE(controller_->SchedulePageFlip());
  93   controller_->WaitForPageFlipEvent();
  94   EXPECT_TRUE(plane1.buffer->HasOneRef());
  95   EXPECT_FALSE(plane2.buffer->HasOneRef());
  96
  97   EXPECT_EQ(1, drm_->get_page_flip_call_count());
  98   EXPECT_EQ(0, drm_->get_overlay_flip_call_count());
  99 }
 100
 101 TEST_F(HardwareDisplayControllerTest, CheckStateIfModesetFails) {
 102   drm_->set_set_crtc_expectation(false);
 103
 104   ui::OverlayPlane plane(scoped_refptr<ui::ScanoutBuffer>(new MockScanoutBuffer(
 105       kDefaultModeSize)));
 106
 107   EXPECT_FALSE(controller_->Modeset(plane, kDefaultMode));
 108 }
 109
 110 TEST_F(HardwareDisplayControllerTest, CheckStateIfPageFlipFails) {
 111   drm_->set_page_flip_expectation(false);
 112
 113   ui::OverlayPlane plane1(scoped_refptr<ui::ScanoutBuffer>(
 114       new MockScanoutBuffer(kDefaultModeSize)));
 115
 116   EXPECT_TRUE(controller_->Modeset(plane1, kDefaultMode));
 117
 118   ui::OverlayPlane plane2(scoped_refptr<ui::ScanoutBuffer>(
 119       new MockScanoutBuffer(kDefaultModeSize)));
 120   controller_->QueueOverlayPlane(plane2);
 121   EXPECT_FALSE(controller_->SchedulePageFlip());
 122   EXPECT_FALSE(plane1.buffer->HasOneRef());
 123   EXPECT_FALSE(plane2.buffer->HasOneRef());
 124
 125   controller_->WaitForPageFlipEvent();
 126   EXPECT_FALSE(plane1.buffer->HasOneRef());
 127   EXPECT_TRUE(plane2.buffer->HasOneRef());
 128 }
 129
 130 TEST_F(HardwareDisplayControllerTest, VerifyNoDRMCallsWhenDisabled) {
 131   ui::OverlayPlane plane1(scoped_refptr<ui::ScanoutBuffer>(
 132       new MockScanoutBuffer(kDefaultModeSize)));
 133
 134   EXPECT_TRUE(controller_->Modeset(plane1, kDefaultMode));
 135   controller_->Disable();
 136   ui::OverlayPlane plane2(scoped_refptr<ui::ScanoutBuffer>(
 137       new MockScanoutBuffer(kDefaultModeSize)));
 138   controller_->QueueOverlayPlane(plane2);
 139   EXPECT_TRUE(controller_->SchedulePageFlip());
 140   controller_->WaitForPageFlipEvent();
 141   EXPECT_EQ(0, drm_->get_page_flip_call_count());
 142
 143   EXPECT_TRUE(controller_->Modeset(plane1, kDefaultMode));
 144   controller_->QueueOverlayPlane(plane2);
 145   EXPECT_TRUE(controller_->SchedulePageFlip());
 146   controller_->WaitForPageFlipEvent();
 147   EXPECT_EQ(1, drm_->get_page_flip_call_count());
 148 }
 149
 150 TEST_F(HardwareDisplayControllerTest, CheckOverlayPresent) {
 151   ui::OverlayPlane plane1(scoped_refptr<ui::ScanoutBuffer>(
 152       new MockScanoutBuffer(kDefaultModeSize)));
 153   ui::OverlayPlane plane2(
 154       scoped_refptr<ui::ScanoutBuffer>(new MockScanoutBuffer(kDefaultModeSize)),
 155       1,
 156       gfx::OVERLAY_TRANSFORM_NONE,
 157       gfx::Rect(kDefaultModeSize),
 158       gfx::RectF(kDefaultModeSizeF));
 159   plane2.overlay_plane = 1;  // Force association with a plane.
 160
 161   EXPECT_TRUE(controller_->Modeset(plane1, kDefaultMode));
 162
 163   controller_->QueueOverlayPlane(plane1);
 164   controller_->QueueOverlayPlane(plane2);
 165
 166   EXPECT_TRUE(controller_->SchedulePageFlip());
 167   controller_->WaitForPageFlipEvent();
 168   EXPECT_EQ(1, drm_->get_page_flip_call_count());
 169   EXPECT_EQ(1, drm_->get_overlay_flip_call_count());
 170 }
 171
 172 TEST_F(HardwareDisplayControllerTest, PageflipMirroredControllers) {
 173   controller_->AddCrtc(
 174       scoped_ptr<ui::CrtcState>(
 175           new ui::CrtcState(drm_.get(), kSecondaryCrtc, kSecondaryConnector)));
 176
 177   ui::OverlayPlane plane1(scoped_refptr<ui::ScanoutBuffer>(
 178       new MockScanoutBuffer(kDefaultModeSize)));
 179   EXPECT_TRUE(controller_->Modeset(plane1, kDefaultMode));
 180   EXPECT_EQ(2, drm_->get_set_crtc_call_count());
 181
 182   ui::OverlayPlane plane2(scoped_refptr<ui::ScanoutBuffer>(
 183       new MockScanoutBuffer(kDefaultModeSize)));
 184   controller_->QueueOverlayPlane(plane2);
 185   EXPECT_TRUE(controller_->SchedulePageFlip());
 186   EXPECT_EQ(2, drm_->get_page_flip_call_count());
 187 }