[Ozone-DRI] Convert HardwareDisplayController to use scanout buffers

This change allows scanout buffers to be kept alive until the last of
SurfaceOzone{Canvas,EGL} and HardwareDisplayController are destroyed. For
HardwareDisplayController this means that buffers will be kept around
until the CRTC is properly restored. For SurfaceOzoneEGL this means that
on monitor disconnects (HDC is destroyed) the buffers are kept alive for
any remaining EGL operations still happening.

BUG=none
NOTRY=true

Review URL: https://codereview.chromium.org/393233005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@284708 0039d316-1c4b-4281-b951-d872f2087c98

ui/ozone/platform/dri/dri.gypi

@@ -101,8 +101,6 @@
           'screen_manager_unittest.cc',
           'test/mock_dri_wrapper.cc',
           'test/mock_dri_wrapper.h',
-          'test/mock_surface_generator.cc',
-          'test/mock_surface_generator.h',
         ],
       },
     },

ui/ozone/platform/dri/dri_surface.cc

@@ -60,7 +60,6 @@ void DriSurface::PreSwapBuffers() {
 // This call is made after the hardware just started displaying our back buffer.
 // We need to update our pointer reference and synchronize the two buffers.
 void DriSurface::SwapBuffers() {
-  CHECK(frontbuffer());
   CHECK(backbuffer());
 
   // Update our front buffer pointer.

ui/ozone/platform/dri/dri_surface.h

@@ -27,6 +27,9 @@ class DriSurface : public ScanoutSurface {
 
   // Get a Skia canvas for a backbuffer.
   SkCanvas* GetDrawableForWidget();
+  scoped_refptr<DriBuffer> backbuffer() const {
+    return bitmaps_[front_buffer_ ^ 1];
+  }
 
   // ScanoutSurface:
   virtual bool Initialize() OVERRIDE;
@@ -37,9 +40,6 @@ class DriSurface : public ScanoutSurface {
   virtual gfx::Size Size() const OVERRIDE;
 
  private:
-  DriBuffer* frontbuffer() const { return bitmaps_[front_buffer_].get(); }
-  DriBuffer* backbuffer() const { return bitmaps_[front_buffer_ ^ 1].get(); }
-
   // Stores the connection to the graphics card. Pointer not owned by this
   // class.
   DriWrapper* dri_;

ui/ozone/platform/dri/dri_surface_factory.cc

@@ -45,7 +45,8 @@ void UpdateCursorImage(DriBuffer* cursor, const SkBitmap& image) {
 
 class DriSurfaceAdapter : public ui::SurfaceOzoneCanvas {
  public:
-  DriSurfaceAdapter(const base::WeakPtr<HardwareDisplayController>& controller);
+  DriSurfaceAdapter(DriWrapper* dri,
+                    const base::WeakPtr<HardwareDisplayController>& controller);
   virtual ~DriSurfaceAdapter();
 
   // SurfaceOzoneCanvas:
@@ -57,6 +58,8 @@ class DriSurfaceAdapter : public ui::SurfaceOzoneCanvas {
  private:
   void UpdateNativeSurface(const gfx::Rect& damage);
 
+  DriWrapper* dri_;
+  scoped_ptr<DriSurface> native_surface_;
   skia::RefPtr<SkSurface> surface_;
   gfx::Rect last_damage_;
   base::WeakPtr<HardwareDisplayController> controller_;
@@ -65,8 +68,9 @@ class DriSurfaceAdapter : public ui::SurfaceOzoneCanvas {
 };
 
 DriSurfaceAdapter::DriSurfaceAdapter(
+    DriWrapper* dri,
     const base::WeakPtr<HardwareDisplayController>& controller)
-    : controller_(controller) {
+    : dri_(dri), controller_(controller) {
 }
 
 DriSurfaceAdapter::~DriSurfaceAdapter() {
@@ -80,6 +84,16 @@ void DriSurfaceAdapter::ResizeCanvas(const gfx::Size& viewport_size) {
   SkImageInfo info = SkImageInfo::MakeN32(
       viewport_size.width(), viewport_size.height(), kOpaque_SkAlphaType);
   surface_ = skia::AdoptRef(SkSurface::NewRaster(info));
+
+  if (controller_) {
+    // Need to use the mode size rather than |viewport_size| since a display
+    // cannot scanout from a buffer smaller than the mode.
+    native_surface_.reset(
+        new DriSurface(dri_,
+                       gfx::Size(controller_->get_mode().hdisplay,
+                                 controller_->get_mode().vdisplay)));
+    CHECK(native_surface_->Initialize());
+  }
 }
 
 void DriSurfaceAdapter::PresentCanvas(const gfx::Rect& damage) {
@@ -88,8 +102,10 @@ void DriSurfaceAdapter::PresentCanvas(const gfx::Rect& damage) {
     return;
 
   UpdateNativeSurface(damage);
-  controller_->SchedulePageFlip(std::vector<OzoneOverlayPlane>(), NULL);
+  controller_->SchedulePageFlip(std::vector<OverlayPlane>(
+      1, OverlayPlane(native_surface_->backbuffer())));
   controller_->WaitForPageFlipEvent();
+  native_surface_->SwapBuffers();
 }
 
 scoped_ptr<gfx::VSyncProvider> DriSurfaceAdapter::CreateVSyncProvider() {
@@ -97,8 +113,7 @@ scoped_ptr<gfx::VSyncProvider> DriSurfaceAdapter::CreateVSyncProvider() {
 }
 
 void DriSurfaceAdapter::UpdateNativeSurface(const gfx::Rect& damage) {
-  SkCanvas* canvas = static_cast<DriSurface*>(controller_->surface())
-      ->GetDrawableForWidget();
+  SkCanvas* canvas = native_surface_->GetDrawableForWidget();
 
   // The DriSurface is double buffered, so the current back buffer is
   // missing the previous update. Expand damage region.
@@ -175,7 +190,7 @@ scoped_ptr<ui::SurfaceOzoneCanvas> DriSurfaceFactory::CreateCanvasForWidget(
   ResetCursor(w);
 
   return scoped_ptr<ui::SurfaceOzoneCanvas>(
-      new DriSurfaceAdapter(screen_manager_->GetDisplayController(w)));
+      new DriSurfaceAdapter(drm_, screen_manager_->GetDisplayController(w)));
 }
 
 bool DriSurfaceFactory::LoadEGLGLES2Bindings(

ui/ozone/platform/dri/dri_surface_factory_unittest.cc

@@ -16,20 +16,20 @@
 #include "ui/ozone/platform/dri/hardware_display_controller.h"
 #include "ui/ozone/platform/dri/screen_manager.h"
 #include "ui/ozone/platform/dri/test/mock_dri_wrapper.h"
-#include "ui/ozone/platform/dri/test/mock_surface_generator.h"
 #include "ui/ozone/public/surface_factory_ozone.h"
 #include "ui/ozone/public/surface_ozone_canvas.h"
 
 namespace {
 
+// Mode of size 6x4.
 const drmModeModeInfo kDefaultMode =
     {0, 6, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, {'\0'}};
 
 class MockScreenManager : public ui::ScreenManager {
  public:
   MockScreenManager(ui::DriWrapper* dri,
-                    ui::ScanoutSurfaceGenerator* surface_generator)
-      : ScreenManager(dri, surface_generator),
+                    ui::ScanoutBufferGenerator* buffer_generator)
+      : ScreenManager(dri, buffer_generator),
         dri_(dri) {}
   virtual ~MockScreenManager() {}
 
@@ -56,7 +56,7 @@ class DriSurfaceFactoryTest : public testing::Test {
  protected:
   scoped_ptr<base::MessageLoop> message_loop_;
   scoped_ptr<ui::MockDriWrapper> dri_;
-  scoped_ptr<ui::MockSurfaceGenerator> surface_generator_;
+  scoped_ptr<ui::DriBufferGenerator> buffer_generator_;
   scoped_ptr<MockScreenManager> screen_manager_;
   scoped_ptr<ui::DriSurfaceFactory> factory_;
 
@@ -67,9 +67,9 @@ class DriSurfaceFactoryTest : public testing::Test {
 void DriSurfaceFactoryTest::SetUp() {
   message_loop_.reset(new base::MessageLoopForUI);
   dri_.reset(new ui::MockDriWrapper(3));
-  surface_generator_.reset(new ui::MockSurfaceGenerator(dri_.get()));
+  buffer_generator_.reset(new ui::DriBufferGenerator(dri_.get()));
   screen_manager_.reset(new MockScreenManager(dri_.get(),
-                                              surface_generator_.get()));
+                                              buffer_generator_.get()));
   factory_.reset(new ui::DriSurfaceFactory(dri_.get(), screen_manager_.get()));
 }
 
@@ -120,11 +120,12 @@ TEST_F(DriSurfaceFactoryTest, CheckNativeSurfaceContents) {
       gfx::Rect(0, 0, kDefaultMode.hdisplay / 2, kDefaultMode.vdisplay / 2));
 
   SkBitmap image;
-  // Buffers 0 and 1 are the cursor buffers and 2 and 3 are the surface buffers.
-  // Buffer 3 is the backbuffer we just painted in, so we want to make sure its
+  // Buffers 0 and 1 are the cursor buffers, 2 is the modeset buffer, and
+  // 3 and 4 are the surface buffers.
+  // Buffer 4 is the backbuffer we just painted in, so we want to make sure its
   // contents are correct.
-  image.setInfo(dri_->buffers()[3]->getCanvas()->imageInfo());
-  EXPECT_TRUE(dri_->buffers()[3]->getCanvas()->readPixels(&image, 0, 0));
+  image.setInfo(dri_->buffers()[4]->getCanvas()->imageInfo());
+  EXPECT_TRUE(dri_->buffers()[4]->getCanvas()->readPixels(&image, 0, 0));
 
   EXPECT_EQ(kDefaultMode.hdisplay, image.width());
   EXPECT_EQ(kDefaultMode.vdisplay, image.height());

ui/ozone/platform/dri/dri_surface_unittest.cc

@@ -60,15 +60,13 @@ TEST_F(DriSurfaceTest, SuccessfulInitialization) {
 
 TEST_F(DriSurfaceTest, CheckFBIDOnSwap) {
   EXPECT_TRUE(surface_->Initialize());
-  controller_->BindSurfaceToController(surface_.PassAs<ui::ScanoutSurface>(),
-                                       kDefaultMode);
 
   // Check that the framebuffer ID is correct.
-  EXPECT_EQ(2u, controller_->surface()->GetFramebufferId());
+  EXPECT_EQ(2u, surface_->GetFramebufferId());
 
-  controller_->surface()->SwapBuffers();
+  surface_->SwapBuffers();
 
-  EXPECT_EQ(1u, controller_->surface()->GetFramebufferId());
+  EXPECT_EQ(1u, surface_->GetFramebufferId());
 }
 
 TEST_F(DriSurfaceTest, CheckPixelPointerOnSwap) {

ui/ozone/platform/dri/gbm_buffer.cc

@@ -7,16 +7,10 @@
 #include <gbm.h>
 
 #include "base/logging.h"
-#include "ui/ozone/platform/dri/dri_wrapper.h"
-#include "ui/ozone/platform/dri/hardware_display_controller.h"
 
 namespace ui {
+
 namespace {
-// Pixel configuration for the current buffer format.
-// TODO(dnicoara) These will need to change once we query the hardware for
-// supported configurations.
-const uint8_t kColorDepth = 24;
-const uint8_t kPixelDepth = 32;
 
 int GetGbmFormatFromBufferFormat(SurfaceFactoryOzone::BufferFormat fmt) {
   switch (fmt) {
@@ -32,87 +26,55 @@ int GetGbmFormatFromBufferFormat(SurfaceFactoryOzone::BufferFormat fmt) {
   }
   return 0;
 }
-}
 
-GbmBuffer::GbmBuffer(gbm_device* device, DriWrapper* dri, const gfx::Size& size)
-    : gbm_device_(device),
-      bo_(NULL),
-      handle_(0),
-      framebuffer_(0),
-      dri_(dri),
-      size_(size) {
+}  // namespace
+
+GbmBuffer::GbmBuffer(DriWrapper* dri, gbm_bo* bo, bool scanout)
+    : GbmBufferBase(dri, bo, scanout) {
 }
 
 GbmBuffer::~GbmBuffer() {
-  if (framebuffer_)
-    dri_->RemoveFramebuffer(framebuffer_);
-  if (bo_)
-    gbm_bo_destroy(bo_);
+  if (bo())
+    gbm_bo_destroy(bo());
 }
 
-bool GbmBuffer::InitializeBuffer(SurfaceFactoryOzone::BufferFormat format,
-                                 bool scanout) {
+// static
+scoped_refptr<GbmBuffer> GbmBuffer::CreateBuffer(
+    DriWrapper* dri,
+    gbm_device* device,
+    SurfaceFactoryOzone::BufferFormat format,
+    const gfx::Size& size,
+    bool scanout) {
   unsigned flags = GBM_BO_USE_RENDERING;
   if (scanout)
     flags |= GBM_BO_USE_SCANOUT;
-  bo_ = gbm_bo_create(gbm_device_,
-                      size_.width(),
-                      size_.height(),
-                      GetGbmFormatFromBufferFormat(format),
-                      flags);
-  if (!bo_)
-    return false;
-
-  gbm_bo_set_user_data(bo_, this, NULL);
-  handle_ = gbm_bo_get_handle(bo_).u32;
-
-  if (scanout &&
-      !dri_->AddFramebuffer(size_.width(),
-                            size_.height(),
-                            kColorDepth,
-                            kPixelDepth,
-                            gbm_bo_get_stride(bo_),
-                            handle_,
-                            &framebuffer_)) {
-    return false;
-  }
-  return true;
-}
-
-bool GbmBuffer::Initialize() {
-  return bo_ != NULL;
-}
-
-uint32_t GbmBuffer::GetFramebufferId() const {
-  return framebuffer_;
-}
-
-uint32_t GbmBuffer::GetHandle() const {
-  return handle_;
-}
-
-gfx::Size GbmBuffer::Size() const {
-  return size_;
-}
-
-void GbmBuffer::PreSwapBuffers() {
-}
-
-void GbmBuffer::SwapBuffers() {
+  gbm_bo* bo = gbm_bo_create(device,
+                             size.width(),
+                             size.height(),
+                             GetGbmFormatFromBufferFormat(format),
+                             flags);
+  if (!bo)
+    return NULL;
+
+  scoped_refptr<GbmBuffer> buffer(new GbmBuffer(dri, bo, scanout));
+  if (scanout && !buffer->GetFramebufferId())
+    return NULL;
+
+  return buffer;
 }
 
-GbmPixmap::GbmPixmap(gbm_device* device, DriWrapper* dri, const gfx::Size& size)
-    : buffer_(device, dri, size) {
+GbmPixmap::GbmPixmap(scoped_refptr<GbmBuffer> buffer) : buffer_(buffer) {
 }
 
 GbmPixmap::~GbmPixmap() {
 }
 
 void* GbmPixmap::GetEGLClientBuffer() {
-  return buffer_.bo();
+  return buffer_->bo();
 }
 
 int GbmPixmap::GetDmaBufFd() {
+  NOTIMPLEMENTED();
   return -1;
 }
 

ui/ozone/platform/dri/gbm_buffer.h

@@ -8,7 +8,7 @@
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/gfx/geometry/size.h"
-#include "ui/ozone/platform/dri/scanout_surface.h"
+#include "ui/ozone/platform/dri/gbm_buffer_base.h"
 #include "ui/ozone/public/native_pixmap.h"
 #include "ui/ozone/public/surface_factory_ozone.h"
 
@@ -19,49 +19,38 @@ namespace ui {
 
 class DriWrapper;
 
-class GbmBuffer : public ScanoutSurface {
+class GbmBuffer : public GbmBufferBase {
  public:
-  GbmBuffer(gbm_device* device, DriWrapper* dri, const gfx::Size& size);
-  virtual ~GbmBuffer();
-
-  bool InitializeBuffer(SurfaceFactoryOzone::BufferFormat format, bool scanout);
-
-  // ScanoutSurface:
-  virtual bool Initialize() OVERRIDE;
-  virtual uint32_t GetFramebufferId() const OVERRIDE;
-  virtual uint32_t GetHandle() const OVERRIDE;
-  virtual gfx::Size Size() const OVERRIDE;
-  virtual void PreSwapBuffers() OVERRIDE;
-  virtual void SwapBuffers() OVERRIDE;
-
-  gbm_bo* bo() { return bo_; }
+  static scoped_refptr<GbmBuffer> CreateBuffer(
+      DriWrapper* dri,
+      gbm_device* device,
+      SurfaceFactoryOzone::BufferFormat format,
+      const gfx::Size& size,
+      bool scanout);
 
  private:
-  gbm_device* gbm_device_;
-  gbm_bo* bo_;
-
-  uint32_t handle_;
-  uint32_t framebuffer_;
-
-  DriWrapper* dri_;
+  GbmBuffer(DriWrapper* dri, gbm_bo* bo, bool scanout);
+  virtual ~GbmBuffer();
 
-  gfx::Size size_;
+  DISALLOW_COPY_AND_ASSIGN(GbmBuffer);
 };
 
 class GbmPixmap : public NativePixmap {
  public:
-  GbmPixmap(gbm_device* device, DriWrapper* dri, const gfx::Size& size);
+  GbmPixmap(scoped_refptr<GbmBuffer> buffer);
 
   // NativePixmap:
   virtual void* GetEGLClientBuffer() OVERRIDE;
   virtual int GetDmaBufFd() OVERRIDE;
 
-  GbmBuffer* buffer() { return &buffer_; }
+  scoped_refptr<GbmBuffer> buffer() { return buffer_; }
 
  private:
   virtual ~GbmPixmap();
 
-  GbmBuffer buffer_;
+  scoped_refptr<GbmBuffer> buffer_;
+
+  DISALLOW_COPY_AND_ASSIGN(GbmPixmap);
 };
 
 }  // namespace ui

ui/ozone/platform/dri/gbm_surface.h

@@ -28,6 +28,10 @@ class GbmSurface : public ScanoutSurface {
   GbmSurface(gbm_device* device, DriWrapper* dri, const gfx::Size& size);
   virtual ~GbmSurface();
 
+  scoped_refptr<GbmBufferBase> backbuffer() const {
+    return buffers_[front_buffer_ ^ 1];
+  }
+
   // ScanoutSurface:
   virtual bool Initialize() OVERRIDE;
   virtual uint32_t GetFramebufferId() const OVERRIDE;

ui/ozone/platform/dri/gbm_surface_factory.cc

@@ -23,9 +23,14 @@ namespace {
 
 class GbmSurfaceAdapter : public ui::SurfaceOzoneEGL {
  public:
-  GbmSurfaceAdapter(const base::WeakPtr<HardwareDisplayController>& controller);
+  GbmSurfaceAdapter(
+      gbm_device* device,
+      DriWrapper* dri,
+      const base::WeakPtr<HardwareDisplayController>& controller);
   virtual ~GbmSurfaceAdapter();
 
+  bool Initialize();
+
   // SurfaceOzoneEGL:
   virtual intptr_t GetNativeWindow() OVERRIDE;
   virtual bool ResizeNativeWindow(const gfx::Size& viewport_size) OVERRIDE;
@@ -38,40 +43,64 @@ class GbmSurfaceAdapter : public ui::SurfaceOzoneEGL {
                                     const gfx::RectF& crop_rect) OVERRIDE;
 
  private:
+  gbm_device* device_;
+  DriWrapper* dri_;
+  scoped_ptr<GbmSurface> surface_;
   base::WeakPtr<HardwareDisplayController> controller_;
-  NativePixmapList overlay_refs_;
-  std::vector<OzoneOverlayPlane> overlays_;
+  OverlayPlaneList overlays_;
 
   DISALLOW_COPY_AND_ASSIGN(GbmSurfaceAdapter);
 };
 
 GbmSurfaceAdapter::GbmSurfaceAdapter(
+    gbm_device* device,
+    DriWrapper* dri,
     const base::WeakPtr<HardwareDisplayController>& controller)
-    : controller_(controller) {}
+    : device_(device), dri_(dri), controller_(controller) {}
 
 GbmSurfaceAdapter::~GbmSurfaceAdapter() {}
 
+bool GbmSurfaceAdapter::Initialize() {
+  if (controller_) {
+    surface_.reset(
+        new GbmSurface(device_,
+                       dri_,
+                       gfx::Size(controller_->get_mode().hdisplay,
+                                 controller_->get_mode().vdisplay)));
+    return surface_->Initialize();
+  }
+
+  return false;
+}
+
 intptr_t GbmSurfaceAdapter::GetNativeWindow() {
   if (!controller_)
     return 0;
 
-  return reinterpret_cast<intptr_t>(
-      static_cast<GbmSurface*>(controller_->surface())->native_surface());
+  return reinterpret_cast<intptr_t>(surface_->native_surface());
 }
 
 bool GbmSurfaceAdapter::ResizeNativeWindow(const gfx::Size& viewport_size) {
-  NOTIMPLEMENTED();
-  return false;
+
+  return true;
 }
 
 bool GbmSurfaceAdapter::OnSwapBuffers() {
   if (!controller_)
     return false;
-  bool flip_succeeded =
-      controller_->SchedulePageFlip(overlays_, &overlay_refs_);
+  if (surface_) {
+    surface_->PreSwapBuffers();
+    overlays_.push_back(OverlayPlane(surface_->backbuffer()));
+  }
+
+  bool flip_succeeded = controller_->SchedulePageFlip(overlays_);
   overlays_.clear();
   if (flip_succeeded)
     controller_->WaitForPageFlipEvent();
+
+  if (surface_)
+    surface_->SwapBuffers();
+
   return flip_succeeded;
 }
 
@@ -86,12 +115,11 @@ bool GbmSurfaceAdapter::ScheduleOverlayPlane(
     LOG(ERROR) << "ScheduleOverlayPlane passed NULL buffer";
     return false;
   }
-  overlays_.push_back(OzoneOverlayPlane(pixmap->buffer(),
-                                        plane_z_order,
-                                        plane_transform,
-                                        display_bounds,
-                                        crop_rect));
-  overlay_refs_.push_back(buffer);
+  overlays_.push_back(OverlayPlane(pixmap->buffer(),
+                                   plane_z_order,
+                                   plane_transform,
+                                   display_bounds,
+                                   crop_rect));
   return true;
 }
 
@@ -181,18 +209,25 @@ scoped_ptr<ui::SurfaceOzoneEGL> GbmSurfaceFactory::CreateEGLSurfaceForWidget(
   CHECK(state_ == INITIALIZED);
   ResetCursor(w);
 
-  return scoped_ptr<ui::SurfaceOzoneEGL>(
-      new GbmSurfaceAdapter(screen_manager_->GetDisplayController(w)));
+  scoped_ptr<GbmSurfaceAdapter> surface(
+      new GbmSurfaceAdapter(device_,
+                            drm_,
+                            screen_manager_->GetDisplayController(w)));
+  if (!allow_surfaceless_ && !surface->Initialize())
+    return scoped_ptr<SurfaceOzoneEGL>();
+
+  return surface.PassAs<SurfaceOzoneEGL>();
 }
 
 scoped_refptr<ui::NativePixmap> GbmSurfaceFactory::CreateNativePixmap(
     gfx::Size size,
     BufferFormat format) {
-  scoped_refptr<GbmPixmap> buf = new GbmPixmap(device_, drm_, size);
-  if (!buf->buffer()->InitializeBuffer(format, true)) {
+  scoped_refptr<GbmBuffer> buffer = GbmBuffer::CreateBuffer(
+      drm_, device_, format, size, true);
+  if (!buffer)
     return NULL;
-  }
-  return buf;
+
+  return scoped_refptr<GbmPixmap>(new GbmPixmap(buffer));
 }
 
 bool GbmSurfaceFactory::CanShowPrimaryPlaneAsOverlay() {

ui/ozone/platform/dri/hardware_display_controller.cc

@@ -18,7 +18,6 @@
 #include "ui/gfx/geometry/size.h"
 #include "ui/ozone/platform/dri/dri_buffer.h"
 #include "ui/ozone/platform/dri/dri_wrapper.h"
-#include "ui/ozone/platform/dri/scanout_surface.h"
 #include "ui/ozone/public/native_pixmap.h"
 
 namespace ui {
@@ -45,14 +44,31 @@ void HandlePageFlipEvent(int fd,
       ->OnPageFlipEvent(frame, seconds, useconds);
 }
 
+const OverlayPlane& GetPrimaryPlane(const OverlayPlaneList& overlays) {
+  for (size_t i = 0; i < overlays.size(); ++i) {
+    if (overlays[i].z_order == 0)
+      return overlays[i];
+  }
+
+  NOTREACHED();
+  return overlays[0];
+}
+
 }  // namespace
 
-OzoneOverlayPlane::OzoneOverlayPlane(ScanoutSurface* scanout,
-                                     int z_order,
-                                     gfx::OverlayTransform plane_transform,
-                                     const gfx::Rect& display_bounds,
-                                     const gfx::RectF& crop_rect)
-    : scanout(scanout),
+OverlayPlane::OverlayPlane(scoped_refptr<ScanoutBuffer> buffer)
+    : buffer(buffer),
+      z_order(0),
+      display_bounds(gfx::Point(), buffer->GetSize()),
+      crop_rect(0, 0, 1, 1),
+      overlay_plane(0) {}
+
+OverlayPlane::OverlayPlane(scoped_refptr<ScanoutBuffer> buffer,
+                           int z_order,
+                           gfx::OverlayTransform plane_transform,
+                           const gfx::Rect& display_bounds,
+                           const gfx::RectF& crop_rect)
+    : buffer(buffer),
       z_order(z_order),
       plane_transform(plane_transform),
       display_bounds(display_bounds),
@@ -60,6 +76,8 @@ OzoneOverlayPlane::OzoneOverlayPlane(ScanoutSurface* scanout,
       overlay_plane(0) {
 }
 
+OverlayPlane::~OverlayPlane() {}
+
 HardwareDisplayController::HardwareDisplayController(
     DriWrapper* drm,
     uint32_t connector_id,
@@ -67,7 +85,6 @@ HardwareDisplayController::HardwareDisplayController(
     : drm_(drm),
       connector_id_(connector_id),
       crtc_id_(crtc_id),
-      surface_(),
       time_of_last_flip_(0),
       is_disabled_(true),
       saved_crtc_(drm_->GetCrtc(crtc_id_)) {}
@@ -78,45 +95,35 @@ HardwareDisplayController::~HardwareDisplayController() {
 
   // Reset the cursor.
   UnsetCursor();
-  UnbindSurfaceFromController();
 }
 
-bool
-HardwareDisplayController::BindSurfaceToController(
-    scoped_ptr<ScanoutSurface> surface, drmModeModeInfo mode) {
-  CHECK(surface);
-
+bool HardwareDisplayController::Modeset(const OverlayPlane& primary,
+                                        drmModeModeInfo mode) {
+  CHECK(primary.buffer);
   if (!drm_->SetCrtc(crtc_id_,
-                     surface->GetFramebufferId(),
+                     primary.buffer->GetFramebufferId(),
                      &connector_id_,
                      &mode)) {
     LOG(ERROR) << "Failed to modeset: error='" << strerror(errno)
                << "' crtc=" << crtc_id_ << " connector=" << connector_id_
-               << " framebuffer_id=" << surface->GetFramebufferId()
+               << " framebuffer_id=" << primary.buffer->GetFramebufferId()
                << " mode=" << mode.hdisplay << "x" << mode.vdisplay << "@"
                << mode.vrefresh;
     return false;
   }
 
-  surface_.reset(surface.release());
+  current_planes_ = std::vector<OverlayPlane>(1, primary);
+  pending_planes_.clear();
   mode_ = mode;
   is_disabled_ = false;
   return true;
 }
 
-void HardwareDisplayController::UnbindSurfaceFromController() {
-  drm_->SetCrtc(crtc_id_, 0, 0, NULL);
-  surface_.reset();
-  memset(&mode_, 0, sizeof(mode_));
-  is_disabled_ = true;
-}
-
 bool HardwareDisplayController::Enable() {
-  CHECK(surface_);
-  if (is_disabled_) {
-    scoped_ptr<ScanoutSurface> surface(surface_.release());
-    return BindSurfaceToController(surface.Pass(), mode_);
-  }
+  OverlayPlane primary = GetPrimaryPlane(current_planes_);
+  CHECK(primary.buffer);
+  if (is_disabled_)
+    return Modeset(primary, mode_);
 
   return true;
 }
@@ -126,46 +133,29 @@ void HardwareDisplayController::Disable() {
   is_disabled_ = true;
 }
 
-ScanoutSurface* HardwareDisplayController::GetPrimaryPlane(
-    const std::vector<OzoneOverlayPlane>& overlays) {
-  ScanoutSurface* primary = surface_.get();
-  for (size_t i = 0; i < overlays.size(); i++) {
-    const OzoneOverlayPlane& plane = overlays[i];
-    if (plane.z_order == 0) {
-      return plane.scanout;
-    }
-  }
-
-  return primary;
-}
-
 bool HardwareDisplayController::SchedulePageFlip(
-    const std::vector<OzoneOverlayPlane>& overlays,
-    NativePixmapList* references) {
-  ScanoutSurface* primary = GetPrimaryPlane(overlays);
-  CHECK(primary);
-
-  primary->PreSwapBuffers();
+    const OverlayPlaneList& overlays) {
+  CHECK_LE(1u, overlays.size());
+  const OverlayPlane& primary = GetPrimaryPlane(overlays);
+  CHECK(primary.buffer);
 
   if (!is_disabled_ &&
-      !drm_->PageFlip(crtc_id_, primary->GetFramebufferId(), this)) {
+      !drm_->PageFlip(crtc_id_, primary.buffer->GetFramebufferId(), this)) {
     LOG(ERROR) << "Cannot page flip: " << strerror(errno);
     return false;
   }
 
-  current_overlay_references_.clear();
-  if (references)
-    current_overlay_references_.swap(*references);
+  pending_planes_ = overlays;
 
   for (size_t i = 0; i < overlays.size(); i++) {
-    const OzoneOverlayPlane& plane = overlays[i];
+    const OverlayPlane& plane = overlays[i];
     if (!plane.overlay_plane)
       continue;
-    const gfx::Size& size = plane.scanout->Size();
+    const gfx::Size& size = plane.buffer->GetSize();
     gfx::RectF crop_rect = plane.crop_rect;
     crop_rect.Scale(size.width(), size.height());
     if (!drm_->PageFlipOverlay(crtc_id_,
-                               plane.scanout->GetFramebufferId(),
+                               plane.buffer->GetFramebufferId(),
                                plane.display_bounds,
                                crop_rect,
                                plane.overlay_plane)) {
@@ -199,7 +189,8 @@ void HardwareDisplayController::OnPageFlipEvent(unsigned int frame,
       static_cast<uint64_t>(seconds) * base::Time::kMicrosecondsPerSecond +
       useconds;
 
-  surface_->SwapBuffers();
+  current_planes_ = pending_planes_;
+  pending_planes_.clear();
 }
 
 bool HardwareDisplayController::SetCursor(scoped_refptr<ScanoutBuffer> buffer) {

ui/ozone/platform/dri/hardware_display_controller.h

@@ -21,20 +21,21 @@ class Point;
 
 namespace ui {
 
-class NativePixmap;
 class ScanoutBuffer;
-class ScanoutSurface;
 
-typedef std::vector<scoped_refptr<NativePixmap> > NativePixmapList;
+struct OverlayPlane {
+  // Simpler constructor for the primary plane.
+  explicit OverlayPlane(scoped_refptr<ScanoutBuffer> buffer);
 
-struct OzoneOverlayPlane {
-  OzoneOverlayPlane(ScanoutSurface* scanout,
-                    int z_order,
-                    gfx::OverlayTransform plane_transform,
-                    const gfx::Rect& display_bounds,
-                    const gfx::RectF& crop_rect);
+  OverlayPlane(scoped_refptr<ScanoutBuffer> buffer,
+               int z_order,
+               gfx::OverlayTransform plane_transform,
+               const gfx::Rect& display_bounds,
+               const gfx::RectF& crop_rect);
 
-  ScanoutSurface* scanout;
+  ~OverlayPlane();
+
+  scoped_refptr<ScanoutBuffer> buffer;
   int z_order;
   gfx::OverlayTransform plane_transform;
   gfx::Rect display_bounds;
@@ -42,6 +43,8 @@ struct OzoneOverlayPlane {
   int overlay_plane;
 };
 
+typedef std::vector<OverlayPlane> OverlayPlaneList;
+
 // The HDCOz will handle modesettings and scannout operations for hardware
 // devices.
 //
@@ -105,11 +108,10 @@ class HardwareDisplayController
 
   ~HardwareDisplayController();
 
-  // Associate the HDCO with a surface implementation and initialize it.
-  bool BindSurfaceToController(scoped_ptr<ScanoutSurface> surface,
-                               drmModeModeInfo mode);
-
-  void UnbindSurfaceFromController();
+  // Performs the initial CRTC configuration. If successful, it will display the
+  // framebuffer for |primary| with |mode|.
+  bool Modeset(const OverlayPlane& primary,
+               drmModeModeInfo mode);
 
   // Reconfigures the CRTC with the current surface and mode.
   bool Enable();
@@ -117,14 +119,14 @@ class HardwareDisplayController
   // Disables the CRTC.
   void Disable();
 
-  // Schedules the |surface_|'s framebuffer to be displayed on the next vsync
+  // Schedules the |overlays|' framebuffers to be displayed on the next vsync
   // event. The event will be posted on the graphics card file descriptor |fd_|
   // and it can be read and processed by |drmHandleEvent|. That function can
   // define the callback for the page flip event. A generic data argument will
   // be presented to the callback. We use that argument to pass in the HDCO
   // object the event belongs to.
   //
-  // Between this call and the callback, the framebuffer used in this call
+  // Between this call and the callback, the framebuffers used in this call
   // should not be modified in any way as it would cause screen tearing if the
   // hardware performed the flip. Note that the frontbuffer should also not
   // be modified as it could still be displayed.
@@ -133,8 +135,7 @@ class HardwareDisplayController
   // called again before the page flip occurrs.
   //
   // Returns true if the page flip was successfully registered, false otherwise.
-  bool SchedulePageFlip(const std::vector<OzoneOverlayPlane>& overlays,
-                        NativePixmapList* references);
+  bool SchedulePageFlip(const OverlayPlaneList& overlays);
 
   // TODO(dnicoara) This should be on the MessageLoop when Ozone can have
   // BeginFrame can be triggered explicitly by Ozone.
@@ -161,19 +162,14 @@ class HardwareDisplayController
   const drmModeModeInfo& get_mode() const { return mode_; };
   uint32_t connector_id() const { return connector_id_; }
   uint32_t crtc_id() const { return crtc_id_; }
-  ScanoutSurface* surface() const {
-    return surface_.get();
-  };
 
   uint64_t get_time_of_last_flip() const {
     return time_of_last_flip_;
   };
 
  private:
-  ScanoutSurface* GetPrimaryPlane(
-      const std::vector<OzoneOverlayPlane>& overlays);
-
-  NativePixmapList current_overlay_references_;
+  OverlayPlaneList current_planes_;
+  OverlayPlaneList pending_planes_;
 
   // Object containing the connection to the graphics device and wraps the API
   // calls to control it.
@@ -186,8 +182,6 @@ class HardwareDisplayController
 
   drmModeModeInfo mode_;
 
-  scoped_ptr<ScanoutSurface> surface_;
-
   scoped_refptr<ScanoutBuffer> cursor_buffer_;
 
   uint64_t time_of_last_flip_;

ui/ozone/platform/dri/hardware_display_controller_unittest.cc

@@ -5,7 +5,6 @@
 #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"
@@ -20,6 +19,23 @@ const drmModeModeInfo kDefaultMode =
 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 {
@@ -47,122 +63,97 @@ void HardwareDisplayControllerTest::TearDown() {
   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(controller_->Modeset(plane1, kDefaultMode));
 
-  EXPECT_TRUE(surface->Initialize());
-  EXPECT_TRUE(controller_->BindSurfaceToController(surface.Pass(),
-                                                   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(controller_->Modeset(plane1, kDefaultMode));
 
-  EXPECT_TRUE(surface->Initialize());
-  EXPECT_TRUE(controller_->BindSurfaceToController(surface.Pass(),
-                                                   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));
-
-  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(),
-                                           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));
+  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(controller_->Modeset(plane1, kDefaultMode));
+
+  std::vector<ui::OverlayPlane> overlays;
+  overlays.push_back(plane1);
+  overlays.push_back(plane2);
+
+  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());
 }

ui/ozone/platform/dri/ozone_platform_dri.cc

@@ -10,10 +10,9 @@
 #include "ui/events/ozone/evdev/event_factory_evdev.h"
 #include "ui/ozone/common/window/platform_window_compat.h"
 #include "ui/ozone/platform/dri/cursor_factory_evdev_dri.h"
-#include "ui/ozone/platform/dri/dri_surface.h"
+#include "ui/ozone/platform/dri/dri_buffer.h"
 #include "ui/ozone/platform/dri/dri_surface_factory.h"
 #include "ui/ozone/platform/dri/dri_wrapper.h"
-#include "ui/ozone/platform/dri/scanout_surface.h"
 #include "ui/ozone/platform/dri/screen_manager.h"
 #include "ui/ozone/platform/dri/virtual_terminal_manager.h"
 #include "ui/ozone/public/ozone_platform.h"
@@ -29,21 +28,6 @@ namespace {
 
 const char kDefaultGraphicsCardPath[] = "/dev/dri/card0";
 
-class DriSurfaceGenerator : public ScanoutSurfaceGenerator {
- public:
-  DriSurfaceGenerator(DriWrapper* dri) : dri_(dri) {}
-  virtual ~DriSurfaceGenerator() {}
-
-  virtual ScanoutSurface* Create(const gfx::Size& size) OVERRIDE {
-    return new DriSurface(dri_, size);
-  }
-
- private:
-  DriWrapper* dri_;  // Not owned.
-
-  DISALLOW_COPY_AND_ASSIGN(DriSurfaceGenerator);
-};
-
 // OzonePlatform for Linux DRI (Direct Rendering Infrastructure)
 //
 // This platform is Linux without any display server (no X, wayland, or
@@ -53,9 +37,9 @@ class OzonePlatformDri : public OzonePlatform {
   OzonePlatformDri()
       : vt_manager_(new VirtualTerminalManager()),
         dri_(new DriWrapper(kDefaultGraphicsCardPath)),
-        surface_generator_(new DriSurfaceGenerator(dri_.get())),
+        buffer_generator_(new DriBufferGenerator(dri_.get())),
         screen_manager_(new ScreenManager(dri_.get(),
-                                          surface_generator_.get())),
+                                          buffer_generator_.get())),
         device_manager_(CreateDeviceManager()) {
     base::AtExitManager::RegisterTask(
         base::Bind(&base::DeletePointer<OzonePlatformDri>, this));
@@ -110,7 +94,7 @@ class OzonePlatformDri : public OzonePlatform {
  private:
   scoped_ptr<VirtualTerminalManager> vt_manager_;
   scoped_ptr<DriWrapper> dri_;
-  scoped_ptr<DriSurfaceGenerator> surface_generator_;
+  scoped_ptr<DriBufferGenerator> buffer_generator_;
   scoped_ptr<ScreenManager> screen_manager_;
   scoped_ptr<DeviceManager> device_manager_;
 

ui/ozone/platform/dri/ozone_platform_gbm.cc

@@ -19,7 +19,7 @@
 #include "ui/ozone/platform/dri/gbm_surface_factory.h"
 #include "ui/ozone/platform/dri/gpu_platform_support_gbm.h"
 #include "ui/ozone/platform/dri/gpu_platform_support_host_gbm.h"
-#include "ui/ozone/platform/dri/scanout_surface.h"
+#include "ui/ozone/platform/dri/scanout_buffer.h"
 #include "ui/ozone/platform/dri/screen_manager.h"
 #include "ui/ozone/platform/dri/virtual_terminal_manager.h"
 #include "ui/ozone/public/cursor_factory_ozone.h"
@@ -40,13 +40,13 @@ namespace {
 
 const char kDefaultGraphicsCardPath[] = "/dev/dri/card0";
 
-class GbmSurfaceGenerator : public ScanoutSurfaceGenerator {
+class GbmBufferGenerator : public ScanoutBufferGenerator {
  public:
-  GbmSurfaceGenerator(DriWrapper* dri)
+  GbmBufferGenerator(DriWrapper* dri)
       : dri_(dri),
         glapi_lib_(dlopen("libglapi.so.0", RTLD_LAZY | RTLD_GLOBAL)),
         device_(gbm_create_device(dri_->get_fd())) {}
-  virtual ~GbmSurfaceGenerator() {
+  virtual ~GbmBufferGenerator() {
     gbm_device_destroy(device_);
     if (glapi_lib_)
       dlclose(glapi_lib_);
@@ -54,8 +54,9 @@ class GbmSurfaceGenerator : public ScanoutSurfaceGenerator {
 
   gbm_device* device() const { return device_; }
 
-  virtual ScanoutSurface* Create(const gfx::Size& size) OVERRIDE {
-    return new GbmSurface(device_, dri_, size);
+  virtual scoped_refptr<ScanoutBuffer> Create(const gfx::Size& size) OVERRIDE {
+    return GbmBuffer::CreateBuffer(
+        dri_, device_, SurfaceFactoryOzone::RGBA_8888, size, true);
   }
 
  protected:
@@ -66,22 +67,7 @@ class GbmSurfaceGenerator : public ScanoutSurfaceGenerator {
 
   gbm_device* device_;
 
-  DISALLOW_COPY_AND_ASSIGN(GbmSurfaceGenerator);
-};
-
-class GbmEglImageSurfaceGenerator : public GbmSurfaceGenerator {
- public:
-  GbmEglImageSurfaceGenerator(DriWrapper* dri) : GbmSurfaceGenerator(dri) {}
-  virtual ~GbmEglImageSurfaceGenerator() {}
-
-  virtual ScanoutSurface* Create(const gfx::Size& size) OVERRIDE {
-    scoped_ptr<GbmBuffer> buffer =
-        scoped_ptr<GbmBuffer>(new GbmBuffer(device_, dri_, size));
-    if (!buffer->InitializeBuffer(SurfaceFactoryOzone::RGBA_8888, true)) {
-      return NULL;
-    }
-    return buffer.release();
-  }
+  DISALLOW_COPY_AND_ASSIGN(GbmBufferGenerator);
 };
 
 class OzonePlatformGbm : public OzonePlatform {
@@ -142,17 +128,14 @@ class OzonePlatformGbm : public OzonePlatform {
 
   virtual void InitializeGPU() OVERRIDE {
     dri_.reset(new DriWrapper(kDefaultGraphicsCardPath));
-    if (use_surfaceless_)
-      surface_generator_.reset(new GbmEglImageSurfaceGenerator(dri_.get()));
-    else
-      surface_generator_.reset(new GbmSurfaceGenerator(dri_.get()));
+    buffer_generator_.reset(new GbmBufferGenerator(dri_.get()));
     screen_manager_.reset(new ScreenManager(dri_.get(),
-                                            surface_generator_.get()));
+                                            buffer_generator_.get()));
     if (!surface_factory_ozone_)
       surface_factory_ozone_.reset(new GbmSurfaceFactory(use_surfaceless_));
 
     surface_factory_ozone_->InitializeGpu(dri_.get(),
-                                          surface_generator_->device(),
+                                          buffer_generator_->device(),
                                           screen_manager_.get());
 
     gpu_platform_support_.reset(
@@ -171,7 +154,7 @@ class OzonePlatformGbm : public OzonePlatform {
   bool use_surfaceless_;
   scoped_ptr<VirtualTerminalManager> vt_manager_;
   scoped_ptr<DriWrapper> dri_;
-  scoped_ptr<GbmSurfaceGenerator> surface_generator_;
+  scoped_ptr<GbmBufferGenerator> buffer_generator_;
   scoped_ptr<ScreenManager> screen_manager_;
   scoped_ptr<DeviceManager> device_manager_;
 

ui/ozone/platform/dri/screen_manager.cc

@@ -11,13 +11,13 @@
 #include "ui/gfx/geometry/size.h"
 #include "ui/ozone/platform/dri/dri_util.h"
 #include "ui/ozone/platform/dri/hardware_display_controller.h"
-#include "ui/ozone/platform/dri/scanout_surface.h"
+#include "ui/ozone/platform/dri/scanout_buffer.h"
 
 namespace ui {
 
 ScreenManager::ScreenManager(
-    DriWrapper* dri, ScanoutSurfaceGenerator* surface_generator)
-    : dri_(dri), surface_generator_(surface_generator), last_added_widget_(0) {
+    DriWrapper* dri, ScanoutBufferGenerator* buffer_generator)
+    : dri_(dri), buffer_generator_(buffer_generator), last_added_widget_(0) {
 }
 
 ScreenManager::~ScreenManager() {
@@ -45,7 +45,6 @@ bool ScreenManager::ConfigureDisplayController(uint32_t crtc,
       return it->second->Enable();
 
     controller = it->second;
-    controller->UnbindSurfaceFromController();
   }
 
   if (it == controllers_.end()) {
@@ -54,19 +53,16 @@ bool ScreenManager::ConfigureDisplayController(uint32_t crtc,
   }
 
   // Create a surface suitable for the current controller.
-  scoped_ptr<ScanoutSurface> surface(
-      surface_generator_->Create(gfx::Size(mode.hdisplay, mode.vdisplay)));
+  scoped_refptr<ScanoutBuffer> buffer =
+      buffer_generator_->Create(gfx::Size(mode.hdisplay, mode.vdisplay));
 
-  if (!surface->Initialize()) {
-    LOG(ERROR) << "Failed to initialize surface";
+  if (!buffer) {
+    LOG(ERROR) << "Failed to create scanout buffer";
     return false;
   }
 
-  // Bind the surface to the controller. This will register the backing buffers
-  // with the hardware CRTC such that we can show the buffers and performs the
-  // initial modeset. The controller takes ownership of the surface.
-  if (!controller->BindSurfaceToController(surface.Pass(), mode)) {
-    LOG(ERROR) << "Failed to bind surface to controller";
+  if (!controller->Modeset(OverlayPlane(buffer), mode)) {
+    LOG(ERROR) << "Failed to modeset controller";
     return false;
   }
 

ui/ozone/platform/dri/screen_manager.h

@@ -23,12 +23,12 @@ class Size;
 namespace ui {
 
 class DriWrapper;
-class ScanoutSurfaceGenerator;
+class ScanoutBufferGenerator;
 
 // Responsible for keeping track of active displays and configuring them.
 class ScreenManager {
  public:
-  ScreenManager(DriWrapper* dri, ScanoutSurfaceGenerator* surface_generator);
+  ScreenManager(DriWrapper* dri, ScanoutBufferGenerator* surface_generator);
   virtual ~ScreenManager();
 
   // Remove a display controller from the list of active controllers. The
@@ -70,7 +70,7 @@ class ScreenManager {
   virtual void ForceInitializationOfPrimaryDisplay();
 
   DriWrapper* dri_;  // Not owned.
-  ScanoutSurfaceGenerator* surface_generator_;  // Not owned.
+  ScanoutBufferGenerator* buffer_generator_;  // Not owned.
   // Mapping between an accelerated widget and an active display.
   HardwareDisplayControllerMap controllers_;
   gfx::AcceleratedWidget last_added_widget_;

ui/ozone/platform/dri/screen_manager_unittest.cc

@@ -3,10 +3,10 @@
 // found in the LICENSE file.
 
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/ozone/platform/dri/dri_buffer.h"
 #include "ui/ozone/platform/dri/hardware_display_controller.h"
 #include "ui/ozone/platform/dri/screen_manager.h"
 #include "ui/ozone/platform/dri/test/mock_dri_wrapper.h"
-#include "ui/ozone/platform/dri/test/mock_surface_generator.h"
 
 namespace {
 
@@ -17,8 +17,8 @@ const drmModeModeInfo kDefaultMode =
 class MockScreenManager : public ui::ScreenManager {
  public:
   MockScreenManager(ui::DriWrapper* dri,
-                    ui::ScanoutSurfaceGenerator* surface_generator)
-      : ScreenManager(dri, surface_generator), dri_(dri) {}
+                    ui::ScanoutBufferGenerator* buffer_generator)
+      : ScreenManager(dri, buffer_generator), dri_(dri) {}
 
   virtual void ForceInitializationOfPrimaryDisplay() OVERRIDE {}
 
@@ -37,9 +37,9 @@ class ScreenManagerTest : public testing::Test {
 
   virtual void SetUp() OVERRIDE {
     dri_.reset(new ui::MockDriWrapper(3));
-    surface_generator_.reset(new ui::MockSurfaceGenerator(dri_.get()));
+    buffer_generator_.reset(new ui::DriBufferGenerator(dri_.get()));
     screen_manager_.reset(new MockScreenManager(
-        dri_.get(), surface_generator_.get()));
+        dri_.get(), buffer_generator_.get()));
   }
   virtual void TearDown() OVERRIDE {
     screen_manager_.reset();
@@ -48,7 +48,7 @@ class ScreenManagerTest : public testing::Test {
 
  protected:
   scoped_ptr<ui::MockDriWrapper> dri_;
-  scoped_ptr<ui::MockSurfaceGenerator> surface_generator_;
+  scoped_ptr<ui::DriBufferGenerator> buffer_generator_;
   scoped_ptr<MockScreenManager> screen_manager_;
 
  private:

ui/ozone/platform/dri/test/mock_dri_wrapper.cc

@@ -8,7 +8,6 @@
 #include <xf86drmMode.h>
 
 #include "third_party/skia/include/core/SkCanvas.h"
-#include "ui/ozone/platform/dri/dri_surface.h"
 #include "ui/ozone/platform/dri/hardware_display_controller.h"
 
 namespace ui {
@@ -32,7 +31,9 @@ MockDriWrapper::MockDriWrapper(int fd)
       set_crtc_expectation_(true),
       add_framebuffer_expectation_(true),
       page_flip_expectation_(true),
-      create_dumb_buffer_expectation_(true) {
+      create_dumb_buffer_expectation_(true),
+      current_framebuffer_(0),
+      controller_(NULL) {
   fd_ = fd;
 }
 
@@ -49,6 +50,7 @@ bool MockDriWrapper::SetCrtc(uint32_t crtc_id,
                              uint32_t framebuffer,
                              uint32_t* connectors,
                              drmModeModeInfo* mode) {
+  current_framebuffer_ = framebuffer;
   return set_crtc_expectation_;
 }
 
@@ -78,7 +80,8 @@ bool MockDriWrapper::PageFlip(uint32_t crtc_id,
                               uint32_t framebuffer,
                               void* data) {
   page_flip_call_count_++;
-  static_cast<ui::HardwareDisplayController*>(data)->surface()->SwapBuffers();
+  current_framebuffer_ = framebuffer;
+  controller_ = static_cast<ui::HardwareDisplayController*>(data);
   return page_flip_expectation_;
 }
 
@@ -119,6 +122,8 @@ bool MockDriWrapper::MoveCursor(uint32_t crtc_id, const gfx::Point& point) {
 }
 
 void MockDriWrapper::HandleEvent(drmEventContext& event) {
+  if (controller_)
+    controller_->OnPageFlipEvent(0, 0, 0);
 }
 
 bool MockDriWrapper::CreateDumbBuffer(const SkImageInfo& info,

ui/ozone/platform/dri/test/mock_dri_wrapper.h

@@ -13,6 +13,8 @@
 
 namespace ui {
 
+class HardwareDisplayController;
+
 // The real DriWrapper makes actual DRM calls which we can't use in unit tests.
 class MockDriWrapper : public ui::DriWrapper {
  public:
@@ -39,6 +41,8 @@ class MockDriWrapper : public ui::DriWrapper {
     create_dumb_buffer_expectation_ = state;
   }
 
+  uint32_t current_framebuffer() const { return current_framebuffer_; }
+
   const std::vector<skia::RefPtr<SkSurface> > buffers() const {
     return buffers_;
   }
@@ -100,8 +104,12 @@ class MockDriWrapper : public ui::DriWrapper {
   bool page_flip_expectation_;
   bool create_dumb_buffer_expectation_;
 
+  uint32_t current_framebuffer_;
+
   std::vector<skia::RefPtr<SkSurface> > buffers_;
 
+  HardwareDisplayController* controller_;
+
   DISALLOW_COPY_AND_ASSIGN(MockDriWrapper);
 };
 

ui/ozone/platform/dri/test/mock_surface_generator.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/test/mock_surface_generator.h"
-
-namespace ui {
-
-MockSurfaceGenerator::MockSurfaceGenerator(DriWrapper* dri) : dri_(dri) {}
-
-MockSurfaceGenerator::~MockSurfaceGenerator() {}
-
-ScanoutSurface* MockSurfaceGenerator::Create(const gfx::Size& size) {
-  surfaces_.push_back(new DriSurface(dri_, size));
-  return surfaces_.back();
-}
-
-}  // namespace ui

ui/ozone/platform/dri/test/mock_surface_generator.h

-// 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.
-
-#ifndef UI_OZONE_PLATFORM_DRI_TEST_MOCK_SURFACE_GENERATOR_H_
-#define UI_OZONE_PLATFORM_DRI_TEST_MOCK_SURFACE_GENERATOR_H_
-
-#include <vector>
-
-#include "ui/ozone/platform/dri/dri_surface.h"
-
-namespace gfx {
-class Size;
-}
-
-namespace ui {
-
-class DriWrapper;
-
-class MockSurfaceGenerator : public ScanoutSurfaceGenerator {
- public:
-  MockSurfaceGenerator(DriWrapper* dri);
-  virtual ~MockSurfaceGenerator();
-
-  std::vector<DriSurface*> surfaces() const { return surfaces_; }
-
-  // ScanoutSurfaceGenerator:
-  virtual ScanoutSurface* Create(const gfx::Size& size) OVERRIDE;
-
- private:
-  DriWrapper* dri_;  // Not owned.
-
-  std::vector<DriSurface*> surfaces_;
-
-  DISALLOW_COPY_AND_ASSIGN(MockSurfaceGenerator);
-};
-
-}  // namespace ui
-
-#endif  // UI_OZONE_PLATFORM_DRI_TEST_MOCK_SURFACE_GENERATOR_H_