Switch DRM platform to using a separate thread

ui/ozone/platform/drm/gpu/gbm_buffer.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/drm/gpu/gbm_buffer.h"
 
 #include <drm.h>
 #include <fcntl.h>
 #include <gbm.h>
 #include <xf86drm.h>
 
 #include "base/logging.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/native_pixmap_handle_ozone.h"
+#include "ui/ozone/platform/drm/gpu/drm_thread.h"
 #include "ui/ozone/platform/drm/gpu/drm_window.h"
 #include "ui/ozone/platform/drm/gpu/gbm_device.h"
+#include "ui/ozone/platform/drm/gpu/proxy_helpers.h"
 
 namespace ui {
 
 namespace {
 
 int GetGbmFormatFromBufferFormat(gfx::BufferFormat fmt) {
   switch (fmt) {
     case gfx::BufferFormat::BGRA_8888:
       return GBM_FORMAT_ARGB8888;
     case gfx::BufferFormat::BGRX_8888:
@@ skipping 36 matching lines @@
     return nullptr;
 
   scoped_refptr<GbmBuffer> buffer(new GbmBuffer(gbm, bo, usage));
   if (use_scanout && !buffer->GetFramebufferId())
     return nullptr;
 
   return buffer;
 }
 
 GbmPixmap::GbmPixmap(const scoped_refptr<GbmBuffer>& buffer,
-                     ScreenManager* screen_manager)
-    : buffer_(buffer), screen_manager_(screen_manager) {
-}
+                     DrmThread* drm_thread)
+    : buffer_(buffer), drm_thread_(drm_thread) {}
 
 bool GbmPixmap::Initialize() {
   // We want to use the GBM API because it's going to call into libdrm
   // which might do some optimizations on buffer allocation,
   // especially when sharing buffers via DMABUF.
   dma_buf_ = gbm_bo_get_fd(buffer_->bo());
   if (dma_buf_ < 0) {
     PLOG(ERROR) << "Failed to export buffer to dma_buf";
     return false;
   }
@@ skipping 50 matching lines @@
       ShouldApplyScaling(display_bounds, crop_rect, &required_size)) {
     scoped_refptr<NativePixmap> scaled_pixmap = GetScaledPixmap(required_size);
     if (scaled_pixmap) {
       return scaled_pixmap->ScheduleOverlayPlane(
           widget, plane_z_order, plane_transform, display_bounds, crop_rect);
     } else {
       return false;
     }
   }
 
-  screen_manager_->GetWindow(widget)->QueueOverlayPlane(OverlayPlane(
-      buffer_, plane_z_order, plane_transform, display_bounds, crop_rect));
+  if (widget != cached_widget_) {
+    cached_widget_ = widget;
+    cached_window_ = drm_thread_->GetWindow(cached_widget_);

[spang, 2015/09/18 00:46:25]

How about:

(1) store window_id -> Surface map in GbmSurfaceFactory
(2) queue overlays on GbmSurfaceless
(3) send the whole stack in OnSwapBuffersAsync

It could be done as a preliminary step.

[dnicoara, 2015/09/18 17:43:08]

Acknowledged.

+  }
+
+  drm_thread_->task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&DrmWindow::QueueOverlayPlane, cached_window_,
+                 OverlayPlane(buffer_, plane_z_order, plane_transform,
+                              display_bounds, crop_rect)));
   return true;
 }
 
 bool GbmPixmap::ShouldApplyScaling(const gfx::Rect& display_bounds,
                                    const gfx::RectF& crop_rect,
                                    gfx::Size* required_size) {
   if (crop_rect.width() == 0 || crop_rect.height() == 0) {
     PLOG(ERROR) << "ShouldApplyScaling passed zero scaling target.";
     return false;
   }
 
   gfx::Size pixmap_size = buffer_->GetSize();
   // If the required size is not integer-sized, round it to the next integer.
   *required_size = gfx::ToCeiledSize(
       gfx::SizeF(display_bounds.width() / crop_rect.width(),
                  display_bounds.height() / crop_rect.height()));
   return pixmap_size != *required_size;
 }
 
 }  // namespace ui