ozone: Add OzoneSurface object that is owned by compositor, GLSurface

ui/gfx/ozone/dri/dri_surface_factory.cc

 // Copyright 2013 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/gfx/ozone/dri/dri_surface_factory.h"
 
 #include <drm.h>
 #include <errno.h>
 #include <xf86drm.h>
 
 #include "base/message_loop/message_loop.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkDevice.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/ozone/dri/dri_skbitmap.h"
 #include "ui/gfx/ozone/dri/dri_surface.h"
 #include "ui/gfx/ozone/dri/dri_vsync_provider.h"
 #include "ui/gfx/ozone/dri/dri_wrapper.h"
 #include "ui/gfx/ozone/dri/hardware_display_controller.h"
+#include "ui/gfx/ozone/surface_ozone.h"
 
 namespace gfx {
 
 namespace {
 
 const char kDefaultGraphicsCardPath[] = "/dev/dri/card0";
 const char kDPMSProperty[] = "DPMS";
 
 const gfx::AcceleratedWidget kDefaultWidgetHandle = 1;
 
@@ skipping 77 matching lines @@
   SkCanvas* canvas = cursor->GetDrawableForWidget();
   canvas->clear(SK_ColorTRANSPARENT);
 
   SkRect clip;
   clip.set(
       0, 0, canvas->getDeviceSize().width(), canvas->getDeviceSize().height());
   canvas->clipRect(clip, SkRegion::kReplace_Op);
   canvas->drawBitmapRectToRect(image, &damage, damage);
 }
 
+// Adapter from SurfaceOzone to DriSurfaceFactory
+//
+// This class is derived from SurfaceOzone and owned by the compositor.
+//
+// For DRI the hadware surface & canvas are owned by the platform, so
+// the compositor merely owns this proxy object.
+//
+// TODO(spang): Should the compositor own any bits of the DriSurface?
+class DriSurfaceAdapter : public SurfaceOzone {
+ public:
+  DriSurfaceAdapter(gfx::AcceleratedWidget w, DriSurfaceFactory* dri)
+      : widget_(w), dri_(dri) {}
+  virtual ~DriSurfaceAdapter() {}
+
+  // SurfaceOzone:
+  virtual bool InitializeCanvas() OVERRIDE { return true; }
+  virtual skia::RefPtr<SkCanvas> GetCanvas() OVERRIDE {
+    return skia::SharePtr(dri_->GetCanvasForWidget(widget_));
+  }
+  virtual bool PresentCanvas() OVERRIDE {
+    return dri_->SchedulePageFlip(widget_);
+  }
+  virtual scoped_ptr<gfx::VSyncProvider> CreateVSyncProvider() OVERRIDE {
+    return dri_->CreateVSyncProvider(widget_);
+  }
+
+ private:
+  gfx::AcceleratedWidget widget_;
+  DriSurfaceFactory* dri_;
+};
+
 }  // namespace
 
 DriSurfaceFactory::DriSurfaceFactory()
     : drm_(),
       state_(UNINITIALIZED),
       controller_() {
 }
 
 DriSurfaceFactory::~DriSurfaceFactory() {
   if (state_ == INITIALIZED)
@@ skipping 42 matching lines @@
   // For now just assume we have 1 display device and return it.
   if (!controller_.get())
     controller_.reset(new HardwareDisplayController());
 
   // TODO(dnicoara) We only have 1 display for now, so only 1 AcceleratedWidget.
   // When we'll support multiple displays this needs to be changed to return a
   // different handle for every display.
   return kDefaultWidgetHandle;
 }
 
