[Ozone-DRI] Migrate cursor to using ScanoutBuffer

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"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkDevice.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "ui/gfx/native_widget_types.h"
+#include "ui/ozone/platform/dri/dri_buffer.h"
 #include "ui/ozone/platform/dri/dri_surface.h"
 #include "ui/ozone/platform/dri/dri_util.h"
 #include "ui/ozone/platform/dri/dri_vsync_provider.h"
 #include "ui/ozone/platform/dri/dri_wrapper.h"
 #include "ui/ozone/platform/dri/hardware_display_controller.h"
 #include "ui/ozone/platform/dri/screen_manager.h"
 #include "ui/ozone/public/surface_ozone_canvas.h"
 
 namespace ui {
 
 namespace {
 
 // TODO(dnicoara) Read the cursor plane size from the hardware.
 const gfx::Size kCursorSize(64, 64);
 
-void UpdateCursorImage(DriSurface* cursor, const SkBitmap& image) {
+void UpdateCursorImage(DriBuffer* cursor, const SkBitmap& image) {
   SkRect damage;
   image.getBounds(&damage);
 
   // Clear to transparent in case |image| is smaller than the canvas.
-  SkCanvas* canvas = cursor->GetDrawableForWidget();
+  SkCanvas* canvas = cursor->GetCanvas();
   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);
 }
 
 class DriSurfaceAdapter : public ui::SurfaceOzoneCanvas {
@@ skipping 67 matching lines @@
 }  // namespace
 
 // static
 const gfx::AcceleratedWidget DriSurfaceFactory::kDefaultWidgetHandle = 1;
 
 DriSurfaceFactory::DriSurfaceFactory(DriWrapper* drm,
                                      ScreenManager* screen_manager)
     : drm_(drm),
       screen_manager_(screen_manager),
       state_(UNINITIALIZED),
-      allocated_widgets_(0) {
+      allocated_widgets_(0),
+      cursor_frontbuffer_(0) {
 }
 
 DriSurfaceFactory::~DriSurfaceFactory() {
   if (state_ == INITIALIZED)
     ShutdownHardware();
 }
 
 ui::SurfaceFactoryOzone::HardwareState DriSurfaceFactory::InitializeHardware() {
   if (state_ != UNINITIALIZED)
     return state_;
 
   if (drm_->get_fd() < 0) {
     LOG(ERROR) << "Failed to create DRI connection";
     state_ = FAILED;
     return state_;
   }
 
-  cursor_surface_.reset(CreateSurface(kCursorSize));
-  if (!cursor_surface_->Initialize()) {
-    LOG(ERROR) << "Failed to initialize cursor surface";
-    state_ = FAILED;
-    return state_;
+  SkImageInfo info = SkImageInfo::MakeN32Premul(kCursorSize.width(),
+                                                kCursorSize.height());
+  for (size_t i = 0; i < arraysize(cursor_buffers_); ++i) {
+    cursor_buffers_[i] = new DriBuffer(drm_);

[alexst (slow to review), 2014/07/18 18:34:59]

nit: probably not a big deal, given things have to be really wrong for
initialization to fail, but we don't destroy the allocated buffers if
initialization fails.

[dnicoara, 2014/07/18 18:38:56]

SFO keeps track of them and since they're scoped_refptrs they'll get destroyed
when SFO does.

I felt that destroying them early doesn't buy us anything, just makes the code
more complicated.

+    if (!cursor_buffers_[i]->Initialize(info)) {
+      LOG(ERROR) << "Failed to initialize cursor buffer";
+      state_ = FAILED;
+      return state_;
+    }
   }
 
   state_ = INITIALIZED;
   return state_;
 }
 
 void DriSurfaceFactory::ShutdownHardware() {
   CHECK(state_ == INITIALIZED);
   state_ = UNINITIALIZED;
 }
@@ skipping 53 matching lines @@
 
   base::WeakPtr<HardwareDisplayController> controller =
       screen_manager_->GetDisplayController(window);
   if (controller)
     controller->MoveCursor(location);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DriSurfaceFactory private
 
-DriSurface* DriSurfaceFactory::CreateSurface(const gfx::Size& size) {
-  return new DriSurface(drm_, size);
-}
-
 void DriSurfaceFactory::ResetCursor(gfx::AcceleratedWidget w) {
   base::WeakPtr<HardwareDisplayController> controller =
       screen_manager_->GetDisplayController(w);
 
   if (!cursor_bitmap_.empty()) {
     // Draw new cursor into backbuffer.
-    UpdateCursorImage(cursor_surface_.get(), cursor_bitmap_);
+    UpdateCursorImage(cursor_buffers_[cursor_frontbuffer_ ^ 1].get(),
+                      cursor_bitmap_);
 
     // Reset location & buffer.
     if (controller) {
       controller->MoveCursor(cursor_location_);
-      controller->SetCursor(cursor_surface_.get());
+      controller->SetCursor(cursor_buffers_[cursor_frontbuffer_ ^ 1]);
+      cursor_frontbuffer_ ^= 1;
     }
   } else {
     // No cursor set.
     if (controller)
       controller->UnsetCursor();
   }
 }
 
 }  // namespace ui