1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
// Copyright 2016 The Chromium Authors
// 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_HOST_HOST_DRM_DEVICE_H_
#define UI_OZONE_PLATFORM_DRM_HOST_HOST_DRM_DEVICE_H_
#include <memory>
#include "base/functional/callback.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/observer_list.h"
#include "base/synchronization/lock.h"
#include "base/threading/thread_checker.h"
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "ui/gfx/native_widget_types.h"
#include "ui/ozone/platform/drm/common/display_types.h"
#include "ui/ozone/platform/drm/host/drm_cursor.h"
#include "ui/ozone/platform/drm/host/gpu_thread_adapter.h"
#include "ui/ozone/platform/drm/mojom/device_cursor.mojom.h"
#include "ui/ozone/platform/drm/mojom/drm_device.mojom.h"
#include "ui/ozone/public/gpu_platform_support_host.h"
namespace ui {
class DrmDisplayHostManager;
class GpuThreadObserver;
class DrmDeviceConnector;
class HostCursorProxy;
// This is the Viz host-side library for the DRM device service provided by the
// viz process.
class HostDrmDevice : public base::RefCountedThreadSafe<HostDrmDevice>,
public GpuThreadAdapter {
public:
explicit HostDrmDevice(DrmCursor* cursor);
HostDrmDevice(const HostDrmDevice&) = delete;
HostDrmDevice& operator=(const HostDrmDevice&) = delete;
void SetDisplayManager(DrmDisplayHostManager* display_manager);
void OnGpuServiceLaunched(
mojo::PendingRemote<ui::ozone::mojom::DrmDevice> drm_device);
// Invoked by DrmDeviceConnector on loss of GPU service.
void OnGpuServiceLost();
// GpuThreadAdapter
void AddGpuThreadObserver(GpuThreadObserver* observer) override;
void RemoveGpuThreadObserver(GpuThreadObserver* observer) override;
bool IsConnected() override;
// Services needed for DrmDisplayHostMananger.
void RegisterHandlerForDrmDisplayHostManager(
DrmDisplayHostManager* handler) override;
void UnRegisterHandlerForDrmDisplayHostManager() override;
bool GpuTakeDisplayControl() override;
bool GpuRefreshNativeDisplays() override;
bool GpuRelinquishDisplayControl() override;
void GpuAddGraphicsDevice(const base::FilePath& path,
base::ScopedFD fd) override;
bool GpuRemoveGraphicsDevice(const base::FilePath& path) override;
void GpuShouldDisplayEventTriggerConfiguration(
const EventPropertyMap& event_props) override;
// Services needed by DrmDisplayHost
void GpuConfigureNativeDisplays(
const std::vector<display::DisplayConfigurationParams>& config_requests,
display::ConfigureCallback callback,
display::ModesetFlags modeset_flags) override;
bool GpuSetHdcpKeyProp(int64_t display_id, const std::string& key) override;
bool GpuGetHDCPState(int64_t display_id) override;
bool GpuSetHDCPState(
int64_t display_id,
display::HDCPState state,
display::ContentProtectionMethod protection_method) override;
void GpuSetColorTemperatureAdjustment(
int64_t display_id,
const display::ColorTemperatureAdjustment& cta) override;
void GpuSetColorCalibration(
int64_t display_id,
const display::ColorCalibration& calibration) override;
void GpuSetGammaAdjustment(
int64_t display_id,
const display::GammaAdjustment& adjustment) override;
void GpuSetPrivacyScreen(int64_t display_id,
bool enabled,
display::SetPrivacyScreenCallback callback) override;
void GpuGetSeamlessRefreshRates(
int64_t display_id,
display::GetSeamlessRefreshRatesCallback callback) override;
// Services needed by DrmWindowHost
bool GpuDestroyWindow(gfx::AcceleratedWidget widget) override;
bool GpuCreateWindow(gfx::AcceleratedWidget widget,
const gfx::Rect& initial_bounds) override;
bool GpuWindowBoundsChanged(gfx::AcceleratedWidget widget,
const gfx::Rect& bounds) override;
private:
friend class base::RefCountedThreadSafe<HostDrmDevice>;
~HostDrmDevice() override;
void HostOnGpuServiceLaunched();
void OnDrmServiceStarted();
void GpuRefreshNativeDisplaysCallback(MovableDisplaySnapshots displays) const;
void GpuTakeDisplayControlCallback(bool success) const;
void GpuRelinquishDisplayControlCallback(bool success) const;
void GpuShouldDisplayEventTriggerConfigurationCallback(
bool should_trigger) const;
void GpuSetHdcpKeyPropCallback(int64_t display_id, bool success) const;
void GpuGetHDCPStateCallback(
int64_t display_id,
bool success,
display::HDCPState state,
display::ContentProtectionMethod protection_method) const;
void GpuSetHDCPStateCallback(int64_t display_id, bool success) const;
// Mojo implementation of the DrmDevice. Will be bound on the "main" thread.
mojo::Remote<ui::ozone::mojom::DrmDevice> drm_device_;
raw_ptr<DrmDisplayHostManager> display_manager_; // Not owned.
const raw_ptr<DrmCursor> cursor_; // Not owned.
std::unique_ptr<HostCursorProxy> cursor_proxy_;
THREAD_CHECKER(on_ui_thread_);
bool connected_ = false;
base::ObserverList<GpuThreadObserver>::Unchecked gpu_thread_observers_;
};
} // namespace ui
#endif // UI_OZONE_PLATFORM_DRM_HOST_HOST_DRM_DEVICE_H_
|
