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 #undef LOG_TAG
18 #define LOG_TAG "TunnelModeEnabledReporterTest"
19
20 #include <android/gui/BnTunnelModeEnabledListener.h>
21 #include <gmock/gmock.h>
22 #include <gtest/gtest.h>
23 #include <gui/LayerMetadata.h>
24
25 #include "BufferStateLayer.h"
26 #include "TestableSurfaceFlinger.h"
27 #include "TunnelModeEnabledReporter.h"
28 #include "mock/DisplayHardware/MockComposer.h"
29 #include "mock/MockEventThread.h"
30 #include "mock/MockMessageQueue.h"
31
32 namespace android {
33
34 using testing::_;
35 using testing::Mock;
36 using testing::Return;
37
38 using android::Hwc2::IComposer;
39 using android::Hwc2::IComposerClient;
40
41 using FakeHwcDisplayInjector = TestableSurfaceFlinger::FakeHwcDisplayInjector;
42
43 constexpr int DEFAULT_SIDEBAND_STREAM = 51;
44
45 struct TestableTunnelModeEnabledListener : public gui::BnTunnelModeEnabledListener {
TestableTunnelModeEnabledListenerandroid::TestableTunnelModeEnabledListener46 TestableTunnelModeEnabledListener() {}
47
48 bool mTunnelModeEnabled = false;
49
onTunnelModeEnabledChangedandroid::TestableTunnelModeEnabledListener50 binder::Status onTunnelModeEnabledChanged(bool tunnelModeEnabled) override {
51 mTunnelModeEnabled = tunnelModeEnabled;
52 return binder::Status::ok();
53 }
54 };
55
56 class TunnelModeEnabledReporterTest : public testing::Test {
57 public:
58 TunnelModeEnabledReporterTest();
59 ~TunnelModeEnabledReporterTest() override;
60
61 protected:
62 static constexpr uint32_t WIDTH = 100;
63 static constexpr uint32_t HEIGHT = 100;
64 static constexpr uint32_t LAYER_FLAGS = 0;
65
66 void setupScheduler();
67 void setupComposer(uint32_t virtualDisplayCount);
68 sp<BufferStateLayer> createBufferStateLayer(LayerMetadata metadata);
69
70 TestableSurfaceFlinger mFlinger;
71 Hwc2::mock::Composer* mComposer = nullptr;
72 sp<TestableTunnelModeEnabledListener> mTunnelModeEnabledListener =
73 new TestableTunnelModeEnabledListener();
74 sp<TunnelModeEnabledReporter> mTunnelModeEnabledReporter =
75 new TunnelModeEnabledReporter();
76
77 mock::MessageQueue* mMessageQueue = new mock::MessageQueue();
78 };
79
TunnelModeEnabledReporterTest()80 TunnelModeEnabledReporterTest::TunnelModeEnabledReporterTest() {
81 const ::testing::TestInfo* const test_info =
82 ::testing::UnitTest::GetInstance()->current_test_info();
83 ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());
84
85 mFlinger.mutableEventQueue().reset(mMessageQueue);
86 setupScheduler();
87 mFlinger.setupComposer(std::make_unique<Hwc2::mock::Composer>());
88 mFlinger.flinger()->mTunnelModeEnabledReporter = mTunnelModeEnabledReporter;
89 mTunnelModeEnabledReporter->dispatchTunnelModeEnabled(false);
90 }
91
~TunnelModeEnabledReporterTest()92 TunnelModeEnabledReporterTest::~TunnelModeEnabledReporterTest() {
93 const ::testing::TestInfo* const test_info =
94 ::testing::UnitTest::GetInstance()->current_test_info();
95 ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
96 mTunnelModeEnabledReporter->dispatchTunnelModeEnabled(false);
97 mTunnelModeEnabledReporter->removeListener(mTunnelModeEnabledListener);
98 }
99
createBufferStateLayer(LayerMetadata metadata={})100 sp<BufferStateLayer> TunnelModeEnabledReporterTest::createBufferStateLayer(
101 LayerMetadata metadata = {}) {
102 sp<Client> client;
103 LayerCreationArgs args(mFlinger.flinger(), client, "buffer-state-layer", WIDTH, HEIGHT,
104 LAYER_FLAGS, metadata);
105 return new BufferStateLayer(args);
106 }
107
setupScheduler()108 void TunnelModeEnabledReporterTest::setupScheduler() {
109 auto eventThread = std::make_unique<mock::EventThread>();
110 auto sfEventThread = std::make_unique<mock::EventThread>();
111
112 EXPECT_CALL(*eventThread, registerDisplayEventConnection(_));
113 EXPECT_CALL(*eventThread, createEventConnection(_, _))
114 .WillOnce(Return(new EventThreadConnection(eventThread.get(), /*callingUid=*/0,
115 ResyncCallback())));
116
117 EXPECT_CALL(*sfEventThread, registerDisplayEventConnection(_));
118 EXPECT_CALL(*sfEventThread, createEventConnection(_, _))
119 .WillOnce(Return(new EventThreadConnection(sfEventThread.get(), /*callingUid=*/0,
120 ResyncCallback())));
121
122 auto vsyncController = std::make_unique<mock::VsyncController>();
123 auto vsyncTracker = std::make_unique<mock::VSyncTracker>();
124
125 EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillRepeatedly(Return(0));
126 EXPECT_CALL(*vsyncTracker, currentPeriod())
127 .WillRepeatedly(Return(FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD));
128 EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillRepeatedly(Return(0));
129 mFlinger.setupScheduler(std::move(vsyncController), std::move(vsyncTracker),
130 std::move(eventThread), std::move(sfEventThread));
131 }
132
133 namespace {
134
TEST_F(TunnelModeEnabledReporterTest,callsAddedListeners)135 TEST_F(TunnelModeEnabledReporterTest, callsAddedListeners) {
136 mTunnelModeEnabledReporter->addListener(mTunnelModeEnabledListener);
137
138 bool expectedTunnelModeEnabled = false;
139 mTunnelModeEnabledReporter->dispatchTunnelModeEnabled(expectedTunnelModeEnabled);
140 EXPECT_EQ(expectedTunnelModeEnabled, mTunnelModeEnabledListener->mTunnelModeEnabled);
141
142 expectedTunnelModeEnabled = true;
143 mTunnelModeEnabledReporter->dispatchTunnelModeEnabled(expectedTunnelModeEnabled);
144 EXPECT_EQ(expectedTunnelModeEnabled, mTunnelModeEnabledListener->mTunnelModeEnabled);
145
146 mTunnelModeEnabledReporter->removeListener(mTunnelModeEnabledListener);
147
148 mTunnelModeEnabledReporter->dispatchTunnelModeEnabled(false);
149 EXPECT_EQ(expectedTunnelModeEnabled, mTunnelModeEnabledListener->mTunnelModeEnabled);
150 }
151
TEST_F(TunnelModeEnabledReporterTest,callsNewListenerImmediately)152 TEST_F(TunnelModeEnabledReporterTest, callsNewListenerImmediately) {
153 bool expectedTunnelModeEnabled = false;
154 mTunnelModeEnabledReporter->dispatchTunnelModeEnabled(expectedTunnelModeEnabled);
155
156 mTunnelModeEnabledReporter->addListener(mTunnelModeEnabledListener);
157 EXPECT_EQ(expectedTunnelModeEnabled, mTunnelModeEnabledListener->mTunnelModeEnabled);
158 }
159
TEST_F(TunnelModeEnabledReporterTest,callsNewListenerWithFreshInformation)160 TEST_F(TunnelModeEnabledReporterTest, callsNewListenerWithFreshInformation) {
161 sp<Layer> layer = createBufferStateLayer();
162 sp<NativeHandle> stream =
163 NativeHandle::create(reinterpret_cast<native_handle_t*>(DEFAULT_SIDEBAND_STREAM),
164 false);
165 layer->setSidebandStream(stream);
166 mFlinger.mutableCurrentState().layersSortedByZ.add(layer);
167 mTunnelModeEnabledReporter->updateTunnelModeStatus();
168 mTunnelModeEnabledReporter->addListener(mTunnelModeEnabledListener);
169 EXPECT_EQ(true, mTunnelModeEnabledListener->mTunnelModeEnabled);
170 mTunnelModeEnabledReporter->removeListener(mTunnelModeEnabledListener);
171 mFlinger.mutableCurrentState().layersSortedByZ.remove(layer);
172 layer = nullptr;
173
174 mTunnelModeEnabledReporter->updateTunnelModeStatus();
175 mTunnelModeEnabledReporter->addListener(mTunnelModeEnabledListener);
176
177 EXPECT_EQ(false, mTunnelModeEnabledListener->mTunnelModeEnabled);
178 }
179
TEST_F(TunnelModeEnabledReporterTest,layerWithSidebandStreamTriggersUpdate)180 TEST_F(TunnelModeEnabledReporterTest, layerWithSidebandStreamTriggersUpdate) {
181 mTunnelModeEnabledReporter->addListener(mTunnelModeEnabledListener);
182 EXPECT_EQ(false, mTunnelModeEnabledListener->mTunnelModeEnabled);
183
184 sp<Layer> simpleLayer = createBufferStateLayer();
185 sp<Layer> layerWithSidebandStream = createBufferStateLayer();
186 sp<NativeHandle> stream =
187 NativeHandle::create(reinterpret_cast<native_handle_t*>(DEFAULT_SIDEBAND_STREAM),
188 false);
189 layerWithSidebandStream->setSidebandStream(stream);
190
191 mFlinger.mutableCurrentState().layersSortedByZ.add(simpleLayer);
192 mFlinger.mutableCurrentState().layersSortedByZ.add(layerWithSidebandStream);
193 mTunnelModeEnabledReporter->updateTunnelModeStatus();
194 EXPECT_EQ(true, mTunnelModeEnabledListener->mTunnelModeEnabled);
195
196 mFlinger.mutableCurrentState().layersSortedByZ.remove(layerWithSidebandStream);
197 layerWithSidebandStream = nullptr;
198 mTunnelModeEnabledReporter->updateTunnelModeStatus();
199 EXPECT_EQ(false, mTunnelModeEnabledListener->mTunnelModeEnabled);
200 }
201
202 } // namespace
203 } // namespace android
204