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
141
142
143
144
145
146
147
148
149
150
151
|
// 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.
#ifndef UI_OZONE_PLATFORM_DRM_GPU_MOCK_DRM_DEVICE_H_
#define UI_OZONE_PLATFORM_DRM_GPU_MOCK_DRM_DEVICE_H_
#include <stddef.h>
#include <stdint.h>
#include <map>
#include <queue>
#include <vector>
#include "base/macros.h"
#include "skia/ext/refptr.h"
#include "third_party/skia/include/core/SkSurface.h"
#include "ui/ozone/platform/drm/gpu/drm_device.h"
namespace ui {
// The real DrmDevice makes actual DRM calls which we can't use in unit tests.
class MockDrmDevice : public DrmDevice {
public:
MockDrmDevice();
MockDrmDevice(bool use_sync_flips,
std::vector<uint32_t> crtcs,
size_t planes_per_crtc);
int get_get_crtc_call_count() const { return get_crtc_call_count_; }
int get_set_crtc_call_count() const { return set_crtc_call_count_; }
int get_restore_crtc_call_count() const { return restore_crtc_call_count_; }
int get_add_framebuffer_call_count() const {
return add_framebuffer_call_count_;
}
int get_remove_framebuffer_call_count() const {
return remove_framebuffer_call_count_;
}
int get_page_flip_call_count() const { return page_flip_call_count_; }
int get_overlay_flip_call_count() const { return overlay_flip_call_count_; }
int get_overlay_clear_call_count() const { return overlay_clear_call_count_; }
void set_set_crtc_expectation(bool state) { set_crtc_expectation_ = state; }
void set_page_flip_expectation(bool state) { page_flip_expectation_ = state; }
void set_add_framebuffer_expectation(bool state) {
add_framebuffer_expectation_ = state;
}
void set_create_dumb_buffer_expectation(bool state) {
create_dumb_buffer_expectation_ = state;
}
uint32_t current_framebuffer() const { return current_framebuffer_; }
const std::vector<skia::RefPtr<SkSurface>> buffers() const {
return buffers_;
}
uint32_t get_cursor_handle_for_crtc(uint32_t crtc) const {
const auto it = crtc_cursor_map_.find(crtc);
return it != crtc_cursor_map_.end() ? it->second : 0;
}
void RunCallbacks();
// DrmDevice:
ScopedDrmCrtcPtr GetCrtc(uint32_t crtc_id) override;
bool SetCrtc(uint32_t crtc_id,
uint32_t framebuffer,
std::vector<uint32_t> connectors,
drmModeModeInfo* mode) override;
bool SetCrtc(drmModeCrtc* crtc, std::vector<uint32_t> connectors) override;
bool DisableCrtc(uint32_t crtc_id) override;
ScopedDrmConnectorPtr GetConnector(uint32_t connector_id) override;
bool AddFramebuffer2(uint32_t width,
uint32_t height,
uint32_t format,
uint32_t handles[4],
uint32_t strides[4],
uint32_t offsets[4],
uint32_t* framebuffer,
uint32_t flags) override;
bool RemoveFramebuffer(uint32_t framebuffer) override;
ScopedDrmFramebufferPtr GetFramebuffer(uint32_t framebuffer) override;
bool PageFlip(uint32_t crtc_id,
uint32_t framebuffer,
const PageFlipCallback& callback) override;
bool PageFlipOverlay(uint32_t crtc_id,
uint32_t framebuffer,
const gfx::Rect& location,
const gfx::Rect& source,
int overlay_plane) override;
ScopedDrmPropertyPtr GetProperty(drmModeConnector* connector,
const char* name) override;
bool SetProperty(uint32_t connector_id,
uint32_t property_id,
uint64_t value) override;
bool GetCapability(uint64_t capability, uint64_t* value) override;
ScopedDrmPropertyBlobPtr GetPropertyBlob(drmModeConnector* connector,
const char* name) override;
bool SetCursor(uint32_t crtc_id,
uint32_t handle,
const gfx::Size& size) override;
bool MoveCursor(uint32_t crtc_id, const gfx::Point& point) override;
bool CreateDumbBuffer(const SkImageInfo& info,
uint32_t* handle,
uint32_t* stride) override;
bool DestroyDumbBuffer(uint32_t handle) override;
bool MapDumbBuffer(uint32_t handle, size_t size, void** pixels) override;
bool UnmapDumbBuffer(void* pixels, size_t size) override;
bool CloseBufferHandle(uint32_t handle) override;
bool CommitProperties(drmModeAtomicReq* properties,
uint32_t flags,
uint32_t crtc_count,
const PageFlipCallback& callback) override;
bool SetGammaRamp(uint32_t crtc_id,
const std::vector<GammaRampRGBEntry>& lut) override;
bool SetCapability(uint64_t capability, uint64_t value) override;
private:
~MockDrmDevice() override;
int get_crtc_call_count_;
int set_crtc_call_count_;
int restore_crtc_call_count_;
int add_framebuffer_call_count_;
int remove_framebuffer_call_count_;
int page_flip_call_count_;
int overlay_flip_call_count_;
int overlay_clear_call_count_;
int allocate_buffer_count_;
bool set_crtc_expectation_;
bool add_framebuffer_expectation_;
bool page_flip_expectation_;
bool create_dumb_buffer_expectation_;
bool use_sync_flips_;
uint32_t current_framebuffer_;
std::vector<skia::RefPtr<SkSurface>> buffers_;
std::map<uint32_t, uint32_t> crtc_cursor_map_;
std::queue<PageFlipCallback> callbacks_;
DISALLOW_COPY_AND_ASSIGN(MockDrmDevice);
};
} // namespace ui
#endif // UI_OZONE_PLATFORM_DRM_GPU_MOCK_DRM_DEVICE_H_
|
