[Ozone-DRI] Convert HardwareDisplayController to use scanout buffers

ui/ozone/platform/dri/dri_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/dri_surface_factory.h"
 
 #include <errno.h>
 
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 27 matching lines @@
 
   SkRect clip;
   clip.set(
       0, 0, canvas->getDeviceSize().width(), canvas->getDeviceSize().height());
   canvas->clipRect(clip, SkRegion::kReplace_Op);
   canvas->drawBitmapRectToRect(image, &damage, damage);
 }
 
 class DriSurfaceAdapter : public ui::SurfaceOzoneCanvas {
  public:
-  DriSurfaceAdapter(const base::WeakPtr<HardwareDisplayController>& controller);
+  DriSurfaceAdapter(DriWrapper* dri,
+                    const base::WeakPtr<HardwareDisplayController>& controller);
   virtual ~DriSurfaceAdapter();
 
   // SurfaceOzoneCanvas:
   virtual skia::RefPtr<SkCanvas> GetCanvas() OVERRIDE;
   virtual void ResizeCanvas(const gfx::Size& viewport_size) OVERRIDE;
   virtual void PresentCanvas(const gfx::Rect& damage) OVERRIDE;
   virtual scoped_ptr<gfx::VSyncProvider> CreateVSyncProvider() OVERRIDE;
 
  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_;
 
   DISALLOW_COPY_AND_ASSIGN(DriSurfaceAdapter);
 };
 
 DriSurfaceAdapter::DriSurfaceAdapter(
+    DriWrapper* dri,
     const base::WeakPtr<HardwareDisplayController>& controller)
-    : controller_(controller) {
+    : dri_(dri), controller_(controller) {
 }
 
 DriSurfaceAdapter::~DriSurfaceAdapter() {
 }
 
 skia::RefPtr<SkCanvas> DriSurfaceAdapter::GetCanvas() {
   return skia::SharePtr(surface_->getCanvas());
 }
 
 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) {
   CHECK(base::MessageLoopForUI::IsCurrent());
   if (!controller_)
     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() {
   return scoped_ptr<gfx::VSyncProvider>(new DriVSyncProvider(controller_));
 }
 
 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.
   SkRect real_damage = RectToSkRect(UnionRects(damage, last_damage_));
 
   // Copy damage region.
   skia::RefPtr<SkImage> image = skia::AdoptRef(surface_->newImageSnapshot());
   image->draw(canvas, &real_damage, real_damage, NULL);
 
   last_damage_ = damage;
@@ skipping 56 matching lines @@
   return ++allocated_widgets_;
 }
 
 scoped_ptr<ui::SurfaceOzoneCanvas> DriSurfaceFactory::CreateCanvasForWidget(
     gfx::AcceleratedWidget w) {
   CHECK(state_ == INITIALIZED);
   // Initial cursor set.
   ResetCursor(w);
 
   return scoped_ptr<ui::SurfaceOzoneCanvas>(
-      new DriSurfaceAdapter(screen_manager_->GetDisplayController(w)));
+      new DriSurfaceAdapter(drm_, screen_manager_->GetDisplayController(w)));
 }
 
 bool DriSurfaceFactory::LoadEGLGLES2Bindings(
       AddGLLibraryCallback add_gl_library,
       SetGLGetProcAddressProcCallback set_gl_get_proc_address) {
   return false;
 }
 
 gfx::Size DriSurfaceFactory::GetWidgetSize(gfx::AcceleratedWidget w) {
   base::WeakPtr<HardwareDisplayController> controller =
@@ skipping 49 matching lines @@
       cursor_frontbuffer_ ^= 1;
     }
   } else {
     // No cursor set.
     if (controller)
       controller->UnsetCursor();
   }
 }
 
 }  // namespace ui