1 /*
2 * Copyright 2021 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 #include <android/gui/BnRegionSamplingListener.h>
17 #include <android/gui/BnSurfaceComposer.h>
18 #include <android/gui/BnSurfaceComposerClient.h>
19 #include <android/gui/IDisplayEventConnection.h>
20 #include <android/gui/ISurfaceComposerClient.h>
21 #include <fuzzer/FuzzedDataProvider.h>
22 #include <gmock/gmock.h>
23 #include <gui/BLASTBufferQueue.h>
24 #include <gui/DisplayEventDispatcher.h>
25 #include <gui/IGraphicBufferProducer.h>
26 #include <gui/LayerDebugInfo.h>
27 #include <gui/LayerState.h>
28 #include <gui/bufferqueue/1.0/H2BGraphicBufferProducer.h>
29 #include <gui/bufferqueue/2.0/H2BGraphicBufferProducer.h>
30 #include <ui/fuzzer/FuzzableDataspaces.h>
31
32 namespace android {
33
34 constexpr uint32_t kOrientation[] = {
35 ui::Transform::ROT_0, ui::Transform::FLIP_H, ui::Transform::FLIP_V,
36 ui::Transform::ROT_90, ui::Transform::ROT_180, ui::Transform::ROT_270,
37 };
38
getRect(FuzzedDataProvider * fdp)39 Rect getRect(FuzzedDataProvider* fdp) {
40 const int32_t left = fdp->ConsumeIntegral<int32_t>();
41 const int32_t top = fdp->ConsumeIntegral<int32_t>();
42 const int32_t right = fdp->ConsumeIntegral<int32_t>();
43 const int32_t bottom = fdp->ConsumeIntegral<int32_t>();
44 return Rect(left, top, right, bottom);
45 }
46
getBrightness(FuzzedDataProvider * fdp)47 gui::DisplayBrightness getBrightness(FuzzedDataProvider* fdp) {
48 static constexpr float kMinBrightness = 0;
49 static constexpr float kMaxBrightness = 1;
50 gui::DisplayBrightness brightness;
51 brightness.sdrWhitePoint =
52 fdp->ConsumeFloatingPointInRange<float>(kMinBrightness, kMaxBrightness);
53 brightness.sdrWhitePointNits =
54 fdp->ConsumeFloatingPointInRange<float>(kMinBrightness, kMaxBrightness);
55 brightness.displayBrightness =
56 fdp->ConsumeFloatingPointInRange<float>(kMinBrightness, kMaxBrightness);
57 brightness.displayBrightnessNits =
58 fdp->ConsumeFloatingPointInRange<float>(kMinBrightness, kMaxBrightness);
59 return brightness;
60 }
61
62 class FakeBnSurfaceComposer : public gui::BnSurfaceComposer {
63 public:
64 MOCK_METHOD(binder::Status, bootFinished, (), (override));
65 MOCK_METHOD(binder::Status, createDisplayEventConnection,
66 (gui::ISurfaceComposer::VsyncSource, gui::ISurfaceComposer::EventRegistration,
67 const sp<IBinder>& /*layerHandle*/, sp<gui::IDisplayEventConnection>*),
68 (override));
69 MOCK_METHOD(binder::Status, createConnection, (sp<gui::ISurfaceComposerClient>*), (override));
70 MOCK_METHOD(binder::Status, createDisplay, (const std::string&, bool, float, sp<IBinder>*),
71 (override));
72 MOCK_METHOD(binder::Status, destroyDisplay, (const sp<IBinder>&), (override));
73 MOCK_METHOD(binder::Status, getPhysicalDisplayIds, (std::vector<int64_t>*), (override));
74 MOCK_METHOD(binder::Status, getPhysicalDisplayToken, (int64_t, sp<IBinder>*), (override));
75 MOCK_METHOD(binder::Status, setPowerMode, (const sp<IBinder>&, int), (override));
76 MOCK_METHOD(binder::Status, getSupportedFrameTimestamps, (std::vector<FrameEvent>*),
77 (override));
78 MOCK_METHOD(binder::Status, getDisplayStats, (const sp<IBinder>&, gui::DisplayStatInfo*),
79 (override));
80 MOCK_METHOD(binder::Status, getDisplayState, (const sp<IBinder>&, gui::DisplayState*),
81 (override));
82 MOCK_METHOD(binder::Status, getStaticDisplayInfo, (int64_t, gui::StaticDisplayInfo*),
83 (override));
84 MOCK_METHOD(binder::Status, getDynamicDisplayInfoFromId, (int64_t, gui::DynamicDisplayInfo*),
85 (override));
86 MOCK_METHOD(binder::Status, getDynamicDisplayInfoFromToken,
87 (const sp<IBinder>&, gui::DynamicDisplayInfo*), (override));
88 MOCK_METHOD(binder::Status, getDisplayNativePrimaries,
89 (const sp<IBinder>&, gui::DisplayPrimaries*), (override));
90 MOCK_METHOD(binder::Status, setActiveColorMode, (const sp<IBinder>&, int), (override));
91 MOCK_METHOD(binder::Status, setBootDisplayMode, (const sp<IBinder>&, int), (override));
92 MOCK_METHOD(binder::Status, clearBootDisplayMode, (const sp<IBinder>&), (override));
93 MOCK_METHOD(binder::Status, getBootDisplayModeSupport, (bool*), (override));
94 MOCK_METHOD(binder::Status, getHdrConversionCapabilities,
95 (std::vector<gui::HdrConversionCapability>*), (override));
96 MOCK_METHOD(binder::Status, setHdrConversionStrategy,
97 (const gui::HdrConversionStrategy&, int32_t*), (override));
98 MOCK_METHOD(binder::Status, getHdrOutputConversionSupport, (bool*), (override));
99 MOCK_METHOD(binder::Status, setAutoLowLatencyMode, (const sp<IBinder>&, bool), (override));
100 MOCK_METHOD(binder::Status, setGameContentType, (const sp<IBinder>&, bool), (override));
101 MOCK_METHOD(binder::Status, captureDisplay,
102 (const DisplayCaptureArgs&, const sp<IScreenCaptureListener>&), (override));
103 MOCK_METHOD(binder::Status, captureDisplayById, (int64_t, const sp<IScreenCaptureListener>&),
104 (override));
105 MOCK_METHOD(binder::Status, captureLayers,
106 (const LayerCaptureArgs&, const sp<IScreenCaptureListener>&), (override));
107 MOCK_METHOD(binder::Status, clearAnimationFrameStats, (), (override));
108 MOCK_METHOD(binder::Status, getAnimationFrameStats, (gui::FrameStats*), (override));
109 MOCK_METHOD(binder::Status, overrideHdrTypes, (const sp<IBinder>&, const std::vector<int32_t>&),
110 (override));
111 MOCK_METHOD(binder::Status, onPullAtom, (int32_t, gui::PullAtomData*), (override));
112 MOCK_METHOD(binder::Status, getLayerDebugInfo, (std::vector<gui::LayerDebugInfo>*), (override));
113 MOCK_METHOD(binder::Status, getColorManagement, (bool*), (override));
114 MOCK_METHOD(binder::Status, getCompositionPreference, (gui::CompositionPreference*),
115 (override));
116 MOCK_METHOD(binder::Status, getDisplayedContentSamplingAttributes,
117 (const sp<IBinder>&, gui::ContentSamplingAttributes*), (override));
118 MOCK_METHOD(binder::Status, setDisplayContentSamplingEnabled,
119 (const sp<IBinder>&, bool, int8_t, int64_t), (override));
120 MOCK_METHOD(binder::Status, getDisplayedContentSample,
121 (const sp<IBinder>&, int64_t, int64_t, gui::DisplayedFrameStats*), (override));
122 MOCK_METHOD(binder::Status, getProtectedContentSupport, (bool*), (override));
123 MOCK_METHOD(binder::Status, isWideColorDisplay, (const sp<IBinder>&, bool*), (override));
124 MOCK_METHOD(binder::Status, addRegionSamplingListener,
125 (const gui::ARect&, const sp<IBinder>&, const sp<gui::IRegionSamplingListener>&),
126 (override));
127 MOCK_METHOD(binder::Status, removeRegionSamplingListener,
128 (const sp<gui::IRegionSamplingListener>&), (override));
129 MOCK_METHOD(binder::Status, addFpsListener, (int32_t, const sp<gui::IFpsListener>&),
130 (override));
131 MOCK_METHOD(binder::Status, removeFpsListener, (const sp<gui::IFpsListener>&), (override));
132 MOCK_METHOD(binder::Status, addTunnelModeEnabledListener,
133 (const sp<gui::ITunnelModeEnabledListener>&), (override));
134 MOCK_METHOD(binder::Status, removeTunnelModeEnabledListener,
135 (const sp<gui::ITunnelModeEnabledListener>&), (override));
136 MOCK_METHOD(binder::Status, setDesiredDisplayModeSpecs,
137 (const sp<IBinder>&, const gui::DisplayModeSpecs&), (override));
138 MOCK_METHOD(binder::Status, getDesiredDisplayModeSpecs,
139 (const sp<IBinder>&, gui::DisplayModeSpecs*), (override));
140 MOCK_METHOD(binder::Status, getDisplayBrightnessSupport, (const sp<IBinder>&, bool*),
141 (override));
142 MOCK_METHOD(binder::Status, setDisplayBrightness,
143 (const sp<IBinder>&, const gui::DisplayBrightness&), (override));
144 MOCK_METHOD(binder::Status, addHdrLayerInfoListener,
145 (const sp<IBinder>&, const sp<gui::IHdrLayerInfoListener>&), (override));
146 MOCK_METHOD(binder::Status, removeHdrLayerInfoListener,
147 (const sp<IBinder>&, const sp<gui::IHdrLayerInfoListener>&), (override));
148 MOCK_METHOD(binder::Status, notifyPowerBoost, (int), (override));
149 MOCK_METHOD(binder::Status, setGlobalShadowSettings,
150 (const gui::Color&, const gui::Color&, float, float, float), (override));
151 MOCK_METHOD(binder::Status, getDisplayDecorationSupport,
152 (const sp<IBinder>&, std::optional<gui::DisplayDecorationSupport>*), (override));
153 MOCK_METHOD(binder::Status, setOverrideFrameRate, (int32_t, float), (override));
154 MOCK_METHOD(binder::Status, updateSmallAreaDetection,
155 (const std::vector<int32_t>&, const std::vector<float>&), (override));
156 MOCK_METHOD(binder::Status, setSmallAreaDetectionThreshold, (int32_t, float), (override));
157 MOCK_METHOD(binder::Status, getGpuContextPriority, (int32_t*), (override));
158 MOCK_METHOD(binder::Status, getMaxAcquiredBufferCount, (int32_t*), (override));
159 MOCK_METHOD(binder::Status, addWindowInfosListener,
160 (const sp<gui::IWindowInfosListener>&, gui::WindowInfosListenerInfo*), (override));
161 MOCK_METHOD(binder::Status, removeWindowInfosListener, (const sp<gui::IWindowInfosListener>&),
162 (override));
163 MOCK_METHOD(binder::Status, getOverlaySupport, (gui::OverlayProperties*), (override));
164 MOCK_METHOD(binder::Status, getStalledTransactionInfo,
165 (int32_t, std::optional<gui::StalledTransactionInfo>*), (override));
166 };
167
168 class FakeBnSurfaceComposerClient : public gui::BnSurfaceComposerClient {
169 public:
170 MOCK_METHOD(binder::Status, createSurface,
171 (const std::string& name, int32_t flags, const sp<IBinder>& parent,
172 const gui::LayerMetadata& metadata, gui::CreateSurfaceResult* outResult),
173 (override));
174
175 MOCK_METHOD(binder::Status, clearLayerFrameStats, (const sp<IBinder>& handle), (override));
176
177 MOCK_METHOD(binder::Status, getLayerFrameStats,
178 (const sp<IBinder>& handle, gui::FrameStats* outStats), (override));
179
180 MOCK_METHOD(binder::Status, mirrorSurface,
181 (const sp<IBinder>& mirrorFromHandle, gui::CreateSurfaceResult* outResult),
182 (override));
183
184 MOCK_METHOD(binder::Status, mirrorDisplay,
185 (int64_t displayId, gui::CreateSurfaceResult* outResult), (override));
186 };
187
188 class FakeDisplayEventDispatcher : public DisplayEventDispatcher {
189 public:
FakeDisplayEventDispatcher(const sp<Looper> & looper,gui::ISurfaceComposer::VsyncSource vsyncSource,gui::ISurfaceComposer::EventRegistration eventRegistration)190 FakeDisplayEventDispatcher(const sp<Looper>& looper,
191 gui::ISurfaceComposer::VsyncSource vsyncSource,
192 gui::ISurfaceComposer::EventRegistration eventRegistration)
193 : DisplayEventDispatcher(looper, vsyncSource, eventRegistration){};
194
195 MOCK_METHOD4(dispatchVsync, void(nsecs_t, PhysicalDisplayId, uint32_t, VsyncEventData));
196 MOCK_METHOD3(dispatchHotplug, void(nsecs_t, PhysicalDisplayId, bool));
197 MOCK_METHOD4(dispatchModeChanged, void(nsecs_t, PhysicalDisplayId, int32_t, nsecs_t));
198 MOCK_METHOD2(dispatchNullEvent, void(nsecs_t, PhysicalDisplayId));
199 MOCK_METHOD3(dispatchFrameRateOverrides,
200 void(nsecs_t, PhysicalDisplayId, std::vector<FrameRateOverride>));
201 };
202
203 } // namespace android
204
205 namespace android::hardware {
206
207 namespace graphics::bufferqueue::V1_0::utils {
208
209 class FakeGraphicBufferProducerV1 : public HGraphicBufferProducer {
210 public:
FakeGraphicBufferProducerV1()211 FakeGraphicBufferProducerV1() {
212 ON_CALL(*this, setMaxDequeuedBufferCount).WillByDefault([]() { return 0; });
213 ON_CALL(*this, setAsyncMode).WillByDefault([]() { return 0; });
214 ON_CALL(*this, detachBuffer).WillByDefault([]() { return 0; });
215 ON_CALL(*this, cancelBuffer).WillByDefault([]() { return 0; });
216 ON_CALL(*this, disconnect).WillByDefault([]() { return 0; });
217 ON_CALL(*this, setSidebandStream).WillByDefault([]() { return 0; });
218 ON_CALL(*this, allowAllocation).WillByDefault([]() { return 0; });
219 ON_CALL(*this, setGenerationNumber).WillByDefault([]() { return 0; });
220 ON_CALL(*this, setSharedBufferMode).WillByDefault([]() { return 0; });
221 ON_CALL(*this, setAutoRefresh).WillByDefault([]() { return 0; });
222 ON_CALL(*this, setDequeueTimeout).WillByDefault([]() { return 0; });
223 ON_CALL(*this, setLegacyBufferDrop).WillByDefault([]() { return 0; });
224 };
225 MOCK_METHOD2(requestBuffer, Return<void>(int, requestBuffer_cb));
226 MOCK_METHOD1(setMaxDequeuedBufferCount, Return<int32_t>(int32_t));
227 MOCK_METHOD1(setAsyncMode, Return<int32_t>(bool));
228 MOCK_METHOD6(dequeueBuffer,
229 Return<void>(uint32_t, uint32_t, graphics::common::V1_0::PixelFormat, uint32_t,
230 bool, dequeueBuffer_cb));
231 MOCK_METHOD1(detachBuffer, Return<int32_t>(int));
232 MOCK_METHOD1(detachNextBuffer, Return<void>(detachNextBuffer_cb));
233 MOCK_METHOD2(attachBuffer, Return<void>(const media::V1_0::AnwBuffer&, attachBuffer_cb));
234 MOCK_METHOD3(
235 queueBuffer,
236 Return<void>(
237 int,
238 const graphics::bufferqueue::V1_0::IGraphicBufferProducer::QueueBufferInput&,
239 queueBuffer_cb));
240 MOCK_METHOD2(cancelBuffer, Return<int32_t>(int, const hidl_handle&));
241 MOCK_METHOD2(query, Return<void>(int32_t, query_cb));
242 MOCK_METHOD4(connect,
243 Return<void>(const sp<graphics::bufferqueue::V1_0::IProducerListener>&, int32_t,
244 bool, connect_cb));
245 MOCK_METHOD2(disconnect,
246 Return<int32_t>(
247 int, graphics::bufferqueue::V1_0::IGraphicBufferProducer::DisconnectMode));
248 MOCK_METHOD1(setSidebandStream, Return<int32_t>(const hidl_handle&));
249 MOCK_METHOD4(allocateBuffers,
250 Return<void>(uint32_t, uint32_t, graphics::common::V1_0::PixelFormat, uint32_t));
251 MOCK_METHOD1(allowAllocation, Return<int32_t>(bool));
252 MOCK_METHOD1(setGenerationNumber, Return<int32_t>(uint32_t));
253 MOCK_METHOD1(getConsumerName, Return<void>(getConsumerName_cb));
254 MOCK_METHOD1(setSharedBufferMode, Return<int32_t>(bool));
255 MOCK_METHOD1(setAutoRefresh, Return<int32_t>(bool));
256 MOCK_METHOD1(setDequeueTimeout, Return<int32_t>(nsecs_t));
257 MOCK_METHOD1(setLegacyBufferDrop, Return<int32_t>(bool));
258 MOCK_METHOD1(getLastQueuedBuffer, Return<void>(getLastQueuedBuffer_cb));
259 MOCK_METHOD1(getFrameTimestamps, Return<void>(getFrameTimestamps_cb));
260 MOCK_METHOD1(getUniqueId, Return<void>(getUniqueId_cb));
261 };
262
263 }; // namespace graphics::bufferqueue::V1_0::utils
264
265 namespace graphics::bufferqueue::V2_0::utils {
266
267 class FakeGraphicBufferProducerV2 : public HGraphicBufferProducer {
268 public:
FakeGraphicBufferProducerV2()269 FakeGraphicBufferProducerV2() {
270 ON_CALL(*this, setMaxDequeuedBufferCount).WillByDefault([]() { return Status::OK; });
271 ON_CALL(*this, setAsyncMode).WillByDefault([]() { return Status::OK; });
272 ON_CALL(*this, detachBuffer).WillByDefault([]() { return Status::OK; });
273 ON_CALL(*this, cancelBuffer).WillByDefault([]() { return Status::OK; });
274 ON_CALL(*this, disconnect).WillByDefault([]() { return Status::OK; });
275 ON_CALL(*this, allocateBuffers).WillByDefault([]() { return Status::OK; });
276 ON_CALL(*this, allowAllocation).WillByDefault([]() { return Status::OK; });
277 ON_CALL(*this, setGenerationNumber).WillByDefault([]() { return Status::OK; });
278 ON_CALL(*this, setDequeueTimeout).WillByDefault([]() { return Status::OK; });
279 ON_CALL(*this, getUniqueId).WillByDefault([]() { return 0; });
280 };
281 MOCK_METHOD2(requestBuffer, Return<void>(int, requestBuffer_cb));
282 MOCK_METHOD1(setMaxDequeuedBufferCount, Return<graphics::bufferqueue::V2_0::Status>(int));
283 MOCK_METHOD1(setAsyncMode, Return<graphics::bufferqueue::V2_0::Status>(bool));
284 MOCK_METHOD2(
285 dequeueBuffer,
286 Return<void>(
287 const graphics::bufferqueue::V2_0::IGraphicBufferProducer::DequeueBufferInput&,
288 dequeueBuffer_cb));
289 MOCK_METHOD1(detachBuffer, Return<graphics::bufferqueue::V2_0::Status>(int));
290 MOCK_METHOD1(detachNextBuffer, Return<void>(detachNextBuffer_cb));
291 MOCK_METHOD3(attachBuffer,
292 Return<void>(const graphics::common::V1_2::HardwareBuffer&, uint32_t,
293 attachBuffer_cb));
294 MOCK_METHOD3(
295 queueBuffer,
296 Return<void>(
297 int,
298 const graphics::bufferqueue::V2_0::IGraphicBufferProducer::QueueBufferInput&,
299 queueBuffer_cb));
300 MOCK_METHOD2(cancelBuffer,
301 Return<graphics::bufferqueue::V2_0::Status>(int, const hidl_handle&));
302 MOCK_METHOD2(query, Return<void>(int32_t, query_cb));
303 MOCK_METHOD4(connect,
304 Return<void>(const sp<graphics::bufferqueue::V2_0::IProducerListener>&,
305 graphics::bufferqueue::V2_0::ConnectionType, bool, connect_cb));
306 MOCK_METHOD1(disconnect,
307 Return<graphics::bufferqueue::V2_0::Status>(
308 graphics::bufferqueue::V2_0::ConnectionType));
309 MOCK_METHOD4(allocateBuffers,
310 Return<graphics::bufferqueue::V2_0::Status>(uint32_t, uint32_t, uint32_t,
311 uint64_t));
312 MOCK_METHOD1(allowAllocation, Return<graphics::bufferqueue::V2_0::Status>(bool));
313 MOCK_METHOD1(setGenerationNumber, Return<graphics::bufferqueue::V2_0::Status>(uint32_t));
314 MOCK_METHOD1(getConsumerName, Return<void>(getConsumerName_cb));
315 MOCK_METHOD1(setDequeueTimeout, Return<graphics::bufferqueue::V2_0::Status>(int64_t));
316 MOCK_METHOD0(getUniqueId, Return<uint64_t>());
317 };
318
319 }; // namespace graphics::bufferqueue::V2_0::utils
320 }; // namespace android::hardware
321