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"
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  egl::MockManager* egl_manager() { return egl_manager_; }
72  egl::MockContext* render_context() { return render_context_.get(); }
73  egl::MockWindowSurface* surface() { return surface_; }
74 
75  void UseHeadlessEngine() {
76  auto egl_manager = std::make_unique<egl::MockManager>();
77  render_context_ = std::make_unique<egl::MockContext>();
78  egl_manager_ = egl_manager.get();
79 
80  EXPECT_CALL(*egl_manager_, render_context)
81  .Times(AnyNumber())
82  .WillRepeatedly(Return(render_context_.get()));
83 
84  FlutterWindowsEngineBuilder builder{GetContext()};
85 
86  engine_ = builder.Build();
87  EngineModifier modifier{engine_.get()};
88  modifier.SetEGLManager(std::move(egl_manager));
89  }
90 
91  void UseEngineWithView(bool add_surface = true) {
92  UseHeadlessEngine();
93 
94  auto window = std::make_unique<MockWindowBindingHandler>();
95  EXPECT_CALL(*window.get(), SetView).Times(1);
96  EXPECT_CALL(*window.get(), GetWindowHandle).WillRepeatedly(Return(nullptr));
97 
98  view_ = std::make_unique<FlutterWindowsView>(kImplicitViewId, engine_.get(),
99  std::move(window));
100 
101  if (add_surface) {
102  auto surface = std::make_unique<egl::MockWindowSurface>();
103  surface_ = surface.get();
104 
105  EXPECT_CALL(*surface_, Destroy).Times(AnyNumber());
106 
107  ViewModifier modifier{view_.get()};
108  modifier.SetSurface(std::move(surface));
109  }
110 
111  EngineModifier modifier{engine_.get()};
112  modifier.SetImplicitView(view_.get());
113  }
114 
115  private:
116  std::unique_ptr<FlutterWindowsEngine> engine_;
117  std::unique_ptr<FlutterWindowsView> view_;
118  std::unique_ptr<egl::MockContext> render_context_;
119  egl::MockWindowSurface* surface_;
120  egl::MockManager* egl_manager_;
121 
122  FML_DISALLOW_COPY_AND_ASSIGN(CompositorOpenGLTest);
123 };
124 
125 } // namespace
126 
127 TEST_F(CompositorOpenGLTest, CreateBackingStore) {
128  UseHeadlessEngine();
129 
130  auto compositor = CompositorOpenGL{engine(), kMockResolver};
131 
132  FlutterBackingStoreConfig config = {};
133  FlutterBackingStore backing_store = {};
134 
135  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
136  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
137  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
138 }
139 
140 TEST_F(CompositorOpenGLTest, InitializationFailure) {
141  UseHeadlessEngine();
142 
143  auto compositor = CompositorOpenGL{engine(), kMockResolver};
144 
145  FlutterBackingStoreConfig config = {};
146  FlutterBackingStore backing_store = {};
147 
148  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(false));
149  EXPECT_FALSE(compositor.CreateBackingStore(config, &backing_store));
150 }
151 
152 TEST_F(CompositorOpenGLTest, Present) {
153  UseEngineWithView();
154 
155  auto compositor = CompositorOpenGL{engine(), kMockResolver};
156 
157  FlutterBackingStoreConfig config = {};
158  FlutterBackingStore backing_store = {};
159 
160  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
161  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
162 
163  FlutterLayer layer = {};
164  layer.type = kFlutterLayerContentTypeBackingStore;
165  layer.backing_store = &backing_store;
166  const FlutterLayer* layer_ptr = &layer;
167 
168  EXPECT_CALL(*surface(), IsValid).WillRepeatedly(Return(true));
169  EXPECT_CALL(*surface(), MakeCurrent).WillOnce(Return(true));
170  EXPECT_CALL(*surface(), SwapBuffers).WillOnce(Return(true));
171  EXPECT_TRUE(compositor.Present(&layer_ptr, 1));
172 
173  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
174 }
175 
176 TEST_F(CompositorOpenGLTest, PresentEmpty) {
177  UseEngineWithView();
178 
179  auto compositor = CompositorOpenGL{engine(), kMockResolver};
180 
181  // The context will be bound twice: first to initialize the compositor, second
182  // to clear the surface.
183  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
184  EXPECT_CALL(*surface(), IsValid).WillRepeatedly(Return(true));
185  EXPECT_CALL(*surface(), MakeCurrent).WillOnce(Return(true));
186  EXPECT_CALL(*surface(), SwapBuffers).WillOnce(Return(true));
187  EXPECT_TRUE(compositor.Present(nullptr, 0));
188 }
189 
190 TEST_F(CompositorOpenGLTest, HeadlessPresentIgnored) {
191  UseHeadlessEngine();
192 
193  auto compositor = CompositorOpenGL{engine(), kMockResolver};
194 
195  FlutterBackingStoreConfig config = {};
196  FlutterBackingStore backing_store = {};
197 
198  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
199  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
200 
201  FlutterLayer layer = {};
202  layer.type = kFlutterLayerContentTypeBackingStore;
203  layer.backing_store = &backing_store;
204  const FlutterLayer* layer_ptr = &layer;
205 
206  EXPECT_FALSE(compositor.Present(&layer_ptr, 1));
207 
208  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
209 }
210 
211 TEST_F(CompositorOpenGLTest, NoSurfaceIgnored) {
212  UseEngineWithView(/*add_surface = */ false);
213 
214  auto compositor = CompositorOpenGL{engine(), kMockResolver};
215 
216  FlutterBackingStoreConfig config = {};
217  FlutterBackingStore backing_store = {};
218 
219  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
220  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
221 
222  FlutterLayer layer = {};
223  layer.type = kFlutterLayerContentTypeBackingStore;
224  layer.backing_store = &backing_store;
225  const FlutterLayer* layer_ptr = &layer;
226 
227  EXPECT_FALSE(compositor.Present(&layer_ptr, 1));
228 }
229 
230 } // namespace testing
231 } // namespace flutter
flutter::kImplicitViewId
constexpr FlutterViewId kImplicitViewId
Definition: flutter_windows_engine.h:54
flutter_windows_view.h
compositor_opengl.h
flutter
Definition: accessibility_bridge_windows.cc:11
manager.h
flutter::CompositorOpenGL
Definition: compositor_opengl.h:18
flutter::testing::TEST_F
TEST_F(CompositorOpenGLTest, CreateBackingStore)
Definition: compositor_opengl_unittests.cc:127