-gfx::AcceleratedWidget DriSurfaceFactory::RealizeAcceleratedWidget(
+scoped_ptr<SurfaceOzone> DriSurfaceFactory::CreateSurfaceForWidget(
     gfx::AcceleratedWidget w) {
   CHECK(state_ == INITIALIZED);
   // TODO(dnicoara) Once we can handle multiple displays this needs to be
   // changed.
   CHECK(w == kDefaultWidgetHandle);
 
   CHECK(controller_->get_state() ==
         HardwareDisplayController::UNASSOCIATED);
 
   // Until now the controller is just a stub. Initializing it will link it to a
   // hardware display.
   if (!InitializeControllerForPrimaryDisplay(drm_.get(), controller_.get())) {
     LOG(ERROR) << "Failed to initialize controller";
-    return gfx::kNullAcceleratedWidget;
+    return scoped_ptr<SurfaceOzone>();
   }
 
   // Create a surface suitable for the current controller.
   scoped_ptr<DriSurface> surface(CreateSurface(
       Size(controller_->get_mode().hdisplay,
            controller_->get_mode().vdisplay)));
 
   if (!surface->Initialize()) {
     LOG(ERROR) << "Failed to initialize surface";
-    return gfx::kNullAcceleratedWidget;
+    return scoped_ptr<SurfaceOzone>();
   }
 
   // Bind the surface to the controller. This will register the backing buffers
   // with the hardware CRTC such that we can show the buffers. The controller
   // takes ownership of the surface.
   if (!controller_->BindSurfaceToController(surface.Pass())) {
     LOG(ERROR) << "Failed to bind surface to controller";
-    return gfx::kNullAcceleratedWidget;
+    return scoped_ptr<SurfaceOzone>();
   }
 
-  return reinterpret_cast<gfx::AcceleratedWidget>(controller_->get_surface());
+  return make_scoped_ptr<SurfaceOzone>(new DriSurfaceAdapter(w, this));
 }
 
 bool DriSurfaceFactory::LoadEGLGLES2Bindings(
       AddGLLibraryCallback add_gl_library,
       SetGLGetProcAddressProcCallback set_gl_get_proc_address) {
   return false;
 }
 
-bool DriSurfaceFactory::AttemptToResizeAcceleratedWidget(
-    gfx::AcceleratedWidget w,
-    const gfx::Rect& bounds) {
-  return false;
-}
-
 bool DriSurfaceFactory::SchedulePageFlip(gfx::AcceleratedWidget w) {
   CHECK(state_ == INITIALIZED);
   // TODO(dnicoara) Change this CHECK once we're running with the threaded
   // compositor.
   CHECK(base::MessageLoopForUI::IsCurrent());
 
   // TODO(dnicoara) Once we can handle multiple displays this needs to be
   // changed.
   CHECK(w == kDefaultWidgetHandle);
 
@@ skipping 15 matching lines @@
   // Note that the following call does not use any locks, so it is safe to be
   // made on the UI thread (thought not ideal).
   WaitForPageFlipEvent(drm_->get_fd());
 
   return true;
 }
 
 SkCanvas* DriSurfaceFactory::GetCanvasForWidget(
     gfx::AcceleratedWidget w) {
   CHECK(state_ == INITIALIZED);
-  return reinterpret_cast<DriSurface*>(w)->GetDrawableForWidget();
+  CHECK_EQ(kDefaultWidgetHandle, w);
+  return controller_->get_surface()->GetDrawableForWidget();
 }
 
 scoped_ptr<gfx::VSyncProvider> DriSurfaceFactory::CreateVSyncProvider(
     gfx::AcceleratedWidget w) {
   CHECK(state_ == INITIALIZED);
   return scoped_ptr<VSyncProvider>(new DriVSyncProvider(controller_.get()));
 }
 
 void DriSurfaceFactory::SetHardwareCursor(gfx::AcceleratedWidget window,
                                           const SkBitmap& image,
@@ skipping 86 matching lines @@
   drmEventContext drm_event;
   drm_event.version = DRM_EVENT_CONTEXT_VERSION;
   drm_event.page_flip_handler = HandlePageFlipEvent;
   drm_event.vblank_handler = NULL;
 
   // Wait for the page-flip to complete.
   drmHandleEvent(fd, &drm_event);
 }
 
 }  // namespace gfx