Switch DRM platform to using a separate thread

ui/ozone/platform/drm/gpu/message_filter_proxy.cc

Index: ui/ozone/platform/drm/gpu/message_filter_proxy.cc
diff --git a/ui/ozone/platform/drm/gpu/message_filter_proxy.cc b/ui/ozone/platform/drm/gpu/message_filter_proxy.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e17b78f4ac198d0ad0886054ef2de2624e175d9f
--- /dev/null
+++ b/ui/ozone/platform/drm/gpu/message_filter_proxy.cc
@@ -0,0 +1,259 @@
+// 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.
+
+#include "ui/ozone/platform/drm/gpu/message_filter_proxy.h"
+
+#include "base/thread_task_runner_handle.h"
+#include "ipc/ipc_message.h"
+#include "ipc/ipc_sender.h"
+#include "ui/ozone/common/gpu/ozone_gpu_messages.h"
+#include "ui/ozone/platform/drm/gpu/drm_thread_proxy.h"
+#include "ui/ozone/platform/drm/gpu/proxy_helpers.h"
+
+namespace ui {
+
+MessageFilterProxy::MessageFilterProxy(DrmThread* drm_thread)
+    : drm_thread_(drm_thread), weak_ptr_factory_(this) {}
+
+MessageFilterProxy::~MessageFilterProxy() {}
+
+void MessageFilterProxy::OnFilterAdded(IPC::Sender* sender) {
+  sender_ = sender;
+
+  // The DRM thread needs to be started late since we need to wait for the
+  // sandbox to start.
+  drm_thread_->Start();
+}
+
+bool MessageFilterProxy::OnMessageReceived(const IPC::Message& message) {
+  bool handled = true;
+
+  IPC_BEGIN_MESSAGE_MAP(MessageFilterProxy, message)
+    IPC_MESSAGE_HANDLER(OzoneGpuMsg_CreateWindow, OnCreateWindow)
+    IPC_MESSAGE_HANDLER(OzoneGpuMsg_DestroyWindow, OnDestroyWindow)
+    IPC_MESSAGE_HANDLER(OzoneGpuMsg_WindowBoundsChanged, OnWindowBoundsChanged)
+
+    IPC_MESSAGE_HANDLER(OzoneGpuMsg_CursorSet, OnCursorSet)
+    IPC_MESSAGE_HANDLER(OzoneGpuMsg_CursorMove, OnCursorMove)
+
+    IPC_MESSAGE_HANDLER(OzoneGpuMsg_RefreshNativeDisplays,
+                        OnRefreshNativeDisplays)
+    IPC_MESSAGE_HANDLER(OzoneGpuMsg_ConfigureNativeDisplay,
+                        OnConfigureNativeDisplay)
+    IPC_MESSAGE_HANDLER(OzoneGpuMsg_DisableNativeDisplay,
+                        OnDisableNativeDisplay)
+    IPC_MESSAGE_HANDLER(OzoneGpuMsg_TakeDisplayControl, OnTakeDisplayControl)
+    IPC_MESSAGE_HANDLER(OzoneGpuMsg_RelinquishDisplayControl,
+                        OnRelinquishDisplayControl)
+    IPC_MESSAGE_HANDLER(OzoneGpuMsg_AddGraphicsDevice, OnAddGraphicsDevice)
+    IPC_MESSAGE_HANDLER(OzoneGpuMsg_RemoveGraphicsDevice,
+                        OnRemoveGraphicsDevice)
+    IPC_MESSAGE_HANDLER(OzoneGpuMsg_GetHDCPState, OnGetHDCPState)
+    IPC_MESSAGE_HANDLER(OzoneGpuMsg_SetHDCPState, OnSetHDCPState)
+    IPC_MESSAGE_HANDLER(OzoneGpuMsg_SetGammaRamp, OnSetGammaRamp);
+    IPC_MESSAGE_HANDLER(OzoneGpuMsg_CheckOverlayCapabilities,
+                        OnCheckOverlayCapabilities)
+    IPC_MESSAGE_UNHANDLED(handled = false);
+  IPC_END_MESSAGE_MAP()
+
+  return handled;
+}
+
+void MessageFilterProxy::OnCreateWindow(gfx::AcceleratedWidget widget) {
+  DCHECK(drm_thread_->IsRunning());
+  drm_thread_->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&DrmThread::CreateWindow,
+                            base::Unretained(drm_thread_), widget));
+}
+
+void MessageFilterProxy::OnDestroyWindow(gfx::AcceleratedWidget widget) {
+  DCHECK(drm_thread_->IsRunning());
+  drm_thread_->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&DrmThread::DestroyWindow,
+                            base::Unretained(drm_thread_), widget));
+}
+
+void MessageFilterProxy::OnWindowBoundsChanged(gfx::AcceleratedWidget widget,
+                                               const gfx::Rect& bounds) {
+  DCHECK(drm_thread_->IsRunning());
+  drm_thread_->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&DrmThread::WindowBoundsChanged,
+                            base::Unretained(drm_thread_), widget, bounds));
+}
+
+void MessageFilterProxy::OnCursorSet(gfx::AcceleratedWidget widget,
+                                     const std::vector<SkBitmap>& bitmaps,
+                                     const gfx::Point& location,
+                                     int frame_delay_ms) {
+  DCHECK(drm_thread_->IsRunning());
+  drm_thread_->task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&DrmThread::CursorSet, base::Unretained(drm_thread_), widget,
+                 bitmaps, location, frame_delay_ms));
+}
+
+void MessageFilterProxy::OnCursorMove(gfx::AcceleratedWidget widget,
+                                      const gfx::Point& location) {
+  DCHECK(drm_thread_->IsRunning());
+  drm_thread_->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&DrmThread::CursorMove,
+                            base::Unretained(drm_thread_), widget, location));
+}
+
+void MessageFilterProxy::OnCheckOverlayCapabilities(
+    gfx::AcceleratedWidget widget,
+    const std::vector<OverlayCheck_Params>& overlays) {
+  DCHECK(drm_thread_->IsRunning());
+  auto callback =
+      base::Bind(&MessageFilterProxy::OnCheckOverlayCapabilitiesCallback,
+                 weak_ptr_factory_.GetWeakPtr());
+  drm_thread_->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&DrmThread::CheckOverlayCapabilities,
+                            base::Unretained(drm_thread_), widget, overlays,
+                            CreateSafeCallback(callback)));
+}
+
+void MessageFilterProxy::OnRefreshNativeDisplays() {
+  DCHECK(drm_thread_->IsRunning());
+  auto callback =
+      base::Bind(&MessageFilterProxy::OnRefreshNativeDisplaysCallback,
+                 weak_ptr_factory_.GetWeakPtr());
+  drm_thread_->task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&DrmThread::RefreshNativeDisplays,
+                 base::Unretained(drm_thread_), CreateSafeCallback(callback)));
+}
+
+void MessageFilterProxy::OnConfigureNativeDisplay(
+    int64_t id,
+    const DisplayMode_Params& mode,
+    const gfx::Point& origin) {
+  DCHECK(drm_thread_->IsRunning());
+  auto callback =
+      base::Bind(&MessageFilterProxy::OnConfigureNativeDisplayCallback,
+                 weak_ptr_factory_.GetWeakPtr());
+  drm_thread_->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&DrmThread::ConfigureNativeDisplay,
+                            base::Unretained(drm_thread_), id, mode, origin,
+                            CreateSafeCallback(callback)));
+}
+
+void MessageFilterProxy::OnDisableNativeDisplay(int64_t id) {
+  DCHECK(drm_thread_->IsRunning());
+  auto callback =
+      base::Bind(&MessageFilterProxy::OnDisableNativeDisplayCallback,
+                 weak_ptr_factory_.GetWeakPtr());
+  drm_thread_->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&DrmThread::DisableNativeDisplay,
+                            base::Unretained(drm_thread_), id,
+                            CreateSafeCallback(callback)));
+}
+
+void MessageFilterProxy::OnTakeDisplayControl() {
+  DCHECK(drm_thread_->IsRunning());
+  auto callback = base::Bind(&MessageFilterProxy::OnTakeDisplayControlCallback,
+                             weak_ptr_factory_.GetWeakPtr());
+  drm_thread_->task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&DrmThread::TakeDisplayControl, base::Unretained(drm_thread_),
+                 CreateSafeCallback(callback)));
+}
+
+void MessageFilterProxy::OnRelinquishDisplayControl() {
+  DCHECK(drm_thread_->IsRunning());
+  auto callback =
+      base::Bind(&MessageFilterProxy::OnRelinquishDisplayControlCallback,
+                 weak_ptr_factory_.GetWeakPtr());
+  drm_thread_->task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&DrmThread::RelinquishDisplayControl,
+                 base::Unretained(drm_thread_), CreateSafeCallback(callback)));
+}
+
+void MessageFilterProxy::OnAddGraphicsDevice(const base::FilePath& path,
+                                             const base::FileDescriptor& fd) {
+  DCHECK(drm_thread_->IsRunning());
+  drm_thread_->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&DrmThread::AddGraphicsDevice,
+                            base::Unretained(drm_thread_), path, fd));
+}
+
+void MessageFilterProxy::OnRemoveGraphicsDevice(const base::FilePath& path) {
+  DCHECK(drm_thread_->IsRunning());
+  drm_thread_->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&DrmThread::RemoveGraphicsDevice,
+                            base::Unretained(drm_thread_), path));
+}
+
+void MessageFilterProxy::OnGetHDCPState(int64_t display_id) {
+  DCHECK(drm_thread_->IsRunning());
+  auto callback = base::Bind(&MessageFilterProxy::OnGetHDCPStateCallback,
+                             weak_ptr_factory_.GetWeakPtr());
+  drm_thread_->task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&DrmThread::GetHDCPState, base::Unretained(drm_thread_),
+                 display_id, CreateSafeCallback(callback)));
+}
+
+void MessageFilterProxy::OnSetHDCPState(int64_t display_id, HDCPState state) {
+  DCHECK(drm_thread_->IsRunning());
+  auto callback = base::Bind(&MessageFilterProxy::OnSetHDCPStateCallback,
+                             weak_ptr_factory_.GetWeakPtr());
+  drm_thread_->task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&DrmThread::SetHDCPState, base::Unretained(drm_thread_),
+                 display_id, state, CreateSafeCallback(callback)));
+}
+
+void MessageFilterProxy::OnSetGammaRamp(
+    int64_t id,
+    const std::vector<GammaRampRGBEntry>& lut) {
+  DCHECK(drm_thread_->IsRunning());
+  drm_thread_->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&DrmThread::SetGammaRamp,
+                            base::Unretained(drm_thread_), id, lut));
+}
+
+void MessageFilterProxy::OnCheckOverlayCapabilitiesCallback(
+    gfx::AcceleratedWidget widget,
+    bool success) const {
+  sender_->Send(new OzoneHostMsg_OverlayCapabilitiesReceived(widget, success));
+}
+
+void MessageFilterProxy::OnRefreshNativeDisplaysCallback(
+    const std::vector<DisplaySnapshot_Params>& displays) const {
+  sender_->Send(new OzoneHostMsg_UpdateNativeDisplays(displays));
+}
+
+void MessageFilterProxy::OnConfigureNativeDisplayCallback(int64_t display_id,
+                                                          bool success) const {
+  sender_->Send(new OzoneHostMsg_DisplayConfigured(display_id, success));
+}
+
+void MessageFilterProxy::OnDisableNativeDisplayCallback(int64_t display_id,
+                                                        bool success) const {
+  sender_->Send(new OzoneHostMsg_DisplayConfigured(display_id, success));
+}
+
+void MessageFilterProxy::OnTakeDisplayControlCallback(bool success) const {
+  sender_->Send(new OzoneHostMsg_DisplayControlTaken(success));
+}
+
+void MessageFilterProxy::OnRelinquishDisplayControlCallback(
+    bool success) const {
+  sender_->Send(new OzoneHostMsg_DisplayControlRelinquished(success));
+}
+
+void MessageFilterProxy::OnGetHDCPStateCallback(int64_t display_id,
+                                                bool success,
+                                                HDCPState state) const {
+  sender_->Send(new OzoneHostMsg_HDCPStateReceived(display_id, success, state));
+}
+
+void MessageFilterProxy::OnSetHDCPStateCallback(int64_t display_id,
+                                                bool success) const {
+  sender_->Send(new OzoneHostMsg_HDCPStateUpdated(display_id, success));
+}
+
+}  // namespace ui