Switch DRM platform to using a separate thread

ui/ozone/platform/drm/gpu/drm_thread.h

+// Copyright 2015 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_DRM_GPU_DRM_THREAD_H_
+#define UI_OZONE_PLATFORM_DRM_GPU_DRM_THREAD_H_
+
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
+#include "base/threading/thread.h"
+#include "ui/gfx/native_widget_types.h"
+#include "ui/gfx/vsync_provider.h"
+#include "ui/ozone/common/gpu/ozone_gpu_message_params.h"
+#include "ui/ozone/public/surface_ozone_egl.h"
+
+namespace base {
+class FileDescriptor;
+}
+
+namespace gfx {
+class Point;
+class Rect;
+}
+
+namespace ui {
+
+class DrmDeviceManager;
+class DrmGpuDisplayManager;
+class DrmWindow;
+class DrmWindowProxy;
+class ScanoutBufferGenerator;
+class ScreenManager;
+
+struct GammaRampRGBEntry;
+struct OverlayPlane;
+
+// Holds all the DRM related state and performs all DRM related operations with
+// the exception of buffer allocations which happen on the threads requiring the
+// allocations.
+//
+// The DRM thread is used to insulate DRM operations from potential blocking
+// behaviour on the GPU main thread in order to reduce the potential for jank
+// (for example jank in the cursor if the GPU main thread is performing heavy
+// operations). The inverse is also true as blocking operations on the DRM
+// thread (such as modesetting) no longer block the GPU main thread.
+class DrmThread : public base::Thread {
+ public:
+  DrmThread();
+  ~DrmThread() override;
+
+  void Start();
+
+  // Safe to use from any thread. Access to the device manager is direct since
+  // the device manager performs its own locking since buffer allocations need
+  // to happen on the main GPU thread and on the IO GPU thread without waiting.
+  DrmDeviceManager* device_manager() const { return device_manager_.get(); }
+
+  // Must be called on the DRM thread.
+  void SchedulePageFlip(gfx::AcceleratedWidget widget,
+                        const std::vector<OverlayPlane>& planes,
+                        const SwapCompletionCallback& callback);
+  void GetVSyncParameters(
+      gfx::AcceleratedWidget widget,
+      const gfx::VSyncProvider::UpdateVSyncCallback& callback);
+
+  void CreateWindow(gfx::AcceleratedWidget widget);
+  void DestroyWindow(gfx::AcceleratedWidget widget);
+  void WindowBoundsChanged(gfx::AcceleratedWidget widget,
+                           const gfx::Rect& bounds);
+  void CursorSet(gfx::AcceleratedWidget widget,
+                 const std::vector<SkBitmap>& bitmaps,
+                 const gfx::Point& location,
+                 int frame_delay_ms);
+  void CursorMove(gfx::AcceleratedWidget widget, const gfx::Point& location);
+  void CheckOverlayCapabilities(
+      gfx::AcceleratedWidget widget,
+      const std::vector<OverlayCheck_Params>& overlays,
+      const base::Callback<void(gfx::AcceleratedWidget, bool)>& callback);
+  void RefreshNativeDisplays(
+      const base::Callback<void(const std::vector<DisplaySnapshot_Params>&)>&
+          callback);
+  void ConfigureNativeDisplay(
+      int64_t id,
+      const DisplayMode_Params& mode,
+      const gfx::Point& origin,
+      const base::Callback<void(int64_t, bool)>& callback);
+  void DisableNativeDisplay(
+      int64_t id,
+      const base::Callback<void(int64_t, bool)>& callback);
+  void TakeDisplayControl(const base::Callback<void(bool)>& callback);
+  void RelinquishDisplayControl(const base::Callback<void(bool)>& callback);
+  void AddGraphicsDevice(const base::FilePath& path,
+                         const base::FileDescriptor& fd);
+  void RemoveGraphicsDevice(const base::FilePath& path);
+  void GetHDCPState(
+      int64_t display_id,
+      const base::Callback<void(int64_t, bool, HDCPState)>& callback);
+  void SetHDCPState(int64_t display_id,
+                    HDCPState state,
+                    const base::Callback<void(int64_t, bool)>& callback);
+  void SetGammaRamp(int64_t id, const std::vector<GammaRampRGBEntry>& lut);
+
+  // base::Thread:
+  void Init() override;
+
+ private:
+  scoped_ptr<DrmDeviceManager> device_manager_;
+  scoped_ptr<ScanoutBufferGenerator> buffer_generator_;
+  scoped_ptr<ScreenManager> screen_manager_;
+  scoped_ptr<DrmGpuDisplayManager> display_manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(DrmThread);
+};
+
+}  // namespace ui
+
+#endif  // UI_OZONE_PLATFORM_DRM_GPU_DRM_THREAD_H_