| Flutter Windows Embedder |

compositor_opengl_unittests.cc
Go to the documentation of this file.
1 // Copyright 2013 The Flutter Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include <memory>
6 #include <vector>
7
8 #include "flutter/impeller/renderer/backend/gles/gles.h"
9 #include "flutter/shell/platform/windows/compositor_opengl.h"
10 #include "flutter/shell/platform/windows/egl/manager.h"
11 #include "flutter/shell/platform/windows/flutter_windows_view.h"
12 #include "flutter/shell/platform/windows/testing/egl/mock_context.h"
13 #include "flutter/shell/platform/windows/testing/egl/mock_manager.h"
14 #include "flutter/shell/platform/windows/testing/egl/mock_window_surface.h"
15 #include "flutter/shell/platform/windows/testing/engine_modifier.h"
16 #include "flutter/shell/platform/windows/testing/flutter_windows_engine_builder.h"
17 #include "flutter/shell/platform/windows/testing/mock_window_binding_handler.h"
18 #include "flutter/shell/platform/windows/testing/view_modifier.h"
19 #include "flutter/shell/platform/windows/testing/windows_test.h"
20 #include "gmock/gmock.h"
21 #include "gtest/gtest.h"
22
23 namespace flutter {
24 namespace testing {
25
26 namespace {
27 using ::testing::AnyNumber;
28 using ::testing::Return;
29
30 const unsigned char* MockGetString(GLenum name) {
31 switch (name) {
32 case GL_VERSION:
33 case GL_SHADING_LANGUAGE_VERSION:
34 return reinterpret_cast<const unsigned char*>("3.0");
35 default:
36 return reinterpret_cast<const unsigned char*>("");
37 }
38 }
39
40 void MockGetIntegerv(GLenum name, int* value) {
41 *value = 0;
42 }
43
44 GLenum MockGetError() {
45 return GL_NO_ERROR;
46 }
47
48 void DoNothing() {}
49
50 const impeller::ProcTableGLES::Resolver kMockResolver = [](const char* name) {
51 std::string function_name{name};
52
53 if (function_name == "glGetString") {
54 return reinterpret_cast<void*>(&MockGetString);
55 } else if (function_name == "glGetIntegerv") {
56 return reinterpret_cast<void*>(&MockGetIntegerv);
57 } else if (function_name == "glGetError") {
58 return reinterpret_cast<void*>(&MockGetError);
59 } else {
60 return reinterpret_cast<void*>(&DoNothing);
61 }
62 };
63
64 class CompositorOpenGLTest : public WindowsTest {
65 public:
66 CompositorOpenGLTest() = default;
67 virtual ~CompositorOpenGLTest() = default;
68
69 protected:
70 FlutterWindowsEngine* engine() { return engine_.get(); }
71 FlutterWindowsView* view() { return view_.get(); }
72 egl::MockManager* egl_manager() { return egl_manager_; }
73 egl::MockContext* render_context() { return render_context_.get(); }
74 egl::MockWindowSurface* surface() { return surface_; }
75
76 void UseHeadlessEngine() {
77 auto egl_manager = std::make_unique<egl::MockManager>();
78 render_context_ = std::make_unique<egl::MockContext>();
79 egl_manager_ = egl_manager.get();
80
81 EXPECT_CALL(*egl_manager_, render_context)
82 .Times(AnyNumber())
83 .WillRepeatedly(Return(render_context_.get()));
84
85 FlutterWindowsEngineBuilder builder{GetContext()};
86
87 engine_ = builder.Build();
88 EngineModifier modifier{engine_.get()};
89 modifier.SetEGLManager(std::move(egl_manager));
90 }
91
92 void UseEngineWithView(bool add_surface = true) {
93 UseHeadlessEngine();
94
95 auto window = std::make_unique<MockWindowBindingHandler>();
96 EXPECT_CALL(*window.get(), SetView).Times(1);
97 EXPECT_CALL(*window.get(), GetWindowHandle).WillRepeatedly(Return(nullptr));
98
99 view_ = std::make_unique<FlutterWindowsView>(kImplicitViewId, engine_.get(),
100 std::move(window));
101
102 if (add_surface) {
103 auto surface = std::make_unique<egl::MockWindowSurface>();
104 surface_ = surface.get();
105
106 EXPECT_CALL(*surface_, Destroy).Times(AnyNumber());
107
108 ViewModifier modifier{view_.get()};
109 modifier.SetSurface(std::move(surface));
110 }
111 }
112
113 private:
114 std::unique_ptr<FlutterWindowsEngine> engine_;
115 std::unique_ptr<FlutterWindowsView> view_;
116 std::unique_ptr<egl::MockContext> render_context_;
117 egl::MockWindowSurface* surface_;
118 egl::MockManager* egl_manager_;
119
120 FML_DISALLOW_COPY_AND_ASSIGN(CompositorOpenGLTest);
121 };
122
123 } // namespace
124
125 TEST_F(CompositorOpenGLTest, CreateBackingStore) {
126 UseHeadlessEngine();
127
128 auto compositor =
129 CompositorOpenGL{engine(), kMockResolver, /*enable_impeller=*/false};
130
131 FlutterBackingStoreConfig config = {};
132 FlutterBackingStore backing_store = {};
133
134 EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
135 ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
136 ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
137 }
138
139 TEST_F(CompositorOpenGLTest, CreateBackingStoreImpeller) {
140 UseHeadlessEngine();
141
142 auto compositor =
143 CompositorOpenGL{engine(), kMockResolver, /*enable_impeller=*/true};
144
145 FlutterBackingStoreConfig config = {};
146 FlutterBackingStore backing_store = {};
147
148 EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
149 ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
150 ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
151 }
152
153 TEST_F(CompositorOpenGLTest, InitializationFailure) {
154 UseHeadlessEngine();
155
156 auto compositor =
157 CompositorOpenGL{engine(), kMockResolver, /*enable_impeller=*/false};
158
159 FlutterBackingStoreConfig config = {};
160 FlutterBackingStore backing_store = {};
161
162 EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(false));
163 EXPECT_FALSE(compositor.CreateBackingStore(config, &backing_store));
164 }
165
166 TEST_F(CompositorOpenGLTest, Present) {
167 UseEngineWithView();
168
169 auto compositor =
170 CompositorOpenGL{engine(), kMockResolver, /*enable_impeller=*/false};
171
172 FlutterBackingStoreConfig config = {};
173 FlutterBackingStore backing_store = {};
174
175 EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
176 ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
177
178 FlutterLayer layer = {};
179 layer.type = kFlutterLayerContentTypeBackingStore;
180 layer.backing_store = &backing_store;
181 const FlutterLayer* layer_ptr = &layer;
182
183 EXPECT_CALL(*surface(), IsValid).WillRepeatedly(Return(true));
184 EXPECT_CALL(*surface(), MakeCurrent).WillOnce(Return(true));
185 EXPECT_CALL(*surface(), SwapBuffers).WillOnce(Return(true));
186 EXPECT_TRUE(compositor.Present(view(), &layer_ptr, 1));
187
188 ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
189 }
190
191 TEST_F(CompositorOpenGLTest, PresentEmpty) {
192 UseEngineWithView();
193
194 auto compositor =
195 CompositorOpenGL{engine(), kMockResolver, /*enable_impeller=*/false};
196
197 // The context will be bound twice: first to initialize the compositor, second
198 // to clear the surface.
199 EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
200 EXPECT_CALL(*surface(), IsValid).WillRepeatedly(Return(true));
201 EXPECT_CALL(*surface(), MakeCurrent).WillOnce(Return(true));
202 EXPECT_CALL(*surface(), SwapBuffers).WillOnce(Return(true));
203 EXPECT_TRUE(compositor.Present(view(), nullptr, 0));
204 }
205
206 TEST_F(CompositorOpenGLTest, NoSurfaceIgnored) {
207 UseEngineWithView(/*add_surface = */ false);
208
209 auto compositor =
210 CompositorOpenGL{engine(), kMockResolver, /*enable_impeller=*/false};
211
212 FlutterBackingStoreConfig config = {};
213 FlutterBackingStore backing_store = {};
214
215 EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
216 ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
217
218 FlutterLayer layer = {};
219 layer.type = kFlutterLayerContentTypeBackingStore;
220 layer.backing_store = &backing_store;
221 const FlutterLayer* layer_ptr = &layer;
222
223 EXPECT_FALSE(compositor.Present(view(), &layer_ptr, 1));
224
225 ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
226 }
227
228 } // namespace testing
229 } // namespace flutter
flutter::kImplicitViewId
constexpr FlutterViewId kImplicitViewId
Definition: flutter_windows_engine.h:55
flutter_windows_view.h
compositor_opengl.h
flutter
Definition: accessibility_bridge_windows.cc:11
manager.h
flutter::CompositorOpenGL
Definition: compositor_opengl.h:19
flutter::testing::TEST_F
TEST_F(CompositorOpenGLTest, CreateBackingStore)
Definition: compositor_opengl_unittests.cc:125