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