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
17 #pragma once
18
19 #include <compositionengine/Display.h>
20 #include <compositionengine/LayerFECompositionState.h>
21 #include <compositionengine/OutputLayer.h>
22 #include <compositionengine/impl/CompositionEngine.h>
23 #include <compositionengine/impl/Display.h>
24 #include <compositionengine/impl/OutputLayerCompositionState.h>
25 #include <ftl/fake_guard.h>
26 #include <gui/LayerDebugInfo.h>
27 #include <gui/ScreenCaptureResults.h>
28 #include <gui/SurfaceComposerClient.h>
29 #include <gui/mock/GraphicBufferProducer.h>
30 #include <ui/DisplayStatInfo.h>
31 #include <ui/DynamicDisplayInfo.h>
32
33 #include "BufferQueueLayer.h"
34 #include "BufferStateLayer.h"
35 #include "ContainerLayer.h"
36 #include "DisplayDevice.h"
37 #include "DisplayHardware/ComposerHal.h"
38 #include "EffectLayer.h"
39 #include "FrameTimeline/FrameTimeline.h"
40 #include "FrameTracer/FrameTracer.h"
41 #include "Layer.h"
42 #include "NativeWindowSurface.h"
43 #include "Scheduler/EventThread.h"
44 #include "Scheduler/MessageQueue.h"
45 #include "Scheduler/RefreshRateConfigs.h"
46 #include "Scheduler/VSyncTracker.h"
47 #include "Scheduler/VsyncConfiguration.h"
48 #include "Scheduler/VsyncController.h"
49 #include "Scheduler/VsyncModulator.h"
50 #include "StartPropertySetThread.h"
51 #include "SurfaceFlinger.h"
52 #include "SurfaceFlingerDefaultFactory.h"
53 #include "SurfaceInterceptor.h"
54 #include "ThreadContext.h"
55 #include "TimeStats/TimeStats.h"
56
57 #include "renderengine/mock/RenderEngine.h"
58 #include "scheduler/TimeKeeper.h"
59 #include "tests/unittests/mock/DisplayHardware/MockComposer.h"
60 #include "tests/unittests/mock/DisplayHardware/MockDisplayMode.h"
61 #include "tests/unittests/mock/DisplayHardware/MockHWC2.h"
62 #include "tests/unittests/mock/DisplayHardware/MockPowerAdvisor.h"
63 #include "tests/unittests/mock/MockEventThread.h"
64 #include "tests/unittests/mock/MockFrameTimeline.h"
65 #include "tests/unittests/mock/MockFrameTracer.h"
66 #include "tests/unittests/mock/MockNativeWindowSurface.h"
67 #include "tests/unittests/mock/MockSurfaceInterceptor.h"
68 #include "tests/unittests/mock/MockTimeStats.h"
69 #include "tests/unittests/mock/MockVSyncTracker.h"
70 #include "tests/unittests/mock/MockVsyncController.h"
71
72 namespace android {
73 namespace Hwc2 {
74
75 class Composer;
76
77 namespace types = hardware::graphics::common;
78
79 namespace V2_1 = hardware::graphics::composer::V2_1;
80 namespace V2_2 = hardware::graphics::composer::V2_2;
81 namespace V2_3 = hardware::graphics::composer::V2_3;
82 namespace V2_4 = hardware::graphics::composer::V2_4;
83
84 using types::V1_0::ColorTransform;
85 using types::V1_0::Transform;
86 using types::V1_1::RenderIntent;
87 using types::V1_2::ColorMode;
88 using types::V1_2::Dataspace;
89 using types::V1_2::Hdr;
90 using types::V1_2::PixelFormat;
91
92 using V2_1::Config;
93 using V2_1::Display;
94 using V2_1::Error;
95 using V2_1::Layer;
96 using V2_4::CommandReaderBase;
97 using V2_4::CommandWriterBase;
98 using V2_4::IComposer;
99 using V2_4::IComposerCallback;
100 using V2_4::IComposerClient;
101 using V2_4::VsyncPeriodChangeTimeline;
102 using V2_4::VsyncPeriodNanos;
103 using DisplayCapability = IComposerClient::DisplayCapability;
104 using PerFrameMetadata = IComposerClient::PerFrameMetadata;
105 using PerFrameMetadataKey = IComposerClient::PerFrameMetadataKey;
106 using PerFrameMetadataBlob = IComposerClient::PerFrameMetadataBlob;
107 }; // namespace Hwc2
108
109 static constexpr hal::HWDisplayId kHwDisplayId = 1000;
110
111 static constexpr ui::Hdr kHdrTypes[] = {ui::Hdr::DOLBY_VISION, ui::Hdr::HDR10, ui::Hdr::HLG,
112 ui::Hdr::HDR10_PLUS};
113
114 static constexpr ui::ColorMode kColormodes[] = {ui::ColorMode::NATIVE,
115 ui::ColorMode::STANDARD_BT601_625,
116 ui::ColorMode::STANDARD_BT601_625_UNADJUSTED,
117 ui::ColorMode::STANDARD_BT601_525,
118 ui::ColorMode::STANDARD_BT601_525_UNADJUSTED,
119 ui::ColorMode::STANDARD_BT709,
120 ui::ColorMode::DCI_P3,
121 ui::ColorMode::SRGB,
122 ui::ColorMode::ADOBE_RGB,
123 ui::ColorMode::DISPLAY_P3,
124 ui::ColorMode::BT2020,
125 ui::ColorMode::BT2100_PQ,
126 ui::ColorMode::BT2100_HLG,
127 ui::ColorMode::DISPLAY_BT2020};
128
129 static constexpr ui::PixelFormat kPixelFormats[] = {ui::PixelFormat::RGBA_8888,
130 ui::PixelFormat::RGBX_8888,
131 ui::PixelFormat::RGB_888,
132 ui::PixelFormat::RGB_565,
133 ui::PixelFormat::BGRA_8888,
134 ui::PixelFormat::YCBCR_422_SP,
135 ui::PixelFormat::YCRCB_420_SP,
136 ui::PixelFormat::YCBCR_422_I,
137 ui::PixelFormat::RGBA_FP16,
138 ui::PixelFormat::RAW16,
139 ui::PixelFormat::BLOB,
140 ui::PixelFormat::IMPLEMENTATION_DEFINED,
141 ui::PixelFormat::YCBCR_420_888,
142 ui::PixelFormat::RAW_OPAQUE,
143 ui::PixelFormat::RAW10,
144 ui::PixelFormat::RAW12,
145 ui::PixelFormat::RGBA_1010102,
146 ui::PixelFormat::Y8,
147 ui::PixelFormat::Y16,
148 ui::PixelFormat::YV12,
149 ui::PixelFormat::DEPTH_16,
150 ui::PixelFormat::DEPTH_24,
151 ui::PixelFormat::DEPTH_24_STENCIL_8,
152 ui::PixelFormat::DEPTH_32F,
153 ui::PixelFormat::DEPTH_32F_STENCIL_8,
154 ui::PixelFormat::STENCIL_8,
155 ui::PixelFormat::YCBCR_P010,
156 ui::PixelFormat::HSV_888};
157
getFuzzedFloatRect(FuzzedDataProvider * fdp)158 FloatRect getFuzzedFloatRect(FuzzedDataProvider *fdp) {
159 return FloatRect(fdp->ConsumeFloatingPoint<float>() /*left*/,
160 fdp->ConsumeFloatingPoint<float>() /*right*/,
161 fdp->ConsumeFloatingPoint<float>() /*top*/,
162 fdp->ConsumeFloatingPoint<float>() /*bottom*/);
163 }
164
getFuzzedHdrMetadata(FuzzedDataProvider * fdp)165 HdrMetadata getFuzzedHdrMetadata(FuzzedDataProvider *fdp) {
166 HdrMetadata hdrMetadata;
167 if (fdp->ConsumeBool()) {
168 hdrMetadata.cta8613.maxContentLightLevel = fdp->ConsumeFloatingPoint<float>();
169 hdrMetadata.cta8613.maxFrameAverageLightLevel = fdp->ConsumeFloatingPoint<float>();
170
171 hdrMetadata.validTypes |= HdrMetadata::CTA861_3;
172 } else {
173 hdrMetadata.smpte2086.displayPrimaryRed.x = fdp->ConsumeFloatingPoint<float>();
174 hdrMetadata.smpte2086.displayPrimaryRed.y = fdp->ConsumeFloatingPoint<float>();
175 hdrMetadata.smpte2086.displayPrimaryGreen.x = fdp->ConsumeFloatingPoint<float>();
176 hdrMetadata.smpte2086.displayPrimaryGreen.y = fdp->ConsumeFloatingPoint<float>();
177 hdrMetadata.smpte2086.displayPrimaryBlue.x = fdp->ConsumeFloatingPoint<float>();
178 hdrMetadata.smpte2086.displayPrimaryBlue.y = fdp->ConsumeFloatingPoint<float>();
179 hdrMetadata.smpte2086.whitePoint.x = fdp->ConsumeFloatingPoint<float>();
180 hdrMetadata.smpte2086.whitePoint.y = fdp->ConsumeFloatingPoint<float>();
181 hdrMetadata.smpte2086.minLuminance = fdp->ConsumeFloatingPoint<float>();
182 hdrMetadata.smpte2086.maxLuminance = fdp->ConsumeFloatingPoint<float>();
183
184 hdrMetadata.validTypes |= HdrMetadata::SMPTE2086;
185 }
186 return hdrMetadata;
187 }
188
189 class EventThread;
190
191 namespace hal = android::hardware::graphics::composer::hal;
192
193 struct FakePhaseOffsets : scheduler::VsyncConfiguration {
194 static constexpr nsecs_t FAKE_PHASE_OFFSET_NS = 0;
195 static constexpr auto FAKE_DURATION_OFFSET_NS = std::chrono::nanoseconds(0);
196
getConfigsForRefreshRateFakePhaseOffsets197 VsyncConfigSet getConfigsForRefreshRate(Fps) const override { return getCurrentConfigs(); }
198
getCurrentConfigsFakePhaseOffsets199 VsyncConfigSet getCurrentConfigs() const override {
200 return {{FAKE_PHASE_OFFSET_NS, FAKE_PHASE_OFFSET_NS, FAKE_DURATION_OFFSET_NS,
201 FAKE_DURATION_OFFSET_NS},
202 {FAKE_PHASE_OFFSET_NS, FAKE_PHASE_OFFSET_NS, FAKE_DURATION_OFFSET_NS,
203 FAKE_DURATION_OFFSET_NS},
204 {FAKE_PHASE_OFFSET_NS, FAKE_PHASE_OFFSET_NS, FAKE_DURATION_OFFSET_NS,
205 FAKE_DURATION_OFFSET_NS},
206 FAKE_DURATION_OFFSET_NS};
207 }
208
resetFakePhaseOffsets209 void reset() override {}
setRefreshRateFpsFakePhaseOffsets210 void setRefreshRateFps(Fps) override {}
dumpFakePhaseOffsets211 void dump(std::string &) const override {}
212 };
213
214 namespace scheduler {
215
216 class TestableScheduler : public Scheduler, private ICompositor {
217 public:
TestableScheduler(const std::shared_ptr<scheduler::RefreshRateConfigs> & refreshRateConfigs,ISchedulerCallback & callback)218 TestableScheduler(const std::shared_ptr<scheduler::RefreshRateConfigs> &refreshRateConfigs,
219 ISchedulerCallback &callback)
220 : TestableScheduler(std::make_unique<android::mock::VsyncController>(),
221 std::make_unique<android::mock::VSyncTracker>(), refreshRateConfigs,
222 callback) {}
223
TestableScheduler(std::unique_ptr<VsyncController> controller,std::unique_ptr<VSyncTracker> tracker,std::shared_ptr<RefreshRateConfigs> configs,ISchedulerCallback & callback)224 TestableScheduler(std::unique_ptr<VsyncController> controller,
225 std::unique_ptr<VSyncTracker> tracker,
226 std::shared_ptr<RefreshRateConfigs> configs, ISchedulerCallback &callback)
227 : Scheduler(*this, callback, Feature::kContentDetection) {
228 mVsyncSchedule.emplace(VsyncSchedule(std::move(tracker), nullptr, std::move(controller)));
229 setRefreshRateConfigs(std::move(configs));
230 }
231
createConnection(std::unique_ptr<EventThread> eventThread)232 ConnectionHandle createConnection(std::unique_ptr<EventThread> eventThread) {
233 return Scheduler::createConnection(std::move(eventThread));
234 }
235
mutablePrimaryHWVsyncEnabled()236 auto &mutablePrimaryHWVsyncEnabled() { return mPrimaryHWVsyncEnabled; }
mutableHWVsyncAvailable()237 auto &mutableHWVsyncAvailable() { return mHWVsyncAvailable; }
238
mutableLayerHistory()239 auto &mutableLayerHistory() { return mLayerHistory; }
240
refreshRateConfigs()241 auto refreshRateConfigs() { return holdRefreshRateConfigs(); }
242
replaceTouchTimer(int64_t millis)243 void replaceTouchTimer(int64_t millis) {
244 if (mTouchTimer) {
245 mTouchTimer.reset();
246 }
247 mTouchTimer.emplace(
248 "Testable Touch timer", std::chrono::milliseconds(millis),
249 [this] { touchTimerCallback(TimerState::Reset); },
250 [this] { touchTimerCallback(TimerState::Expired); });
251 mTouchTimer->start();
252 }
253
isTouchActive()254 bool isTouchActive() {
255 std::lock_guard<std::mutex> lock(mPolicyLock);
256 return mPolicy.touch == Scheduler::TouchState::Active;
257 }
258
dispatchCachedReportedMode()259 void dispatchCachedReportedMode() {
260 std::lock_guard<std::mutex> lock(mPolicyLock);
261 return Scheduler::dispatchCachedReportedMode();
262 }
263
clearCachedReportedMode()264 void clearCachedReportedMode() {
265 std::lock_guard<std::mutex> lock(mPolicyLock);
266 mPolicy.cachedModeChangedParams.reset();
267 }
268
onNonPrimaryDisplayModeChanged(ConnectionHandle handle,DisplayModePtr mode)269 void onNonPrimaryDisplayModeChanged(ConnectionHandle handle, DisplayModePtr mode) {
270 return Scheduler::onNonPrimaryDisplayModeChanged(handle, mode);
271 }
272
273 private:
274 // ICompositor overrides:
commit(nsecs_t,int64_t,nsecs_t)275 bool commit(nsecs_t, int64_t, nsecs_t) override { return false; }
composite(nsecs_t,int64_t)276 void composite(nsecs_t, int64_t) override {}
sample()277 void sample() override {}
278
279 // MessageQueue overrides:
scheduleFrame()280 void scheduleFrame() override {}
postMessage(sp<MessageHandler> &&)281 void postMessage(sp<MessageHandler>&&) override {}
282 };
283
284 } // namespace scheduler
285
286 namespace surfaceflinger::test {
287
288 class Factory final : public surfaceflinger::Factory {
289 public:
290 ~Factory() = default;
291
createHWComposer(const std::string &)292 std::unique_ptr<HWComposer> createHWComposer(const std::string &) override { return nullptr; }
293
createMessageQueue(ICompositor & compositor)294 std::unique_ptr<MessageQueue> createMessageQueue(ICompositor &compositor) {
295 return std::make_unique<android::impl::MessageQueue>(compositor);
296 }
297
createVsyncConfiguration(Fps)298 std::unique_ptr<scheduler::VsyncConfiguration> createVsyncConfiguration(
299 Fps /*currentRefreshRate*/) override {
300 return std::make_unique<FakePhaseOffsets>();
301 }
302
createScheduler(const std::shared_ptr<scheduler::RefreshRateConfigs> &,scheduler::ISchedulerCallback &)303 std::unique_ptr<scheduler::Scheduler> createScheduler(
304 const std::shared_ptr<scheduler::RefreshRateConfigs> &,
305 scheduler::ISchedulerCallback &) {
306 return nullptr;
307 }
308
createSurfaceInterceptor()309 sp<SurfaceInterceptor> createSurfaceInterceptor() override {
310 return new android::impl::SurfaceInterceptor();
311 }
312
createStartPropertySetThread(bool timestampPropertyValue)313 sp<StartPropertySetThread> createStartPropertySetThread(bool timestampPropertyValue) override {
314 return new StartPropertySetThread(timestampPropertyValue);
315 }
316
createDisplayDevice(DisplayDeviceCreationArgs & creationArgs)317 sp<DisplayDevice> createDisplayDevice(DisplayDeviceCreationArgs &creationArgs) override {
318 return new DisplayDevice(creationArgs);
319 }
320
createGraphicBuffer(uint32_t width,uint32_t height,PixelFormat format,uint32_t layerCount,uint64_t usage,std::string requestorName)321 sp<GraphicBuffer> createGraphicBuffer(uint32_t width, uint32_t height, PixelFormat format,
322 uint32_t layerCount, uint64_t usage,
323 std::string requestorName) override {
324 return new GraphicBuffer(width, height, format, layerCount, usage, requestorName);
325 }
326
createBufferQueue(sp<IGraphicBufferProducer> * outProducer,sp<IGraphicBufferConsumer> * outConsumer,bool consumerIsSurfaceFlinger)327 void createBufferQueue(sp<IGraphicBufferProducer> *outProducer,
328 sp<IGraphicBufferConsumer> *outConsumer,
329 bool consumerIsSurfaceFlinger) override {
330 if (!mCreateBufferQueue) {
331 BufferQueue::createBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
332 return;
333 }
334 mCreateBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
335 }
336
createMonitoredProducer(const sp<IGraphicBufferProducer> & producer,const sp<SurfaceFlinger> & flinger,const wp<Layer> & layer)337 sp<IGraphicBufferProducer> createMonitoredProducer(const sp<IGraphicBufferProducer> &producer,
338 const sp<SurfaceFlinger> &flinger,
339 const wp<Layer> &layer) override {
340 return new MonitoredProducer(producer, flinger, layer);
341 }
342
createBufferLayerConsumer(const sp<IGraphicBufferConsumer> & consumer,renderengine::RenderEngine & renderEngine,uint32_t textureName,Layer * layer)343 sp<BufferLayerConsumer> createBufferLayerConsumer(const sp<IGraphicBufferConsumer> &consumer,
344 renderengine::RenderEngine &renderEngine,
345 uint32_t textureName, Layer *layer) override {
346 return new BufferLayerConsumer(consumer, renderEngine, textureName, layer);
347 }
348
createNativeWindowSurface(const sp<IGraphicBufferProducer> & producer)349 std::unique_ptr<surfaceflinger::NativeWindowSurface> createNativeWindowSurface(
350 const sp<IGraphicBufferProducer> &producer) override {
351 if (!mCreateNativeWindowSurface) return nullptr;
352 return mCreateNativeWindowSurface(producer);
353 }
354
createCompositionEngine()355 std::unique_ptr<compositionengine::CompositionEngine> createCompositionEngine() override {
356 return compositionengine::impl::createCompositionEngine();
357 }
358
createBufferQueueLayer(const LayerCreationArgs &)359 sp<BufferQueueLayer> createBufferQueueLayer(const LayerCreationArgs &) override {
360 return nullptr;
361 }
362
createBufferStateLayer(const LayerCreationArgs &)363 sp<BufferStateLayer> createBufferStateLayer(const LayerCreationArgs &) override {
364 return nullptr;
365 }
366
createEffectLayer(const LayerCreationArgs & args)367 sp<EffectLayer> createEffectLayer(const LayerCreationArgs &args) override {
368 return new EffectLayer(args);
369 }
370
createContainerLayer(const LayerCreationArgs & args)371 sp<ContainerLayer> createContainerLayer(const LayerCreationArgs &args) override {
372 return new ContainerLayer(args);
373 }
374
createFrameTracer()375 std::unique_ptr<FrameTracer> createFrameTracer() override {
376 return std::make_unique<android::mock::FrameTracer>();
377 }
378
379 std::unique_ptr<frametimeline::FrameTimeline> createFrameTimeline(
380 std::shared_ptr<TimeStats> timeStats, pid_t surfaceFlingerPid = 0) override {
381 return std::make_unique<android::mock::FrameTimeline>(timeStats, surfaceFlingerPid);
382 }
383
384 using CreateBufferQueueFunction =
385 std::function<void(sp<IGraphicBufferProducer> * /* outProducer */,
386 sp<IGraphicBufferConsumer> * /* outConsumer */,
387 bool /* consumerIsSurfaceFlinger */)>;
388 CreateBufferQueueFunction mCreateBufferQueue;
389
390 using CreateNativeWindowSurfaceFunction =
391 std::function<std::unique_ptr<surfaceflinger::NativeWindowSurface>(
392 const sp<IGraphicBufferProducer> &)>;
393 CreateNativeWindowSurfaceFunction mCreateNativeWindowSurface;
394
395 using CreateCompositionEngineFunction =
396 std::function<std::unique_ptr<compositionengine::CompositionEngine>()>;
397 CreateCompositionEngineFunction mCreateCompositionEngine;
398 };
399
400 } // namespace surfaceflinger::test
401
402 // TODO(b/189053744) : Create a common test/mock library for surfaceflinger
403 class TestableSurfaceFlinger final : private scheduler::ISchedulerCallback {
404 public:
405 using HotplugEvent = SurfaceFlinger::HotplugEvent;
406
flinger()407 SurfaceFlinger *flinger() { return mFlinger.get(); }
scheduler()408 scheduler::TestableScheduler *scheduler() { return mScheduler; }
409
410 // Allow reading display state without locking, as if called on the SF main thread.
onInitializeDisplays()411 auto onInitializeDisplays() NO_THREAD_SAFETY_ANALYSIS {
412 return mFlinger->onInitializeDisplays();
413 }
414
setGlobalShadowSettings(FuzzedDataProvider * fdp)415 void setGlobalShadowSettings(FuzzedDataProvider *fdp) {
416 const half4 ambientColor{fdp->ConsumeFloatingPoint<float>(),
417 fdp->ConsumeFloatingPoint<float>(),
418 fdp->ConsumeFloatingPoint<float>(),
419 fdp->ConsumeFloatingPoint<float>()};
420 const half4 spotColor{fdp->ConsumeFloatingPoint<float>(),
421 fdp->ConsumeFloatingPoint<float>(),
422 fdp->ConsumeFloatingPoint<float>(),
423 fdp->ConsumeFloatingPoint<float>()};
424 float lightPosY = fdp->ConsumeFloatingPoint<float>();
425 float lightPosZ = fdp->ConsumeFloatingPoint<float>();
426 float lightRadius = fdp->ConsumeFloatingPoint<float>();
427 mFlinger->setGlobalShadowSettings(ambientColor, spotColor, lightPosY, lightPosZ,
428 lightRadius);
429 }
430
onPullAtom(FuzzedDataProvider * fdp)431 void onPullAtom(FuzzedDataProvider *fdp) {
432 const int32_t atomId = fdp->ConsumeIntegral<uint8_t>();
433 std::string pulledData = fdp->ConsumeRandomLengthString().c_str();
434 bool success = fdp->ConsumeBool();
435 mFlinger->onPullAtom(atomId, &pulledData, &success);
436 }
437
fuzzDumpsysAndDebug(FuzzedDataProvider * fdp)438 void fuzzDumpsysAndDebug(FuzzedDataProvider *fdp) {
439 std::string result = fdp->ConsumeRandomLengthString().c_str();
440 mFlinger->appendSfConfigString(result);
441 result = fdp->ConsumeRandomLengthString().c_str();
442 mFlinger->listLayersLocked(result);
443
444 using DumpArgs = Vector<String16>;
445 DumpArgs dumpArgs;
446 dumpArgs.push_back(String16(fdp->ConsumeRandomLengthString().c_str()));
447 mFlinger->clearStatsLocked(dumpArgs, result);
448
449 mFlinger->dumpTimeStats(dumpArgs, fdp->ConsumeBool(), result);
450 FTL_FAKE_GUARD(kMainThreadContext, mFlinger->logFrameStats());
451
452 result = fdp->ConsumeRandomLengthString().c_str();
453 mFlinger->dumpFrameTimeline(dumpArgs, result);
454
455 result = fdp->ConsumeRandomLengthString().c_str();
456 mFlinger->dumpStaticScreenStats(result);
457
458 result = fdp->ConsumeRandomLengthString().c_str();
459 mFlinger->dumpRawDisplayIdentificationData(dumpArgs, result);
460
461 LayersProto layersProto = mFlinger->dumpDrawingStateProto(fdp->ConsumeIntegral<uint32_t>());
462 mFlinger->dumpOffscreenLayersProto(layersProto);
463 LayersTraceProto layersTraceProto{};
464 mFlinger->dumpDisplayProto(layersTraceProto);
465
466 result = fdp->ConsumeRandomLengthString().c_str();
467 mFlinger->dumpHwc(result);
468
469 mFlinger->calculateColorMatrix(fdp->ConsumeFloatingPoint<float>());
470 mFlinger->updateColorMatrixLocked();
471 mFlinger->CheckTransactCodeCredentials(fdp->ConsumeIntegral<uint32_t>());
472
473 const CountDownLatch transactionCommittedSignal(fdp->ConsumeIntegral<uint32_t>());
474 mFlinger->waitForSynchronousTransaction(transactionCommittedSignal);
475 mFlinger->signalSynchronousTransactions(fdp->ConsumeIntegral<uint32_t>());
476 }
477
getCompositionPreference()478 void getCompositionPreference() {
479 ui::Dataspace outDataspace;
480 ui::PixelFormat outPixelFormat;
481 ui::Dataspace outWideColorGamutDataspace;
482 ui::PixelFormat outWideColorGamutPixelFormat;
483 mFlinger->getCompositionPreference(&outDataspace, &outPixelFormat,
484 &outWideColorGamutDataspace,
485 &outWideColorGamutPixelFormat);
486 }
487
overrideHdrTypes(sp<IBinder> & display,FuzzedDataProvider * fdp)488 void overrideHdrTypes(sp<IBinder> &display, FuzzedDataProvider *fdp) {
489 std::vector<ui::Hdr> hdrTypes;
490 hdrTypes.push_back(fdp->PickValueInArray(kHdrTypes));
491 mFlinger->overrideHdrTypes(display, hdrTypes);
492 }
493
getDisplayedContentSample(sp<IBinder> & display,FuzzedDataProvider * fdp)494 void getDisplayedContentSample(sp<IBinder> &display, FuzzedDataProvider *fdp) {
495 DisplayedFrameStats outDisplayedFrameStats;
496 mFlinger->getDisplayedContentSample(display, fdp->ConsumeIntegral<uint64_t>(),
497 fdp->ConsumeIntegral<uint64_t>(),
498 &outDisplayedFrameStats);
499 }
500
getDisplayStats(sp<IBinder> & display)501 void getDisplayStats(sp<IBinder> &display) {
502 android::DisplayStatInfo stats;
503 mFlinger->getDisplayStats(display, &stats);
504 }
505
getDisplayState(sp<IBinder> & display)506 void getDisplayState(sp<IBinder> &display) {
507 ui::DisplayState displayState;
508 mFlinger->getDisplayState(display, &displayState);
509 }
510
getStaticDisplayInfo(sp<IBinder> & display)511 void getStaticDisplayInfo(sp<IBinder> &display) {
512 ui::StaticDisplayInfo staticDisplayInfo;
513 mFlinger->getStaticDisplayInfo(display, &staticDisplayInfo);
514 }
515
getDynamicDisplayInfo(sp<IBinder> & display)516 void getDynamicDisplayInfo(sp<IBinder> &display) {
517 android::ui::DynamicDisplayInfo dynamicDisplayInfo;
518 mFlinger->getDynamicDisplayInfo(display, &dynamicDisplayInfo);
519 }
getDisplayNativePrimaries(sp<IBinder> & display)520 void getDisplayNativePrimaries(sp<IBinder> &display) {
521 android::ui::DisplayPrimaries displayPrimaries;
522 mFlinger->getDisplayNativePrimaries(display, displayPrimaries);
523 }
524
getDesiredDisplayModeSpecs(sp<IBinder> & display)525 void getDesiredDisplayModeSpecs(sp<IBinder> &display) {
526 ui::DisplayModeId outDefaultMode;
527 bool outAllowGroupSwitching;
528 float outPrimaryRefreshRateMin;
529 float outPrimaryRefreshRateMax;
530 float outAppRequestRefreshRateMin;
531 float outAppRequestRefreshRateMax;
532 mFlinger->getDesiredDisplayModeSpecs(display, &outDefaultMode, &outAllowGroupSwitching,
533 &outPrimaryRefreshRateMin, &outPrimaryRefreshRateMax,
534 &outAppRequestRefreshRateMin,
535 &outAppRequestRefreshRateMax);
536 }
537
setVsyncConfig(FuzzedDataProvider * fdp)538 void setVsyncConfig(FuzzedDataProvider *fdp) {
539 const scheduler::VsyncModulator::VsyncConfig vsyncConfig{};
540 mFlinger->setVsyncConfig(vsyncConfig, fdp->ConsumeIntegral<nsecs_t>());
541 }
542
updateCompositorTiming(FuzzedDataProvider * fdp)543 void updateCompositorTiming(FuzzedDataProvider *fdp) {
544 std::shared_ptr<FenceTime> presentFenceTime = FenceTime::NO_FENCE;
545 mFlinger->updateCompositorTiming({}, fdp->ConsumeIntegral<nsecs_t>(), presentFenceTime);
546 }
547
getCompositorTiming()548 void getCompositorTiming() {
549 CompositorTiming compositorTiming;
550 mFlinger->getCompositorTiming(&compositorTiming);
551 }
552
fuzzBoot(FuzzedDataProvider * fdp)553 sp<IBinder> fuzzBoot(FuzzedDataProvider *fdp) {
554 mFlinger->callingThreadHasUnscopedSurfaceFlingerAccess(fdp->ConsumeBool());
555 mFlinger->createConnection();
556
557 DisplayIdGenerator<HalVirtualDisplayId> kGenerator;
558 HalVirtualDisplayId halVirtualDisplayId = kGenerator.generateId().value();
559
560 ui::Size uiSize{fdp->ConsumeIntegral<int32_t>(), fdp->ConsumeIntegral<int32_t>()};
561 ui::PixelFormat pixelFormat{};
562 mFlinger->getHwComposer().allocateVirtualDisplay(halVirtualDisplayId, uiSize, &pixelFormat);
563
564 PhysicalDisplayId physicalDisplayId = SurfaceComposerClient::getInternalDisplayId().value();
565 mFlinger->getHwComposer().allocatePhysicalDisplay(kHwDisplayId, physicalDisplayId);
566
567 sp<IBinder> display =
568 mFlinger->createDisplay(String8(fdp->ConsumeRandomLengthString().c_str()),
569 fdp->ConsumeBool());
570
571 onInitializeDisplays();
572 mFlinger->getPhysicalDisplayToken(physicalDisplayId);
573
574 mFlinger->mStartPropertySetThread =
575 mFlinger->getFactory().createStartPropertySetThread(fdp->ConsumeBool());
576
577 mFlinger->bootFinished();
578
579 return display;
580 }
581
fuzzSurfaceFlinger(const uint8_t * data,size_t size)582 void fuzzSurfaceFlinger(const uint8_t *data, size_t size) {
583 FuzzedDataProvider mFdp(data, size);
584
585 sp<IBinder> display = fuzzBoot(&mFdp);
586
587 sp<IGraphicBufferProducer> bufferProducer = sp<mock::GraphicBufferProducer>::make();
588 mFlinger->authenticateSurfaceTexture(bufferProducer.get());
589
590 mFlinger->createDisplayEventConnection();
591
592 getDisplayStats(display);
593 getDisplayState(display);
594 getStaticDisplayInfo(display);
595 getDynamicDisplayInfo(display);
596 getDisplayNativePrimaries(display);
597
598 mFlinger->setAutoLowLatencyMode(display, mFdp.ConsumeBool());
599 mFlinger->setGameContentType(display, mFdp.ConsumeBool());
600 mFlinger->setPowerMode(display, mFdp.ConsumeIntegral<int>());
601 mFlinger->clearAnimationFrameStats();
602
603 overrideHdrTypes(display, &mFdp);
604
605 onPullAtom(&mFdp);
606
607 mFlinger->injectVSync(mFdp.ConsumeIntegral<nsecs_t>());
608
609 getCompositionPreference();
610 getDisplayedContentSample(display, &mFdp);
611 getDesiredDisplayModeSpecs(display);
612
613 bool outSupport;
614 mFlinger->getDisplayBrightnessSupport(display, &outSupport);
615
616 mFlinger->notifyPowerBoost(mFdp.ConsumeIntegral<int32_t>());
617
618 setGlobalShadowSettings(&mFdp);
619
620 mFlinger->binderDied(display);
621 mFlinger->onFirstRef();
622
623 mFlinger->commitTransactions();
624 mFlinger->updateInputFlinger();
625 mFlinger->updateCursorAsync();
626
627 setVsyncConfig(&mFdp);
628
629 mFlinger->flushTransactionQueues(0);
630
631 mFlinger->setTransactionFlags(mFdp.ConsumeIntegral<uint32_t>());
632 mFlinger->clearTransactionFlags(mFdp.ConsumeIntegral<uint32_t>());
633 mFlinger->commitOffscreenLayers();
634
635 mFlinger->frameIsEarly(mFdp.ConsumeIntegral<nsecs_t>(), mFdp.ConsumeIntegral<int64_t>());
636 mFlinger->computeLayerBounds();
637 mFlinger->startBootAnim();
638
639 mFlinger->readPersistentProperties();
640
641 mFlinger->exceedsMaxRenderTargetSize(mFdp.ConsumeIntegral<uint32_t>(),
642 mFdp.ConsumeIntegral<uint32_t>());
643
644 mFlinger->getMaxAcquiredBufferCountForCurrentRefreshRate(mFdp.ConsumeIntegral<uid_t>());
645
646 mFlinger->postComposition();
647
648 getCompositorTiming();
649
650 updateCompositorTiming(&mFdp);
651
652 mFlinger->setCompositorTimingSnapped({}, mFdp.ConsumeIntegral<nsecs_t>());
653 FTL_FAKE_GUARD(kMainThreadContext, mFlinger->postFrame());
654 mFlinger->calculateExpectedPresentTime({});
655
656 mFlinger->enableHalVirtualDisplays(mFdp.ConsumeBool());
657
658 fuzzDumpsysAndDebug(&mFdp);
659
660 mFlinger->destroyDisplay(display);
661 }
662
setupRenderEngine(std::unique_ptr<renderengine::RenderEngine> renderEngine)663 void setupRenderEngine(std::unique_ptr<renderengine::RenderEngine> renderEngine) {
664 mFlinger->mCompositionEngine->setRenderEngine(std::move(renderEngine));
665 }
666
setupComposer(std::unique_ptr<Hwc2::Composer> composer)667 void setupComposer(std::unique_ptr<Hwc2::Composer> composer) {
668 mFlinger->mCompositionEngine->setHwComposer(
669 std::make_unique<impl::HWComposer>(std::move(composer)));
670 }
671
setupTimeStats(const std::shared_ptr<TimeStats> & timeStats)672 void setupTimeStats(const std::shared_ptr<TimeStats> &timeStats) {
673 mFlinger->mCompositionEngine->setTimeStats(timeStats);
674 }
675
676 // The ISchedulerCallback argument can be nullptr for a no-op implementation.
677 void setupScheduler(std::unique_ptr<scheduler::VsyncController> vsyncController,
678 std::unique_ptr<scheduler::VSyncTracker> vsyncTracker,
679 std::unique_ptr<EventThread> appEventThread,
680 std::unique_ptr<EventThread> sfEventThread,
681 scheduler::ISchedulerCallback *callback = nullptr,
682 bool hasMultipleModes = false) {
683 constexpr DisplayModeId kModeId60{0};
684 DisplayModes modes = makeModes(mock::createDisplayMode(kModeId60, 60_Hz));
685
686 if (hasMultipleModes) {
687 constexpr DisplayModeId kModeId90{1};
688 modes.try_emplace(kModeId90, mock::createDisplayMode(kModeId90, 90_Hz));
689 }
690
691 mRefreshRateConfigs = std::make_shared<scheduler::RefreshRateConfigs>(modes, kModeId60);
692 const auto fps = mRefreshRateConfigs->getActiveMode()->getFps();
693 mFlinger->mVsyncConfiguration = mFactory.createVsyncConfiguration(fps);
694 mFlinger->mVsyncModulator = sp<scheduler::VsyncModulator>::make(
695 mFlinger->mVsyncConfiguration->getCurrentConfigs());
696 mFlinger->mRefreshRateStats =
697 std::make_unique<scheduler::RefreshRateStats>(*mFlinger->mTimeStats, fps,
698 hal::PowerMode::OFF);
699
700 mScheduler = new scheduler::TestableScheduler(std::move(vsyncController),
701 std::move(vsyncTracker), mRefreshRateConfigs,
702 *(callback ?: this));
703
704 mFlinger->mAppConnectionHandle = mScheduler->createConnection(std::move(appEventThread));
705 mFlinger->mSfConnectionHandle = mScheduler->createConnection(std::move(sfEventThread));
706 resetScheduler(mScheduler);
707 }
708
resetScheduler(scheduler::Scheduler * scheduler)709 void resetScheduler(scheduler::Scheduler *scheduler) { mFlinger->mScheduler.reset(scheduler); }
710
mutableScheduler()711 scheduler::TestableScheduler &mutableScheduler() const { return *mScheduler; }
712
713 using CreateBufferQueueFunction = surfaceflinger::test::Factory::CreateBufferQueueFunction;
setCreateBufferQueueFunction(CreateBufferQueueFunction f)714 void setCreateBufferQueueFunction(CreateBufferQueueFunction f) {
715 mFactory.mCreateBufferQueue = f;
716 }
717
718 using CreateNativeWindowSurfaceFunction =
719 surfaceflinger::test::Factory::CreateNativeWindowSurfaceFunction;
setCreateNativeWindowSurface(CreateNativeWindowSurfaceFunction f)720 void setCreateNativeWindowSurface(CreateNativeWindowSurfaceFunction f) {
721 mFactory.mCreateNativeWindowSurface = f;
722 }
723
setInternalDisplayPrimaries(const ui::DisplayPrimaries & primaries)724 void setInternalDisplayPrimaries(const ui::DisplayPrimaries &primaries) {
725 memcpy(&mFlinger->mInternalDisplayPrimaries, &primaries, sizeof(ui::DisplayPrimaries));
726 }
727
mutableLayerDrawingState(const sp<Layer> & layer)728 static auto &mutableLayerDrawingState(const sp<Layer> &layer) { return layer->mDrawingState; }
729
mutableStateLock()730 auto &mutableStateLock() { return mFlinger->mStateLock; }
731
findOutputLayerForDisplay(const sp<Layer> & layer,const sp<const DisplayDevice> & display)732 static auto findOutputLayerForDisplay(const sp<Layer> &layer,
733 const sp<const DisplayDevice> &display) {
734 return layer->findOutputLayerForDisplay(display.get());
735 }
736
737 /* ------------------------------------------------------------------------
738 * Forwarding for functions being tested
739 */
740
enableHalVirtualDisplays(bool enable)741 void enableHalVirtualDisplays(bool enable) { mFlinger->enableHalVirtualDisplays(enable); }
742
commitTransactionsLocked(uint32_t transactionFlags)743 auto commitTransactionsLocked(uint32_t transactionFlags) {
744 Mutex::Autolock lock(mFlinger->mStateLock);
745 return mFlinger->commitTransactionsLocked(transactionFlags);
746 }
747
setDisplayStateLocked(const DisplayState & s)748 auto setDisplayStateLocked(const DisplayState &s) {
749 Mutex::Autolock lock(mFlinger->mStateLock);
750 return mFlinger->setDisplayStateLocked(s);
751 }
752
notifyPowerBoost(int32_t boostId)753 auto notifyPowerBoost(int32_t boostId) { return mFlinger->notifyPowerBoost(boostId); }
754
755 // Allow reading display state without locking, as if called on the SF main thread.
setPowerModeInternal(const sp<DisplayDevice> & display,hal::PowerMode mode)756 auto setPowerModeInternal(const sp<DisplayDevice> &display,
757 hal::PowerMode mode) NO_THREAD_SAFETY_ANALYSIS {
758 return mFlinger->setPowerModeInternal(display, mode);
759 }
760
getTransactionQueue()761 auto &getTransactionQueue() { return mFlinger->mTransactionQueue; }
getPendingTransactionQueue()762 auto &getPendingTransactionQueue() { return mFlinger->mPendingTransactionQueues; }
763
setTransactionState(const FrameTimelineInfo & frameTimelineInfo,const Vector<ComposerState> & states,const Vector<DisplayState> & displays,uint32_t flags,const sp<IBinder> & applyToken,const InputWindowCommands & inputWindowCommands,int64_t desiredPresentTime,bool isAutoTimestamp,const client_cache_t & uncacheBuffer,bool hasListenerCallbacks,std::vector<ListenerCallbacks> & listenerCallbacks,uint64_t transactionId)764 auto setTransactionState(
765 const FrameTimelineInfo &frameTimelineInfo, const Vector<ComposerState> &states,
766 const Vector<DisplayState> &displays, uint32_t flags, const sp<IBinder> &applyToken,
767 const InputWindowCommands &inputWindowCommands, int64_t desiredPresentTime,
768 bool isAutoTimestamp, const client_cache_t &uncacheBuffer, bool hasListenerCallbacks,
769 std::vector<ListenerCallbacks> &listenerCallbacks, uint64_t transactionId) {
770 return mFlinger->setTransactionState(frameTimelineInfo, states, displays, flags, applyToken,
771 inputWindowCommands, desiredPresentTime,
772 isAutoTimestamp, uncacheBuffer, hasListenerCallbacks,
773 listenerCallbacks, transactionId);
774 }
775
flushTransactionQueues()776 auto flushTransactionQueues() { return mFlinger->flushTransactionQueues(0); };
777
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)778 auto onTransact(uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) {
779 return mFlinger->onTransact(code, data, reply, flags);
780 }
781
getGPUContextPriority()782 auto getGPUContextPriority() { return mFlinger->getGPUContextPriority(); }
783
calculateMaxAcquiredBufferCount(Fps refreshRate,std::chrono::nanoseconds presentLatency)784 auto calculateMaxAcquiredBufferCount(Fps refreshRate,
785 std::chrono::nanoseconds presentLatency) const {
786 return SurfaceFlinger::calculateMaxAcquiredBufferCount(refreshRate, presentLatency);
787 }
788
789 /* Read-write access to private data to set up preconditions and assert
790 * post-conditions.
791 */
792
mutableCurrentState()793 auto &mutableCurrentState() { return mFlinger->mCurrentState; }
mutableDisplays()794 auto &mutableDisplays() { return mFlinger->mDisplays; }
mutableDrawingState()795 auto &mutableDrawingState() { return mFlinger->mDrawingState; }
mutableInterceptor()796 auto &mutableInterceptor() { return mFlinger->mInterceptor; }
797
fromHandle(const sp<IBinder> & handle)798 auto fromHandle(const sp<IBinder> &handle) { return mFlinger->fromHandle(handle); }
799
~TestableSurfaceFlinger()800 ~TestableSurfaceFlinger() {
801 mutableDisplays().clear();
802 mutableCurrentState().displays.clear();
803 mutableDrawingState().displays.clear();
804 mutableInterceptor().clear();
805 mFlinger->mScheduler.reset();
806 mFlinger->mCompositionEngine->setHwComposer(std::unique_ptr<HWComposer>());
807 mFlinger->mCompositionEngine->setRenderEngine(
808 std::unique_ptr<renderengine::RenderEngine>());
809 }
810
811 private:
setVsyncEnabled(bool)812 void setVsyncEnabled(bool) override {}
requestDisplayMode(DisplayModePtr,DisplayModeEvent)813 void requestDisplayMode(DisplayModePtr, DisplayModeEvent) override {}
kernelTimerChanged(bool)814 void kernelTimerChanged(bool) override {}
triggerOnFrameRateOverridesChanged()815 void triggerOnFrameRateOverridesChanged() override {}
816
817 surfaceflinger::test::Factory mFactory;
818 sp<SurfaceFlinger> mFlinger = new SurfaceFlinger(mFactory, SurfaceFlinger::SkipInitialization);
819 scheduler::TestableScheduler *mScheduler = nullptr;
820 std::shared_ptr<scheduler::RefreshRateConfigs> mRefreshRateConfigs;
821 };
822
823 } // namespace android
824