OLD | NEW |
---|---|
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <stddef.h> | 5 #include <stddef.h> |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
10 #include "base/memory/ptr_util.h" | 10 #include "base/memory/ptr_util.h" |
11 #include "cc/base/region.h" | 11 #include "cc/base/region.h" |
12 #include "cc/output/ca_layer_overlay.h" | 12 #include "cc/output/ca_layer_overlay.h" |
13 #include "cc/output/filter_operation.h" | 13 #include "cc/output/filter_operation.h" |
14 #include "cc/output/gl_renderer.h" | 14 #include "cc/output/gl_renderer.h" |
15 #include "cc/output/output_surface.h" | 15 #include "cc/output/output_surface.h" |
16 #include "cc/output/output_surface_client.h" | 16 #include "cc/output/output_surface_client.h" |
17 #include "cc/output/output_surface_frame.h" | 17 #include "cc/output/output_surface_frame.h" |
18 #include "cc/output/overlay_candidate_validator.h" | 18 #include "cc/output/overlay_candidate_validator.h" |
19 #include "cc/output/overlay_processor.h" | 19 #include "cc/output/overlay_processor.h" |
20 #include "cc/output/overlay_strategy_fullscreen.h" | 20 #include "cc/output/overlay_strategy_fullscreen.h" |
21 #include "cc/output/overlay_strategy_single_on_top.h" | 21 #include "cc/output/overlay_strategy_single_on_top.h" |
22 #include "cc/output/overlay_strategy_underlay.h" | 22 #include "cc/output/overlay_strategy_underlay.h" |
23 #include "cc/output/overlay_strategy_underlay_cast.h" | |
23 #include "cc/quads/render_pass.h" | 24 #include "cc/quads/render_pass.h" |
24 #include "cc/quads/render_pass_draw_quad.h" | 25 #include "cc/quads/render_pass_draw_quad.h" |
25 #include "cc/quads/solid_color_draw_quad.h" | 26 #include "cc/quads/solid_color_draw_quad.h" |
26 #include "cc/quads/stream_video_draw_quad.h" | 27 #include "cc/quads/stream_video_draw_quad.h" |
27 #include "cc/quads/texture_draw_quad.h" | 28 #include "cc/quads/texture_draw_quad.h" |
28 #include "cc/resources/resource_provider.h" | 29 #include "cc/resources/resource_provider.h" |
29 #include "cc/resources/texture_mailbox.h" | 30 #include "cc/resources/texture_mailbox.h" |
30 #include "cc/test/fake_output_surface_client.h" | 31 #include "cc/test/fake_output_surface_client.h" |
31 #include "cc/test/fake_resource_provider.h" | 32 #include "cc/test/fake_resource_provider.h" |
32 #include "cc/test/geometry_test_utils.h" | 33 #include "cc/test/geometry_test_utils.h" |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
70 public: | 71 public: |
71 void GetStrategies(OverlayProcessor::StrategyList* strategies) override { | 72 void GetStrategies(OverlayProcessor::StrategyList* strategies) override { |
72 strategies->push_back(base::MakeUnique<OverlayStrategyFullscreen>(this)); | 73 strategies->push_back(base::MakeUnique<OverlayStrategyFullscreen>(this)); |
73 } | 74 } |
74 bool AllowCALayerOverlays() override { return false; } | 75 bool AllowCALayerOverlays() override { return false; } |
75 void CheckOverlaySupport(OverlayCandidateList* surfaces) override {} | 76 void CheckOverlaySupport(OverlayCandidateList* surfaces) override {} |
76 }; | 77 }; |
77 | 78 |
78 class SingleOverlayValidator : public OverlayCandidateValidator { | 79 class SingleOverlayValidator : public OverlayCandidateValidator { |
79 public: | 80 public: |
81 SingleOverlayValidator() : expected_rect_(kOverlayRect) {} | |
82 | |
80 void GetStrategies(OverlayProcessor::StrategyList* strategies) override { | 83 void GetStrategies(OverlayProcessor::StrategyList* strategies) override { |
81 strategies->push_back(base::MakeUnique<OverlayStrategySingleOnTop>(this)); | 84 strategies->push_back(base::MakeUnique<OverlayStrategySingleOnTop>(this)); |
82 strategies->push_back(base::MakeUnique<OverlayStrategyUnderlay>(this)); | 85 strategies->push_back(base::MakeUnique<OverlayStrategyUnderlay>(this)); |
83 } | 86 } |
84 bool AllowCALayerOverlays() override { return false; } | 87 bool AllowCALayerOverlays() override { return false; } |
85 void CheckOverlaySupport(OverlayCandidateList* surfaces) override { | 88 void CheckOverlaySupport(OverlayCandidateList* surfaces) override { |
86 // We may have 1 or 2 surfaces depending on whether this ran through the | 89 // We may have 1 or 2 surfaces depending on whether this ran through the |
87 // full renderer and picked up the output surface, or not. | 90 // full renderer and picked up the output surface, or not. |
88 ASSERT_LE(1U, surfaces->size()); | 91 ASSERT_LE(1U, surfaces->size()); |
89 ASSERT_GE(2U, surfaces->size()); | 92 ASSERT_GE(2U, surfaces->size()); |
90 | 93 |
91 OverlayCandidate& candidate = surfaces->back(); | 94 OverlayCandidate& candidate = surfaces->back(); |
92 EXPECT_TRUE(!candidate.use_output_surface_for_resource); | 95 EXPECT_TRUE(!candidate.use_output_surface_for_resource); |
93 if (candidate.display_rect.width() == kOverlayBottomRightRect.width()) { | 96 EXPECT_NEAR(expected_rect_.x(), candidate.display_rect.x(), 0.01f); |
94 EXPECT_EQ(gfx::RectF(kOverlayBottomRightRect), candidate.display_rect); | 97 EXPECT_NEAR(expected_rect_.y(), candidate.display_rect.y(), 0.01f); |
95 } else { | 98 EXPECT_NEAR(expected_rect_.width(), candidate.display_rect.width(), 0.01f); |
96 EXPECT_NEAR(kOverlayRect.x(), candidate.display_rect.x(), 0.01f); | 99 EXPECT_NEAR(expected_rect_.height(), candidate.display_rect.height(), |
97 EXPECT_NEAR(kOverlayRect.y(), candidate.display_rect.y(), 0.01f); | 100 0.01f); |
98 EXPECT_NEAR(kOverlayRect.width(), candidate.display_rect.width(), 0.01f); | 101 |
99 EXPECT_NEAR(kOverlayRect.height(), candidate.display_rect.height(), | |
100 0.01f); | |
101 } | |
102 EXPECT_FLOAT_RECT_EQ(BoundingRect(kUVTopLeft, kUVBottomRight), | 102 EXPECT_FLOAT_RECT_EQ(BoundingRect(kUVTopLeft, kUVBottomRight), |
103 candidate.uv_rect); | 103 candidate.uv_rect); |
104 if (!candidate.clip_rect.IsEmpty()) { | 104 if (!candidate.clip_rect.IsEmpty()) { |
105 EXPECT_EQ(true, candidate.is_clipped); | 105 EXPECT_EQ(true, candidate.is_clipped); |
106 EXPECT_EQ(kOverlayClipRect, candidate.clip_rect); | 106 EXPECT_EQ(kOverlayClipRect, candidate.clip_rect); |
107 } | 107 } |
108 candidate.overlay_handled = true; | 108 candidate.overlay_handled = true; |
109 } | 109 } |
110 | |
111 void SetExpectedRect(const gfx::Rect& rect) { | |
112 expected_rect_ = gfx::RectF(rect); | |
danakj
2017/02/24 22:05:18
can u drop this overload and do the gfx::RectF pro
halliwell
2017/02/27 22:57:13
Done.
| |
113 } | |
114 void SetExpectedRect(const gfx::RectF& rect) { expected_rect_ = rect; } | |
115 | |
116 private: | |
117 gfx::RectF expected_rect_; | |
110 }; | 118 }; |
111 | 119 |
112 class CALayerValidator : public OverlayCandidateValidator { | 120 class CALayerValidator : public OverlayCandidateValidator { |
113 public: | 121 public: |
114 void GetStrategies(OverlayProcessor::StrategyList* strategies) override {} | 122 void GetStrategies(OverlayProcessor::StrategyList* strategies) override {} |
115 bool AllowCALayerOverlays() override { return true; } | 123 bool AllowCALayerOverlays() override { return true; } |
116 void CheckOverlaySupport(OverlayCandidateList* surfaces) override {} | 124 void CheckOverlaySupport(OverlayCandidateList* surfaces) override {} |
117 }; | 125 }; |
118 | 126 |
119 class SingleOnTopOverlayValidator : public SingleOverlayValidator { | 127 class SingleOnTopOverlayValidator : public SingleOverlayValidator { |
120 public: | 128 public: |
121 void GetStrategies(OverlayProcessor::StrategyList* strategies) override { | 129 void GetStrategies(OverlayProcessor::StrategyList* strategies) override { |
122 strategies->push_back(base::MakeUnique<OverlayStrategySingleOnTop>(this)); | 130 strategies->push_back(base::MakeUnique<OverlayStrategySingleOnTop>(this)); |
123 } | 131 } |
124 }; | 132 }; |
125 | 133 |
126 class UnderlayOverlayValidator : public SingleOverlayValidator { | 134 class UnderlayOverlayValidator : public SingleOverlayValidator { |
127 public: | 135 public: |
128 void GetStrategies(OverlayProcessor::StrategyList* strategies) override { | 136 void GetStrategies(OverlayProcessor::StrategyList* strategies) override { |
129 strategies->push_back(base::MakeUnique<OverlayStrategyUnderlay>(this)); | 137 strategies->push_back(base::MakeUnique<OverlayStrategyUnderlay>(this)); |
130 } | 138 } |
131 }; | 139 }; |
132 | 140 |
141 class UnderlayCastOverlayValidator : public SingleOverlayValidator { | |
142 public: | |
143 void GetStrategies(OverlayProcessor::StrategyList* strategies) override { | |
144 strategies->push_back(base::MakeUnique<OverlayStrategyUnderlayCast>(this)); | |
145 } | |
146 }; | |
147 | |
133 class DefaultOverlayProcessor : public OverlayProcessor { | 148 class DefaultOverlayProcessor : public OverlayProcessor { |
134 public: | 149 public: |
135 explicit DefaultOverlayProcessor(OutputSurface* surface); | 150 explicit DefaultOverlayProcessor(OutputSurface* surface); |
136 size_t GetStrategyCount(); | 151 size_t GetStrategyCount(); |
137 }; | 152 }; |
138 | 153 |
139 DefaultOverlayProcessor::DefaultOverlayProcessor(OutputSurface* surface) | 154 DefaultOverlayProcessor::DefaultOverlayProcessor(OutputSurface* surface) |
140 : OverlayProcessor(surface) { | 155 : OverlayProcessor(surface) { |
141 } | 156 } |
142 | 157 |
143 size_t DefaultOverlayProcessor::GetStrategyCount() { | 158 size_t DefaultOverlayProcessor::GetStrategyCount() { |
144 return strategies_.size(); | 159 return strategies_.size(); |
145 } | 160 } |
146 | 161 |
162 template <typename OverlayCandidateValidatorType> | |
147 class OverlayOutputSurface : public OutputSurface { | 163 class OverlayOutputSurface : public OutputSurface { |
148 public: | 164 public: |
149 explicit OverlayOutputSurface( | 165 explicit OverlayOutputSurface( |
150 scoped_refptr<TestContextProvider> context_provider) | 166 scoped_refptr<TestContextProvider> context_provider) |
151 : OutputSurface(std::move(context_provider)) { | 167 : OutputSurface(std::move(context_provider)) { |
152 is_displayed_as_overlay_plane_ = true; | 168 is_displayed_as_overlay_plane_ = true; |
153 } | 169 } |
154 | 170 |
155 // OutputSurface implementation. | 171 // OutputSurface implementation. |
156 void BindToClient(OutputSurfaceClient* client) override {} | 172 void BindToClient(OutputSurfaceClient* client) override {} |
157 void EnsureBackbuffer() override {} | 173 void EnsureBackbuffer() override {} |
158 void DiscardBackbuffer() override {} | 174 void DiscardBackbuffer() override {} |
159 void BindFramebuffer() override { | 175 void BindFramebuffer() override { |
160 bind_framebuffer_count_ += 1; | 176 bind_framebuffer_count_ += 1; |
161 } | 177 } |
162 void Reshape(const gfx::Size& size, | 178 void Reshape(const gfx::Size& size, |
163 float device_scale_factor, | 179 float device_scale_factor, |
164 const gfx::ColorSpace& color_space, | 180 const gfx::ColorSpace& color_space, |
165 bool has_alpha, | 181 bool has_alpha, |
166 bool use_stencil) override {} | 182 bool use_stencil) override {} |
167 void SwapBuffers(OutputSurfaceFrame frame) override {} | 183 void SwapBuffers(OutputSurfaceFrame frame) override {} |
168 uint32_t GetFramebufferCopyTextureFormat() override { | 184 uint32_t GetFramebufferCopyTextureFormat() override { |
169 // TestContextProvider has no real framebuffer, just use RGB. | 185 // TestContextProvider has no real framebuffer, just use RGB. |
170 return GL_RGB; | 186 return GL_RGB; |
171 } | 187 } |
172 bool HasExternalStencilTest() const override { return false; } | 188 bool HasExternalStencilTest() const override { return false; } |
173 void ApplyExternalStencil() override {} | 189 void ApplyExternalStencil() override {} |
174 OverlayCandidateValidator* GetOverlayCandidateValidator() const override { | 190 OverlayCandidateValidatorType* GetOverlayCandidateValidator() const override { |
175 return overlay_candidate_validator_.get(); | 191 return overlay_candidate_validator_.get(); |
176 } | 192 } |
177 bool IsDisplayedAsOverlayPlane() const override { | 193 bool IsDisplayedAsOverlayPlane() const override { |
178 return is_displayed_as_overlay_plane_; | 194 return is_displayed_as_overlay_plane_; |
179 } | 195 } |
180 unsigned GetOverlayTextureId() const override { return 10000; } | 196 unsigned GetOverlayTextureId() const override { return 10000; } |
181 bool SurfaceIsSuspendForRecycle() const override { return false; } | 197 bool SurfaceIsSuspendForRecycle() const override { return false; } |
182 | 198 |
183 void set_is_displayed_as_overlay_plane(bool value) { | 199 void set_is_displayed_as_overlay_plane(bool value) { |
184 is_displayed_as_overlay_plane_ = value; | 200 is_displayed_as_overlay_plane_ = value; |
185 } | 201 } |
186 | 202 |
187 void SetOverlayCandidateValidator(OverlayCandidateValidator* validator) { | 203 void SetOverlayCandidateValidator(OverlayCandidateValidatorType* validator) { |
188 overlay_candidate_validator_.reset(validator); | 204 overlay_candidate_validator_.reset(validator); |
189 } | 205 } |
190 | 206 |
191 unsigned bind_framebuffer_count() const { return bind_framebuffer_count_; } | 207 unsigned bind_framebuffer_count() const { return bind_framebuffer_count_; } |
192 | 208 |
193 private: | 209 private: |
194 std::unique_ptr<OverlayCandidateValidator> overlay_candidate_validator_; | 210 std::unique_ptr<OverlayCandidateValidatorType> overlay_candidate_validator_; |
195 bool is_displayed_as_overlay_plane_; | 211 bool is_displayed_as_overlay_plane_; |
196 unsigned bind_framebuffer_count_ = 0; | 212 unsigned bind_framebuffer_count_ = 0; |
197 }; | 213 }; |
198 | 214 |
199 std::unique_ptr<RenderPass> CreateRenderPass() { | 215 std::unique_ptr<RenderPass> CreateRenderPass() { |
200 int render_pass_id = 1; | 216 int render_pass_id = 1; |
201 gfx::Rect output_rect(0, 0, 256, 256); | 217 gfx::Rect output_rect(0, 0, 256, 256); |
202 | 218 |
203 std::unique_ptr<RenderPass> pass = RenderPass::Create(); | 219 std::unique_ptr<RenderPass> pass = RenderPass::Create(); |
204 pass->SetNew(render_pass_id, output_rect, output_rect, gfx::Transform()); | 220 pass->SetNew(render_pass_id, output_rect, output_rect, gfx::Transform()); |
205 | 221 |
206 SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState(); | 222 SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState(); |
207 shared_state->opacity = 1.f; | 223 shared_state->opacity = 1.f; |
208 return pass; | 224 return pass; |
209 } | 225 } |
210 | 226 |
227 std::unique_ptr<RenderPass> CreateRenderPassWithTransform( | |
228 const gfx::Transform& transform) { | |
229 int render_pass_id = 1; | |
230 gfx::Rect output_rect(0, 0, 256, 256); | |
231 | |
232 std::unique_ptr<RenderPass> pass = RenderPass::Create(); | |
233 pass->SetNew(render_pass_id, output_rect, output_rect, gfx::Transform()); | |
234 | |
235 SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState(); | |
236 shared_state->opacity = 1.f; | |
237 shared_state->quad_to_target_transform = transform; | |
238 return pass; | |
239 } | |
240 | |
211 ResourceId CreateResource(ResourceProvider* resource_provider, | 241 ResourceId CreateResource(ResourceProvider* resource_provider, |
212 const gfx::Size& size, | 242 const gfx::Size& size, |
213 bool is_overlay_candidate) { | 243 bool is_overlay_candidate) { |
214 TextureMailbox mailbox = | 244 TextureMailbox mailbox = |
215 TextureMailbox(gpu::Mailbox::Generate(), gpu::SyncToken(), GL_TEXTURE_2D, | 245 TextureMailbox(gpu::Mailbox::Generate(), gpu::SyncToken(), GL_TEXTURE_2D, |
216 size, is_overlay_candidate, false); | 246 size, is_overlay_candidate, false); |
217 std::unique_ptr<SingleReleaseCallbackImpl> release_callback = | 247 std::unique_ptr<SingleReleaseCallbackImpl> release_callback = |
218 SingleReleaseCallbackImpl::Create(base::Bind(&MailboxReleased)); | 248 SingleReleaseCallbackImpl::Create(base::Bind(&MailboxReleased)); |
219 | 249 |
220 return resource_provider->CreateResourceFromTextureMailbox( | 250 return resource_provider->CreateResourceFromTextureMailbox( |
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
295 | 325 |
296 void CreateOpaqueQuadAt(ResourceProvider* resource_provider, | 326 void CreateOpaqueQuadAt(ResourceProvider* resource_provider, |
297 const SharedQuadState* shared_quad_state, | 327 const SharedQuadState* shared_quad_state, |
298 RenderPass* render_pass, | 328 RenderPass* render_pass, |
299 const gfx::Rect& rect) { | 329 const gfx::Rect& rect) { |
300 SolidColorDrawQuad* color_quad = | 330 SolidColorDrawQuad* color_quad = |
301 render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); | 331 render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); |
302 color_quad->SetNew(shared_quad_state, rect, rect, SK_ColorBLACK, false); | 332 color_quad->SetNew(shared_quad_state, rect, rect, SK_ColorBLACK, false); |
303 } | 333 } |
304 | 334 |
335 void CreateOpaqueQuadAt(ResourceProvider* resource_provider, | |
336 const SharedQuadState* shared_quad_state, | |
337 RenderPass* render_pass, | |
338 const gfx::Rect& rect, | |
339 SkColor color) { | |
340 SolidColorDrawQuad* color_quad = | |
341 render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); | |
342 color_quad->SetNew(shared_quad_state, rect, rect, color, false); | |
danakj
2017/02/24 22:05:18
DCHECK the color has 255 alpha
halliwell
2017/02/27 22:57:13
Done.
| |
343 } | |
344 | |
305 void CreateFullscreenOpaqueQuad(ResourceProvider* resource_provider, | 345 void CreateFullscreenOpaqueQuad(ResourceProvider* resource_provider, |
306 const SharedQuadState* shared_quad_state, | 346 const SharedQuadState* shared_quad_state, |
307 RenderPass* render_pass) { | 347 RenderPass* render_pass) { |
308 CreateOpaqueQuadAt(resource_provider, shared_quad_state, render_pass, | 348 CreateOpaqueQuadAt(resource_provider, shared_quad_state, render_pass, |
309 render_pass->output_rect); | 349 render_pass->output_rect); |
310 } | 350 } |
311 | 351 |
312 static void CompareRenderPassLists(const RenderPassList& expected_list, | 352 static void CompareRenderPassLists(const RenderPassList& expected_list, |
313 const RenderPassList& actual_list) { | 353 const RenderPassList& actual_list) { |
314 EXPECT_EQ(expected_list.size(), actual_list.size()); | 354 EXPECT_EQ(expected_list.size(), actual_list.size()); |
(...skipping 19 matching lines...) Expand all Loading... | |
334 ++exp_iter, ++act_iter) { | 374 ++exp_iter, ++act_iter) { |
335 EXPECT_EQ(exp_iter->rect.ToString(), act_iter->rect.ToString()); | 375 EXPECT_EQ(exp_iter->rect.ToString(), act_iter->rect.ToString()); |
336 EXPECT_EQ(exp_iter->shared_quad_state->quad_layer_bounds.ToString(), | 376 EXPECT_EQ(exp_iter->shared_quad_state->quad_layer_bounds.ToString(), |
337 act_iter->shared_quad_state->quad_layer_bounds.ToString()); | 377 act_iter->shared_quad_state->quad_layer_bounds.ToString()); |
338 } | 378 } |
339 } | 379 } |
340 } | 380 } |
341 | 381 |
342 template <typename OverlayCandidateValidatorType> | 382 template <typename OverlayCandidateValidatorType> |
343 class OverlayTest : public testing::Test { | 383 class OverlayTest : public testing::Test { |
384 using OutputSurfaceType = OverlayOutputSurface<OverlayCandidateValidatorType>; | |
385 | |
344 protected: | 386 protected: |
345 void SetUp() override { | 387 void SetUp() override { |
346 provider_ = TestContextProvider::Create(); | 388 provider_ = TestContextProvider::Create(); |
347 provider_->BindToCurrentThread(); | 389 provider_->BindToCurrentThread(); |
348 output_surface_.reset(new OverlayOutputSurface(provider_)); | 390 output_surface_.reset(new OutputSurfaceType(provider_)); |
danakj
2017/02/24 22:05:18
nit: = MakeUnique<> is preferred to reset(new)
halliwell
2017/02/27 22:57:13
Done.
| |
349 output_surface_->BindToClient(&client_); | 391 output_surface_->BindToClient(&client_); |
350 output_surface_->SetOverlayCandidateValidator( | 392 output_surface_->SetOverlayCandidateValidator( |
351 new OverlayCandidateValidatorType); | 393 new OverlayCandidateValidatorType); |
352 | 394 |
353 shared_bitmap_manager_.reset(new TestSharedBitmapManager()); | 395 shared_bitmap_manager_.reset(new TestSharedBitmapManager()); |
354 resource_provider_ = FakeResourceProvider::Create( | 396 resource_provider_ = FakeResourceProvider::Create( |
355 provider_.get(), shared_bitmap_manager_.get()); | 397 provider_.get(), shared_bitmap_manager_.get()); |
356 | 398 |
357 overlay_processor_.reset(new OverlayProcessor(output_surface_.get())); | 399 overlay_processor_.reset(new OverlayProcessor(output_surface_.get())); |
358 overlay_processor_->Initialize(); | 400 overlay_processor_->Initialize(); |
359 } | 401 } |
360 | 402 |
361 scoped_refptr<TestContextProvider> provider_; | 403 scoped_refptr<TestContextProvider> provider_; |
362 std::unique_ptr<OverlayOutputSurface> output_surface_; | 404 std::unique_ptr<OutputSurfaceType> output_surface_; |
363 FakeOutputSurfaceClient client_; | 405 FakeOutputSurfaceClient client_; |
364 std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_; | 406 std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_; |
365 std::unique_ptr<ResourceProvider> resource_provider_; | 407 std::unique_ptr<ResourceProvider> resource_provider_; |
366 std::unique_ptr<OverlayProcessor> overlay_processor_; | 408 std::unique_ptr<OverlayProcessor> overlay_processor_; |
367 gfx::Rect damage_rect_; | 409 gfx::Rect damage_rect_; |
410 std::vector<gfx::Rect> content_bounds_; | |
368 }; | 411 }; |
369 | 412 |
370 typedef OverlayTest<FullscreenOverlayValidator> FullscreenOverlayTest; | 413 using FullscreenOverlayTest = OverlayTest<FullscreenOverlayValidator>; |
371 typedef OverlayTest<SingleOnTopOverlayValidator> SingleOverlayOnTopTest; | 414 using SingleOverlayOnTopTest = OverlayTest<SingleOnTopOverlayValidator>; |
372 typedef OverlayTest<UnderlayOverlayValidator> UnderlayTest; | 415 using UnderlayTest = OverlayTest<UnderlayOverlayValidator>; |
373 typedef OverlayTest<CALayerValidator> CALayerOverlayTest; | 416 using UnderlayCastTest = OverlayTest<UnderlayCastOverlayValidator>; |
417 using CALayerOverlayTest = OverlayTest<CALayerValidator>; | |
374 | 418 |
375 TEST(OverlayTest, NoOverlaysByDefault) { | 419 TEST(OverlayTest, NoOverlaysByDefault) { |
376 scoped_refptr<TestContextProvider> provider = TestContextProvider::Create(); | 420 scoped_refptr<TestContextProvider> provider = TestContextProvider::Create(); |
377 OverlayOutputSurface output_surface(provider); | 421 OverlayOutputSurface<OverlayCandidateValidator> output_surface(provider); |
378 EXPECT_EQ(NULL, output_surface.GetOverlayCandidateValidator()); | 422 EXPECT_EQ(NULL, output_surface.GetOverlayCandidateValidator()); |
379 | 423 |
380 output_surface.SetOverlayCandidateValidator(new SingleOverlayValidator); | 424 output_surface.SetOverlayCandidateValidator(new SingleOverlayValidator); |
381 EXPECT_TRUE(output_surface.GetOverlayCandidateValidator() != NULL); | 425 EXPECT_TRUE(output_surface.GetOverlayCandidateValidator() != NULL); |
382 } | 426 } |
383 | 427 |
384 TEST(OverlayTest, OverlaysProcessorHasStrategy) { | 428 TEST(OverlayTest, OverlaysProcessorHasStrategy) { |
385 scoped_refptr<TestContextProvider> provider = TestContextProvider::Create(); | 429 scoped_refptr<TestContextProvider> provider = TestContextProvider::Create(); |
386 provider->BindToCurrentThread(); | 430 provider->BindToCurrentThread(); |
387 OverlayOutputSurface output_surface(provider); | 431 OverlayOutputSurface<OverlayCandidateValidator> output_surface(provider); |
388 FakeOutputSurfaceClient client; | 432 FakeOutputSurfaceClient client; |
389 output_surface.BindToClient(&client); | 433 output_surface.BindToClient(&client); |
390 output_surface.SetOverlayCandidateValidator(new SingleOverlayValidator); | 434 output_surface.SetOverlayCandidateValidator(new SingleOverlayValidator); |
391 | 435 |
392 std::unique_ptr<SharedBitmapManager> shared_bitmap_manager( | 436 std::unique_ptr<SharedBitmapManager> shared_bitmap_manager( |
393 new TestSharedBitmapManager()); | 437 new TestSharedBitmapManager()); |
394 std::unique_ptr<ResourceProvider> resource_provider = | 438 std::unique_ptr<ResourceProvider> resource_provider = |
395 FakeResourceProvider::Create(provider.get(), shared_bitmap_manager.get()); | 439 FakeResourceProvider::Create(provider.get(), shared_bitmap_manager.get()); |
396 | 440 |
397 std::unique_ptr<DefaultOverlayProcessor> overlay_processor( | 441 std::unique_ptr<DefaultOverlayProcessor> overlay_processor( |
(...skipping 12 matching lines...) Expand all Loading... | |
410 // Add something behind it. | 454 // Add something behind it. |
411 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 455 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
412 pass->shared_quad_state_list.back(), pass.get()); | 456 pass->shared_quad_state_list.back(), pass.get()); |
413 | 457 |
414 // Check for potential candidates. | 458 // Check for potential candidates. |
415 OverlayCandidateList candidate_list; | 459 OverlayCandidateList candidate_list; |
416 RenderPassFilterList render_pass_filters; | 460 RenderPassFilterList render_pass_filters; |
417 RenderPassFilterList render_pass_background_filters; | 461 RenderPassFilterList render_pass_background_filters; |
418 overlay_processor_->ProcessForOverlays( | 462 overlay_processor_->ProcessForOverlays( |
419 resource_provider_.get(), pass.get(), render_pass_filters, | 463 resource_provider_.get(), pass.get(), render_pass_filters, |
420 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 464 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
465 &content_bounds_); | |
421 ASSERT_EQ(1U, candidate_list.size()); | 466 ASSERT_EQ(1U, candidate_list.size()); |
422 | 467 |
423 RenderPass* main_pass = pass.get(); | 468 RenderPass* main_pass = pass.get(); |
424 // Check that all the quads are gone. | 469 // Check that all the quads are gone. |
425 EXPECT_EQ(0U, main_pass->quad_list.size()); | 470 EXPECT_EQ(0U, main_pass->quad_list.size()); |
426 // Check that we have only one overlay. | 471 // Check that we have only one overlay. |
427 EXPECT_EQ(1U, candidate_list.size()); | 472 EXPECT_EQ(1U, candidate_list.size()); |
428 // Check that the right resource id got extracted. | 473 // Check that the right resource id got extracted. |
429 EXPECT_EQ(original_resource_id, candidate_list.front().resource_id); | 474 EXPECT_EQ(original_resource_id, candidate_list.front().resource_id); |
430 } | 475 } |
431 | 476 |
432 TEST_F(FullscreenOverlayTest, ResourceSizeInPixelsFail) { | 477 TEST_F(FullscreenOverlayTest, ResourceSizeInPixelsFail) { |
433 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 478 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
434 TextureDrawQuad* original_quad = CreateFullscreenCandidateQuad( | 479 TextureDrawQuad* original_quad = CreateFullscreenCandidateQuad( |
435 resource_provider_.get(), pass->shared_quad_state_list.back(), | 480 resource_provider_.get(), pass->shared_quad_state_list.back(), |
436 pass.get()); | 481 pass.get()); |
437 original_quad->set_resource_size_in_pixels(gfx::Size(64, 64)); | 482 original_quad->set_resource_size_in_pixels(gfx::Size(64, 64)); |
438 | 483 |
439 // Check for potential candidates. | 484 // Check for potential candidates. |
440 OverlayCandidateList candidate_list; | 485 OverlayCandidateList candidate_list; |
441 RenderPassFilterList render_pass_filters; | 486 RenderPassFilterList render_pass_filters; |
442 RenderPassFilterList render_pass_background_filters; | 487 RenderPassFilterList render_pass_background_filters; |
443 overlay_processor_->ProcessForOverlays( | 488 overlay_processor_->ProcessForOverlays( |
444 resource_provider_.get(), pass.get(), render_pass_filters, | 489 resource_provider_.get(), pass.get(), render_pass_filters, |
445 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 490 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
491 &content_bounds_); | |
446 ASSERT_EQ(0U, candidate_list.size()); | 492 ASSERT_EQ(0U, candidate_list.size()); |
447 | 493 |
448 RenderPass* main_pass = pass.get(); | 494 RenderPass* main_pass = pass.get(); |
449 // Check that the quad is not gone. | 495 // Check that the quad is not gone. |
450 EXPECT_EQ(1U, main_pass->quad_list.size()); | 496 EXPECT_EQ(1U, main_pass->quad_list.size()); |
451 } | 497 } |
452 | 498 |
453 TEST_F(FullscreenOverlayTest, OnTopFail) { | 499 TEST_F(FullscreenOverlayTest, OnTopFail) { |
454 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 500 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
455 | 501 |
456 // Add something in front of it. | 502 // Add something in front of it. |
457 CreateOpaqueQuadAt(resource_provider_.get(), | 503 CreateOpaqueQuadAt(resource_provider_.get(), |
458 pass->shared_quad_state_list.back(), pass.get(), | 504 pass->shared_quad_state_list.back(), pass.get(), |
459 kOverlayTopLeftRect); | 505 kOverlayTopLeftRect); |
460 | 506 |
461 CreateFullscreenCandidateQuad(resource_provider_.get(), | 507 CreateFullscreenCandidateQuad(resource_provider_.get(), |
462 pass->shared_quad_state_list.back(), | 508 pass->shared_quad_state_list.back(), |
463 pass.get()); | 509 pass.get()); |
464 | 510 |
465 // Check for potential candidates. | 511 // Check for potential candidates. |
466 OverlayCandidateList candidate_list; | 512 OverlayCandidateList candidate_list; |
467 RenderPassFilterList render_pass_filters; | 513 RenderPassFilterList render_pass_filters; |
468 RenderPassFilterList render_pass_background_filters; | 514 RenderPassFilterList render_pass_background_filters; |
469 overlay_processor_->ProcessForOverlays( | 515 overlay_processor_->ProcessForOverlays( |
470 resource_provider_.get(), pass.get(), render_pass_filters, | 516 resource_provider_.get(), pass.get(), render_pass_filters, |
471 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 517 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
518 &content_bounds_); | |
472 ASSERT_EQ(0U, candidate_list.size()); | 519 ASSERT_EQ(0U, candidate_list.size()); |
473 | 520 |
474 RenderPass* main_pass = pass.get(); | 521 RenderPass* main_pass = pass.get(); |
475 // Check that the 2 quads are not gone. | 522 // Check that the 2 quads are not gone. |
476 EXPECT_EQ(2U, main_pass->quad_list.size()); | 523 EXPECT_EQ(2U, main_pass->quad_list.size()); |
477 } | 524 } |
478 | 525 |
479 TEST_F(FullscreenOverlayTest, NotCoveringFullscreenFail) { | 526 TEST_F(FullscreenOverlayTest, NotCoveringFullscreenFail) { |
480 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 527 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
481 gfx::Rect inset_rect = pass->output_rect; | 528 gfx::Rect inset_rect = pass->output_rect; |
482 inset_rect.Inset(0, 1, 0, 1); | 529 inset_rect.Inset(0, 1, 0, 1); |
483 CreateCandidateQuadAt(resource_provider_.get(), | 530 CreateCandidateQuadAt(resource_provider_.get(), |
484 pass->shared_quad_state_list.back(), pass.get(), | 531 pass->shared_quad_state_list.back(), pass.get(), |
485 inset_rect); | 532 inset_rect); |
486 | 533 |
487 // Check for potential candidates. | 534 // Check for potential candidates. |
488 OverlayCandidateList candidate_list; | 535 OverlayCandidateList candidate_list; |
489 RenderPassFilterList render_pass_filters; | 536 RenderPassFilterList render_pass_filters; |
490 RenderPassFilterList render_pass_background_filters; | 537 RenderPassFilterList render_pass_background_filters; |
491 overlay_processor_->ProcessForOverlays( | 538 overlay_processor_->ProcessForOverlays( |
492 resource_provider_.get(), pass.get(), render_pass_filters, | 539 resource_provider_.get(), pass.get(), render_pass_filters, |
493 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 540 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
541 &content_bounds_); | |
494 ASSERT_EQ(0U, candidate_list.size()); | 542 ASSERT_EQ(0U, candidate_list.size()); |
495 | 543 |
496 RenderPass* main_pass = pass.get(); | 544 RenderPass* main_pass = pass.get(); |
497 // Check that the quad is not gone. | 545 // Check that the quad is not gone. |
498 EXPECT_EQ(1U, main_pass->quad_list.size()); | 546 EXPECT_EQ(1U, main_pass->quad_list.size()); |
499 } | 547 } |
500 | 548 |
501 TEST_F(FullscreenOverlayTest, RemoveFullscreenQuadFromQuadList) { | 549 TEST_F(FullscreenOverlayTest, RemoveFullscreenQuadFromQuadList) { |
502 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 550 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
503 | 551 |
504 // Add something in front of it that is fully transparent. | 552 // Add something in front of it that is fully transparent. |
505 pass->shared_quad_state_list.back()->opacity = 0.0f; | 553 pass->shared_quad_state_list.back()->opacity = 0.0f; |
506 CreateOpaqueQuadAt(resource_provider_.get(), | 554 CreateOpaqueQuadAt(resource_provider_.get(), |
507 pass->shared_quad_state_list.back(), pass.get(), | 555 pass->shared_quad_state_list.back(), pass.get(), |
508 kOverlayTopLeftRect); | 556 kOverlayTopLeftRect); |
509 | 557 |
510 SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState(); | 558 SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState(); |
511 shared_state->opacity = 1.f; | 559 shared_state->opacity = 1.f; |
512 CreateFullscreenCandidateQuad(resource_provider_.get(), | 560 CreateFullscreenCandidateQuad(resource_provider_.get(), |
513 pass->shared_quad_state_list.back(), | 561 pass->shared_quad_state_list.back(), |
514 pass.get()); | 562 pass.get()); |
515 | 563 |
516 // Check for potential candidates. | 564 // Check for potential candidates. |
517 OverlayCandidateList candidate_list; | 565 OverlayCandidateList candidate_list; |
518 RenderPassFilterList render_pass_filters; | 566 RenderPassFilterList render_pass_filters; |
519 RenderPassFilterList render_pass_background_filters; | 567 RenderPassFilterList render_pass_background_filters; |
520 overlay_processor_->ProcessForOverlays( | 568 overlay_processor_->ProcessForOverlays( |
521 resource_provider_.get(), pass.get(), render_pass_filters, | 569 resource_provider_.get(), pass.get(), render_pass_filters, |
522 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 570 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
571 &content_bounds_); | |
523 ASSERT_EQ(1U, candidate_list.size()); | 572 ASSERT_EQ(1U, candidate_list.size()); |
524 | 573 |
525 // Check that the fullscreen quad is gone. | 574 // Check that the fullscreen quad is gone. |
526 for (const DrawQuad* quad : pass->quad_list) { | 575 for (const DrawQuad* quad : pass->quad_list) { |
527 EXPECT_NE(pass->output_rect, quad->rect); | 576 EXPECT_NE(pass->output_rect, quad->rect); |
528 } | 577 } |
529 } | 578 } |
530 | 579 |
531 TEST_F(SingleOverlayOnTopTest, SuccessfulOverlay) { | 580 TEST_F(SingleOverlayOnTopTest, SuccessfulOverlay) { |
532 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 581 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
533 TextureDrawQuad* original_quad = | 582 TextureDrawQuad* original_quad = |
534 CreateFullscreenCandidateQuad(resource_provider_.get(), | 583 CreateFullscreenCandidateQuad(resource_provider_.get(), |
535 pass->shared_quad_state_list.back(), | 584 pass->shared_quad_state_list.back(), |
536 pass.get()); | 585 pass.get()); |
537 unsigned original_resource_id = original_quad->resource_id(); | 586 unsigned original_resource_id = original_quad->resource_id(); |
538 | 587 |
539 // Add something behind it. | 588 // Add something behind it. |
540 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 589 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
541 pass->shared_quad_state_list.back(), pass.get()); | 590 pass->shared_quad_state_list.back(), pass.get()); |
542 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 591 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
543 pass->shared_quad_state_list.back(), pass.get()); | 592 pass->shared_quad_state_list.back(), pass.get()); |
544 | 593 |
545 // Check for potential candidates. | 594 // Check for potential candidates. |
546 OverlayCandidateList candidate_list; | 595 OverlayCandidateList candidate_list; |
547 RenderPassFilterList render_pass_filters; | 596 RenderPassFilterList render_pass_filters; |
548 RenderPassFilterList render_pass_background_filters; | 597 RenderPassFilterList render_pass_background_filters; |
549 overlay_processor_->ProcessForOverlays( | 598 overlay_processor_->ProcessForOverlays( |
550 resource_provider_.get(), pass.get(), render_pass_filters, | 599 resource_provider_.get(), pass.get(), render_pass_filters, |
551 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 600 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
601 &content_bounds_); | |
552 ASSERT_EQ(1U, candidate_list.size()); | 602 ASSERT_EQ(1U, candidate_list.size()); |
553 | 603 |
554 RenderPass* main_pass = pass.get(); | 604 RenderPass* main_pass = pass.get(); |
555 // Check that the quad is gone. | 605 // Check that the quad is gone. |
556 EXPECT_EQ(2U, main_pass->quad_list.size()); | 606 EXPECT_EQ(2U, main_pass->quad_list.size()); |
557 const QuadList& quad_list = main_pass->quad_list; | 607 const QuadList& quad_list = main_pass->quad_list; |
558 for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin(); | 608 for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin(); |
559 it != quad_list.BackToFrontEnd(); | 609 it != quad_list.BackToFrontEnd(); |
560 ++it) { | 610 ++it) { |
561 EXPECT_NE(DrawQuad::TEXTURE_CONTENT, it->material); | 611 EXPECT_NE(DrawQuad::TEXTURE_CONTENT, it->material); |
(...skipping 24 matching lines...) Expand all Loading... | |
586 output_surface_plane.display_rect = gfx::RectF(kOverlayRect); | 636 output_surface_plane.display_rect = gfx::RectF(kOverlayRect); |
587 output_surface_plane.quad_rect_in_target_space = kOverlayRect; | 637 output_surface_plane.quad_rect_in_target_space = kOverlayRect; |
588 output_surface_plane.use_output_surface_for_resource = true; | 638 output_surface_plane.use_output_surface_for_resource = true; |
589 output_surface_plane.overlay_handled = true; | 639 output_surface_plane.overlay_handled = true; |
590 candidate_list.push_back(output_surface_plane); | 640 candidate_list.push_back(output_surface_plane); |
591 | 641 |
592 RenderPassFilterList render_pass_filters; | 642 RenderPassFilterList render_pass_filters; |
593 RenderPassFilterList render_pass_background_filters; | 643 RenderPassFilterList render_pass_background_filters; |
594 overlay_processor_->ProcessForOverlays( | 644 overlay_processor_->ProcessForOverlays( |
595 resource_provider_.get(), pass.get(), render_pass_filters, | 645 resource_provider_.get(), pass.get(), render_pass_filters, |
596 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 646 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
647 &content_bounds_); | |
597 DCHECK(damage_rect_.IsEmpty()); | 648 DCHECK(damage_rect_.IsEmpty()); |
598 } | 649 } |
599 | 650 |
600 TEST_F(SingleOverlayOnTopTest, NoCandidates) { | 651 TEST_F(SingleOverlayOnTopTest, NoCandidates) { |
601 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 652 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
602 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 653 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
603 pass->shared_quad_state_list.back(), pass.get()); | 654 pass->shared_quad_state_list.back(), pass.get()); |
604 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 655 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
605 pass->shared_quad_state_list.back(), pass.get()); | 656 pass->shared_quad_state_list.back(), pass.get()); |
606 | 657 |
607 RenderPassList pass_list; | 658 RenderPassList pass_list; |
608 pass_list.push_back(std::move(pass)); | 659 pass_list.push_back(std::move(pass)); |
609 | 660 |
610 RenderPassList original_pass_list; | 661 RenderPassList original_pass_list; |
611 RenderPass::CopyAll(pass_list, &original_pass_list); | 662 RenderPass::CopyAll(pass_list, &original_pass_list); |
612 | 663 |
613 OverlayCandidateList candidate_list; | 664 OverlayCandidateList candidate_list; |
614 RenderPassFilterList render_pass_filters; | 665 RenderPassFilterList render_pass_filters; |
615 RenderPassFilterList render_pass_background_filters; | 666 RenderPassFilterList render_pass_background_filters; |
616 overlay_processor_->ProcessForOverlays( | 667 overlay_processor_->ProcessForOverlays( |
617 resource_provider_.get(), pass_list.back().get(), render_pass_filters, | 668 resource_provider_.get(), pass_list.back().get(), render_pass_filters, |
618 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 669 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
670 &content_bounds_); | |
619 EXPECT_EQ(0U, candidate_list.size()); | 671 EXPECT_EQ(0U, candidate_list.size()); |
620 // There should be nothing new here. | 672 // There should be nothing new here. |
621 CompareRenderPassLists(pass_list, original_pass_list); | 673 CompareRenderPassLists(pass_list, original_pass_list); |
622 } | 674 } |
623 | 675 |
624 TEST_F(SingleOverlayOnTopTest, OccludedCandidates) { | 676 TEST_F(SingleOverlayOnTopTest, OccludedCandidates) { |
625 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 677 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
626 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 678 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
627 pass->shared_quad_state_list.back(), pass.get()); | 679 pass->shared_quad_state_list.back(), pass.get()); |
628 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 680 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
629 pass->shared_quad_state_list.back(), pass.get()); | 681 pass->shared_quad_state_list.back(), pass.get()); |
630 | 682 |
631 CreateFullscreenCandidateQuad(resource_provider_.get(), | 683 CreateFullscreenCandidateQuad(resource_provider_.get(), |
632 pass->shared_quad_state_list.back(), | 684 pass->shared_quad_state_list.back(), |
633 pass.get()); | 685 pass.get()); |
634 | 686 |
635 RenderPassList pass_list; | 687 RenderPassList pass_list; |
636 pass_list.push_back(std::move(pass)); | 688 pass_list.push_back(std::move(pass)); |
637 | 689 |
638 RenderPassList original_pass_list; | 690 RenderPassList original_pass_list; |
639 RenderPass::CopyAll(pass_list, &original_pass_list); | 691 RenderPass::CopyAll(pass_list, &original_pass_list); |
640 | 692 |
641 OverlayCandidateList candidate_list; | 693 OverlayCandidateList candidate_list; |
642 RenderPassFilterList render_pass_filters; | 694 RenderPassFilterList render_pass_filters; |
643 RenderPassFilterList render_pass_background_filters; | 695 RenderPassFilterList render_pass_background_filters; |
644 overlay_processor_->ProcessForOverlays( | 696 overlay_processor_->ProcessForOverlays( |
645 resource_provider_.get(), pass_list.back().get(), render_pass_filters, | 697 resource_provider_.get(), pass_list.back().get(), render_pass_filters, |
646 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 698 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
699 &content_bounds_); | |
647 EXPECT_EQ(0U, candidate_list.size()); | 700 EXPECT_EQ(0U, candidate_list.size()); |
648 // There should be nothing new here. | 701 // There should be nothing new here. |
649 CompareRenderPassLists(pass_list, original_pass_list); | 702 CompareRenderPassLists(pass_list, original_pass_list); |
650 } | 703 } |
651 | 704 |
652 // Test with multiple render passes. | 705 // Test with multiple render passes. |
653 TEST_F(SingleOverlayOnTopTest, MultipleRenderPasses) { | 706 TEST_F(SingleOverlayOnTopTest, MultipleRenderPasses) { |
654 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 707 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
655 CreateFullscreenCandidateQuad(resource_provider_.get(), | 708 CreateFullscreenCandidateQuad(resource_provider_.get(), |
656 pass->shared_quad_state_list.back(), | 709 pass->shared_quad_state_list.back(), |
657 pass.get()); | 710 pass.get()); |
658 | 711 |
659 // Add something behind it. | 712 // Add something behind it. |
660 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 713 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
661 pass->shared_quad_state_list.back(), pass.get()); | 714 pass->shared_quad_state_list.back(), pass.get()); |
662 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 715 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
663 pass->shared_quad_state_list.back(), pass.get()); | 716 pass->shared_quad_state_list.back(), pass.get()); |
664 | 717 |
665 // Check for potential candidates. | 718 // Check for potential candidates. |
666 OverlayCandidateList candidate_list; | 719 OverlayCandidateList candidate_list; |
667 RenderPassFilterList render_pass_filters; | 720 RenderPassFilterList render_pass_filters; |
668 RenderPassFilterList render_pass_background_filters; | 721 RenderPassFilterList render_pass_background_filters; |
669 overlay_processor_->ProcessForOverlays( | 722 overlay_processor_->ProcessForOverlays( |
670 resource_provider_.get(), pass.get(), render_pass_filters, | 723 resource_provider_.get(), pass.get(), render_pass_filters, |
671 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 724 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
725 &content_bounds_); | |
672 EXPECT_EQ(1U, candidate_list.size()); | 726 EXPECT_EQ(1U, candidate_list.size()); |
673 } | 727 } |
674 | 728 |
675 TEST_F(SingleOverlayOnTopTest, RejectBlending) { | 729 TEST_F(SingleOverlayOnTopTest, RejectBlending) { |
676 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 730 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
677 TextureDrawQuad* quad = | 731 TextureDrawQuad* quad = |
678 CreateFullscreenCandidateQuad(resource_provider_.get(), | 732 CreateFullscreenCandidateQuad(resource_provider_.get(), |
679 pass->shared_quad_state_list.back(), | 733 pass->shared_quad_state_list.back(), |
680 pass.get()); | 734 pass.get()); |
681 quad->needs_blending = true; | 735 quad->needs_blending = true; |
682 | 736 |
683 OverlayCandidateList candidate_list; | 737 OverlayCandidateList candidate_list; |
684 RenderPassFilterList render_pass_filters; | 738 RenderPassFilterList render_pass_filters; |
685 RenderPassFilterList render_pass_background_filters; | 739 RenderPassFilterList render_pass_background_filters; |
686 overlay_processor_->ProcessForOverlays( | 740 overlay_processor_->ProcessForOverlays( |
687 resource_provider_.get(), pass.get(), render_pass_filters, | 741 resource_provider_.get(), pass.get(), render_pass_filters, |
688 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 742 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
743 &content_bounds_); | |
689 EXPECT_EQ(0U, candidate_list.size()); | 744 EXPECT_EQ(0U, candidate_list.size()); |
690 } | 745 } |
691 | 746 |
692 TEST_F(SingleOverlayOnTopTest, RejectBackgroundColor) { | 747 TEST_F(SingleOverlayOnTopTest, RejectBackgroundColor) { |
693 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 748 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
694 TextureDrawQuad* quad = | 749 TextureDrawQuad* quad = |
695 CreateFullscreenCandidateQuad(resource_provider_.get(), | 750 CreateFullscreenCandidateQuad(resource_provider_.get(), |
696 pass->shared_quad_state_list.back(), | 751 pass->shared_quad_state_list.back(), |
697 pass.get()); | 752 pass.get()); |
698 quad->background_color = SK_ColorBLACK; | 753 quad->background_color = SK_ColorBLACK; |
699 | 754 |
700 OverlayCandidateList candidate_list; | 755 OverlayCandidateList candidate_list; |
701 RenderPassFilterList render_pass_filters; | 756 RenderPassFilterList render_pass_filters; |
702 RenderPassFilterList render_pass_background_filters; | 757 RenderPassFilterList render_pass_background_filters; |
703 overlay_processor_->ProcessForOverlays( | 758 overlay_processor_->ProcessForOverlays( |
704 resource_provider_.get(), pass.get(), render_pass_filters, | 759 resource_provider_.get(), pass.get(), render_pass_filters, |
705 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 760 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
761 &content_bounds_); | |
706 EXPECT_EQ(0U, candidate_list.size()); | 762 EXPECT_EQ(0U, candidate_list.size()); |
707 } | 763 } |
708 | 764 |
709 TEST_F(SingleOverlayOnTopTest, RejectBlendMode) { | 765 TEST_F(SingleOverlayOnTopTest, RejectBlendMode) { |
710 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 766 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
711 CreateFullscreenCandidateQuad(resource_provider_.get(), | 767 CreateFullscreenCandidateQuad(resource_provider_.get(), |
712 pass->shared_quad_state_list.back(), | 768 pass->shared_quad_state_list.back(), |
713 pass.get()); | 769 pass.get()); |
714 pass->shared_quad_state_list.back()->blend_mode = SkBlendMode::kScreen; | 770 pass->shared_quad_state_list.back()->blend_mode = SkBlendMode::kScreen; |
715 | 771 |
716 OverlayCandidateList candidate_list; | 772 OverlayCandidateList candidate_list; |
717 RenderPassFilterList render_pass_filters; | 773 RenderPassFilterList render_pass_filters; |
718 RenderPassFilterList render_pass_background_filters; | 774 RenderPassFilterList render_pass_background_filters; |
719 overlay_processor_->ProcessForOverlays( | 775 overlay_processor_->ProcessForOverlays( |
720 resource_provider_.get(), pass.get(), render_pass_filters, | 776 resource_provider_.get(), pass.get(), render_pass_filters, |
721 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 777 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
778 &content_bounds_); | |
722 EXPECT_EQ(0U, candidate_list.size()); | 779 EXPECT_EQ(0U, candidate_list.size()); |
723 } | 780 } |
724 | 781 |
725 TEST_F(SingleOverlayOnTopTest, RejectOpacity) { | 782 TEST_F(SingleOverlayOnTopTest, RejectOpacity) { |
726 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 783 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
727 CreateFullscreenCandidateQuad(resource_provider_.get(), | 784 CreateFullscreenCandidateQuad(resource_provider_.get(), |
728 pass->shared_quad_state_list.back(), | 785 pass->shared_quad_state_list.back(), |
729 pass.get()); | 786 pass.get()); |
730 pass->shared_quad_state_list.back()->opacity = 0.5f; | 787 pass->shared_quad_state_list.back()->opacity = 0.5f; |
731 | 788 |
732 OverlayCandidateList candidate_list; | 789 OverlayCandidateList candidate_list; |
733 RenderPassFilterList render_pass_filters; | 790 RenderPassFilterList render_pass_filters; |
734 RenderPassFilterList render_pass_background_filters; | 791 RenderPassFilterList render_pass_background_filters; |
735 overlay_processor_->ProcessForOverlays( | 792 overlay_processor_->ProcessForOverlays( |
736 resource_provider_.get(), pass.get(), render_pass_filters, | 793 resource_provider_.get(), pass.get(), render_pass_filters, |
737 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 794 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
795 &content_bounds_); | |
738 EXPECT_EQ(0U, candidate_list.size()); | 796 EXPECT_EQ(0U, candidate_list.size()); |
739 } | 797 } |
740 | 798 |
741 TEST_F(SingleOverlayOnTopTest, RejectNonAxisAlignedTransform) { | 799 TEST_F(SingleOverlayOnTopTest, RejectNonAxisAlignedTransform) { |
742 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 800 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
743 CreateFullscreenCandidateQuad(resource_provider_.get(), | 801 CreateFullscreenCandidateQuad(resource_provider_.get(), |
744 pass->shared_quad_state_list.back(), | 802 pass->shared_quad_state_list.back(), |
745 pass.get()); | 803 pass.get()); |
746 pass->shared_quad_state_list.back() | 804 pass->shared_quad_state_list.back() |
747 ->quad_to_target_transform.RotateAboutXAxis(45.f); | 805 ->quad_to_target_transform.RotateAboutXAxis(45.f); |
748 | 806 |
749 OverlayCandidateList candidate_list; | 807 OverlayCandidateList candidate_list; |
750 RenderPassFilterList render_pass_filters; | 808 RenderPassFilterList render_pass_filters; |
751 RenderPassFilterList render_pass_background_filters; | 809 RenderPassFilterList render_pass_background_filters; |
752 overlay_processor_->ProcessForOverlays( | 810 overlay_processor_->ProcessForOverlays( |
753 resource_provider_.get(), pass.get(), render_pass_filters, | 811 resource_provider_.get(), pass.get(), render_pass_filters, |
754 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 812 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
813 &content_bounds_); | |
755 EXPECT_EQ(0U, candidate_list.size()); | 814 EXPECT_EQ(0U, candidate_list.size()); |
756 } | 815 } |
757 | 816 |
758 TEST_F(SingleOverlayOnTopTest, AllowClipped) { | 817 TEST_F(SingleOverlayOnTopTest, AllowClipped) { |
759 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 818 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
760 CreateFullscreenCandidateQuad(resource_provider_.get(), | 819 CreateFullscreenCandidateQuad(resource_provider_.get(), |
761 pass->shared_quad_state_list.back(), | 820 pass->shared_quad_state_list.back(), |
762 pass.get()); | 821 pass.get()); |
763 pass->shared_quad_state_list.back()->is_clipped = true; | 822 pass->shared_quad_state_list.back()->is_clipped = true; |
764 pass->shared_quad_state_list.back()->clip_rect = kOverlayClipRect; | 823 pass->shared_quad_state_list.back()->clip_rect = kOverlayClipRect; |
765 | 824 |
766 OverlayCandidateList candidate_list; | 825 OverlayCandidateList candidate_list; |
767 RenderPassFilterList render_pass_filters; | 826 RenderPassFilterList render_pass_filters; |
768 RenderPassFilterList render_pass_background_filters; | 827 RenderPassFilterList render_pass_background_filters; |
769 overlay_processor_->ProcessForOverlays( | 828 overlay_processor_->ProcessForOverlays( |
770 resource_provider_.get(), pass.get(), render_pass_filters, | 829 resource_provider_.get(), pass.get(), render_pass_filters, |
771 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 830 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
831 &content_bounds_); | |
772 EXPECT_EQ(1U, candidate_list.size()); | 832 EXPECT_EQ(1U, candidate_list.size()); |
773 } | 833 } |
774 | 834 |
775 TEST_F(UnderlayTest, AllowVerticalFlip) { | 835 TEST_F(UnderlayTest, AllowVerticalFlip) { |
776 gfx::Rect rect = kOverlayRect; | 836 gfx::Rect rect = kOverlayRect; |
777 rect.set_width(rect.width() / 2); | 837 rect.set_width(rect.width() / 2); |
778 rect.Offset(0, -rect.height()); | 838 rect.Offset(0, -rect.height()); |
779 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 839 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
780 CreateCandidateQuadAt(resource_provider_.get(), | 840 CreateCandidateQuadAt(resource_provider_.get(), |
781 pass->shared_quad_state_list.back(), pass.get(), rect); | 841 pass->shared_quad_state_list.back(), pass.get(), rect); |
782 pass->shared_quad_state_list.back()->quad_to_target_transform.Scale(2.0f, | 842 pass->shared_quad_state_list.back()->quad_to_target_transform.Scale(2.0f, |
783 -1.0f); | 843 -1.0f); |
784 OverlayCandidateList candidate_list; | 844 OverlayCandidateList candidate_list; |
785 RenderPassFilterList render_pass_filters; | 845 RenderPassFilterList render_pass_filters; |
786 RenderPassFilterList render_pass_background_filters; | 846 RenderPassFilterList render_pass_background_filters; |
787 overlay_processor_->ProcessForOverlays( | 847 overlay_processor_->ProcessForOverlays( |
788 resource_provider_.get(), pass.get(), render_pass_filters, | 848 resource_provider_.get(), pass.get(), render_pass_filters, |
789 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 849 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
850 &content_bounds_); | |
790 ASSERT_EQ(1U, candidate_list.size()); | 851 ASSERT_EQ(1U, candidate_list.size()); |
791 EXPECT_EQ(gfx::OVERLAY_TRANSFORM_FLIP_VERTICAL, | 852 EXPECT_EQ(gfx::OVERLAY_TRANSFORM_FLIP_VERTICAL, |
792 candidate_list.back().transform); | 853 candidate_list.back().transform); |
793 } | 854 } |
794 | 855 |
795 TEST_F(UnderlayTest, AllowHorizontalFlip) { | 856 TEST_F(UnderlayTest, AllowHorizontalFlip) { |
796 gfx::Rect rect = kOverlayRect; | 857 gfx::Rect rect = kOverlayRect; |
797 rect.set_height(rect.height() / 2); | 858 rect.set_height(rect.height() / 2); |
798 rect.Offset(-rect.width(), 0); | 859 rect.Offset(-rect.width(), 0); |
799 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 860 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
800 CreateCandidateQuadAt(resource_provider_.get(), | 861 CreateCandidateQuadAt(resource_provider_.get(), |
801 pass->shared_quad_state_list.back(), pass.get(), rect); | 862 pass->shared_quad_state_list.back(), pass.get(), rect); |
802 pass->shared_quad_state_list.back()->quad_to_target_transform.Scale(-1.0f, | 863 pass->shared_quad_state_list.back()->quad_to_target_transform.Scale(-1.0f, |
803 2.0f); | 864 2.0f); |
804 | 865 |
805 OverlayCandidateList candidate_list; | 866 OverlayCandidateList candidate_list; |
806 RenderPassFilterList render_pass_filters; | 867 RenderPassFilterList render_pass_filters; |
807 RenderPassFilterList render_pass_background_filters; | 868 RenderPassFilterList render_pass_background_filters; |
808 overlay_processor_->ProcessForOverlays( | 869 overlay_processor_->ProcessForOverlays( |
809 resource_provider_.get(), pass.get(), render_pass_filters, | 870 resource_provider_.get(), pass.get(), render_pass_filters, |
810 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 871 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
872 &content_bounds_); | |
811 ASSERT_EQ(1U, candidate_list.size()); | 873 ASSERT_EQ(1U, candidate_list.size()); |
812 EXPECT_EQ(gfx::OVERLAY_TRANSFORM_FLIP_HORIZONTAL, | 874 EXPECT_EQ(gfx::OVERLAY_TRANSFORM_FLIP_HORIZONTAL, |
813 candidate_list.back().transform); | 875 candidate_list.back().transform); |
814 } | 876 } |
815 | 877 |
816 TEST_F(SingleOverlayOnTopTest, AllowPositiveScaleTransform) { | 878 TEST_F(SingleOverlayOnTopTest, AllowPositiveScaleTransform) { |
817 gfx::Rect rect = kOverlayRect; | 879 gfx::Rect rect = kOverlayRect; |
818 rect.set_width(rect.width() / 2); | 880 rect.set_width(rect.width() / 2); |
819 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 881 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
820 CreateCandidateQuadAt(resource_provider_.get(), | 882 CreateCandidateQuadAt(resource_provider_.get(), |
821 pass->shared_quad_state_list.back(), pass.get(), rect); | 883 pass->shared_quad_state_list.back(), pass.get(), rect); |
822 pass->shared_quad_state_list.back()->quad_to_target_transform.Scale(2.0f, | 884 pass->shared_quad_state_list.back()->quad_to_target_transform.Scale(2.0f, |
823 1.0f); | 885 1.0f); |
824 OverlayCandidateList candidate_list; | 886 OverlayCandidateList candidate_list; |
825 RenderPassFilterList render_pass_filters; | 887 RenderPassFilterList render_pass_filters; |
826 RenderPassFilterList render_pass_background_filters; | 888 RenderPassFilterList render_pass_background_filters; |
827 overlay_processor_->ProcessForOverlays( | 889 overlay_processor_->ProcessForOverlays( |
828 resource_provider_.get(), pass.get(), render_pass_filters, | 890 resource_provider_.get(), pass.get(), render_pass_filters, |
829 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 891 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
892 &content_bounds_); | |
830 EXPECT_EQ(1U, candidate_list.size()); | 893 EXPECT_EQ(1U, candidate_list.size()); |
831 } | 894 } |
832 | 895 |
833 TEST_F(SingleOverlayOnTopTest, RejectTransform) { | 896 TEST_F(SingleOverlayOnTopTest, RejectTransform) { |
834 gfx::Rect rect = kOverlayRect; | 897 gfx::Rect rect = kOverlayRect; |
835 rect.Offset(0, -rect.height()); | 898 rect.Offset(0, -rect.height()); |
836 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 899 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
837 CreateCandidateQuadAt(resource_provider_.get(), | 900 CreateCandidateQuadAt(resource_provider_.get(), |
838 pass->shared_quad_state_list.back(), pass.get(), rect); | 901 pass->shared_quad_state_list.back(), pass.get(), rect); |
839 pass->shared_quad_state_list.back() | 902 pass->shared_quad_state_list.back() |
840 ->quad_to_target_transform.RotateAboutZAxis(90.f); | 903 ->quad_to_target_transform.RotateAboutZAxis(90.f); |
841 | 904 |
842 OverlayCandidateList candidate_list; | 905 OverlayCandidateList candidate_list; |
843 RenderPassFilterList render_pass_filters; | 906 RenderPassFilterList render_pass_filters; |
844 RenderPassFilterList render_pass_background_filters; | 907 RenderPassFilterList render_pass_background_filters; |
845 overlay_processor_->ProcessForOverlays( | 908 overlay_processor_->ProcessForOverlays( |
846 resource_provider_.get(), pass.get(), render_pass_filters, | 909 resource_provider_.get(), pass.get(), render_pass_filters, |
847 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 910 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
911 &content_bounds_); | |
848 ASSERT_EQ(0U, candidate_list.size()); | 912 ASSERT_EQ(0U, candidate_list.size()); |
849 } | 913 } |
850 | 914 |
851 TEST_F(UnderlayTest, Allow90DegreeRotation) { | 915 TEST_F(UnderlayTest, Allow90DegreeRotation) { |
852 gfx::Rect rect = kOverlayRect; | 916 gfx::Rect rect = kOverlayRect; |
853 rect.Offset(0, -rect.height()); | 917 rect.Offset(0, -rect.height()); |
854 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 918 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
855 CreateCandidateQuadAt(resource_provider_.get(), | 919 CreateCandidateQuadAt(resource_provider_.get(), |
856 pass->shared_quad_state_list.back(), pass.get(), rect); | 920 pass->shared_quad_state_list.back(), pass.get(), rect); |
857 pass->shared_quad_state_list.back() | 921 pass->shared_quad_state_list.back() |
858 ->quad_to_target_transform.RotateAboutZAxis(90.f); | 922 ->quad_to_target_transform.RotateAboutZAxis(90.f); |
859 | 923 |
860 OverlayCandidateList candidate_list; | 924 OverlayCandidateList candidate_list; |
861 RenderPassFilterList render_pass_filters; | 925 RenderPassFilterList render_pass_filters; |
862 RenderPassFilterList render_pass_background_filters; | 926 RenderPassFilterList render_pass_background_filters; |
863 overlay_processor_->ProcessForOverlays( | 927 overlay_processor_->ProcessForOverlays( |
864 resource_provider_.get(), pass.get(), render_pass_filters, | 928 resource_provider_.get(), pass.get(), render_pass_filters, |
865 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 929 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
930 &content_bounds_); | |
866 ASSERT_EQ(1U, candidate_list.size()); | 931 ASSERT_EQ(1U, candidate_list.size()); |
867 EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_90, candidate_list.back().transform); | 932 EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_90, candidate_list.back().transform); |
868 } | 933 } |
869 | 934 |
870 TEST_F(UnderlayTest, Allow180DegreeRotation) { | 935 TEST_F(UnderlayTest, Allow180DegreeRotation) { |
871 gfx::Rect rect = kOverlayRect; | 936 gfx::Rect rect = kOverlayRect; |
872 rect.Offset(-rect.width(), -rect.height()); | 937 rect.Offset(-rect.width(), -rect.height()); |
873 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 938 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
874 CreateCandidateQuadAt(resource_provider_.get(), | 939 CreateCandidateQuadAt(resource_provider_.get(), |
875 pass->shared_quad_state_list.back(), pass.get(), rect); | 940 pass->shared_quad_state_list.back(), pass.get(), rect); |
876 pass->shared_quad_state_list.back() | 941 pass->shared_quad_state_list.back() |
877 ->quad_to_target_transform.RotateAboutZAxis(180.f); | 942 ->quad_to_target_transform.RotateAboutZAxis(180.f); |
878 | 943 |
879 OverlayCandidateList candidate_list; | 944 OverlayCandidateList candidate_list; |
880 RenderPassFilterList render_pass_filters; | 945 RenderPassFilterList render_pass_filters; |
881 RenderPassFilterList render_pass_background_filters; | 946 RenderPassFilterList render_pass_background_filters; |
882 overlay_processor_->ProcessForOverlays( | 947 overlay_processor_->ProcessForOverlays( |
883 resource_provider_.get(), pass.get(), render_pass_filters, | 948 resource_provider_.get(), pass.get(), render_pass_filters, |
884 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 949 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
950 &content_bounds_); | |
885 ASSERT_EQ(1U, candidate_list.size()); | 951 ASSERT_EQ(1U, candidate_list.size()); |
886 EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_180, candidate_list.back().transform); | 952 EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_180, candidate_list.back().transform); |
887 } | 953 } |
888 | 954 |
889 TEST_F(UnderlayTest, Allow270DegreeRotation) { | 955 TEST_F(UnderlayTest, Allow270DegreeRotation) { |
890 gfx::Rect rect = kOverlayRect; | 956 gfx::Rect rect = kOverlayRect; |
891 rect.Offset(-rect.width(), 0); | 957 rect.Offset(-rect.width(), 0); |
892 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 958 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
893 CreateCandidateQuadAt(resource_provider_.get(), | 959 CreateCandidateQuadAt(resource_provider_.get(), |
894 pass->shared_quad_state_list.back(), pass.get(), rect); | 960 pass->shared_quad_state_list.back(), pass.get(), rect); |
895 pass->shared_quad_state_list.back() | 961 pass->shared_quad_state_list.back() |
896 ->quad_to_target_transform.RotateAboutZAxis(270.f); | 962 ->quad_to_target_transform.RotateAboutZAxis(270.f); |
897 | 963 |
898 OverlayCandidateList candidate_list; | 964 OverlayCandidateList candidate_list; |
899 RenderPassFilterList render_pass_filters; | 965 RenderPassFilterList render_pass_filters; |
900 RenderPassFilterList render_pass_background_filters; | 966 RenderPassFilterList render_pass_background_filters; |
901 overlay_processor_->ProcessForOverlays( | 967 overlay_processor_->ProcessForOverlays( |
902 resource_provider_.get(), pass.get(), render_pass_filters, | 968 resource_provider_.get(), pass.get(), render_pass_filters, |
903 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 969 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
970 &content_bounds_); | |
904 ASSERT_EQ(1U, candidate_list.size()); | 971 ASSERT_EQ(1U, candidate_list.size()); |
905 EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_270, candidate_list.back().transform); | 972 EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_270, candidate_list.back().transform); |
906 } | 973 } |
907 | 974 |
908 TEST_F(SingleOverlayOnTopTest, AllowNotTopIfNotOccluded) { | 975 TEST_F(SingleOverlayOnTopTest, AllowNotTopIfNotOccluded) { |
976 output_surface_->GetOverlayCandidateValidator()->SetExpectedRect( | |
977 kOverlayBottomRightRect); | |
978 | |
909 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 979 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
910 CreateOpaqueQuadAt(resource_provider_.get(), | 980 CreateOpaqueQuadAt(resource_provider_.get(), |
911 pass->shared_quad_state_list.back(), pass.get(), | 981 pass->shared_quad_state_list.back(), pass.get(), |
912 kOverlayTopLeftRect); | 982 kOverlayTopLeftRect); |
913 CreateCandidateQuadAt(resource_provider_.get(), | 983 CreateCandidateQuadAt(resource_provider_.get(), |
914 pass->shared_quad_state_list.back(), | 984 pass->shared_quad_state_list.back(), |
915 pass.get(), | 985 pass.get(), |
916 kOverlayBottomRightRect); | 986 kOverlayBottomRightRect); |
917 | 987 |
918 OverlayCandidateList candidate_list; | 988 OverlayCandidateList candidate_list; |
919 RenderPassFilterList render_pass_filters; | 989 RenderPassFilterList render_pass_filters; |
920 RenderPassFilterList render_pass_background_filters; | 990 RenderPassFilterList render_pass_background_filters; |
921 overlay_processor_->ProcessForOverlays( | 991 overlay_processor_->ProcessForOverlays( |
922 resource_provider_.get(), pass.get(), render_pass_filters, | 992 resource_provider_.get(), pass.get(), render_pass_filters, |
923 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 993 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
994 &content_bounds_); | |
924 EXPECT_EQ(1U, candidate_list.size()); | 995 EXPECT_EQ(1U, candidate_list.size()); |
925 } | 996 } |
926 | 997 |
927 TEST_F(SingleOverlayOnTopTest, AllowTransparentOnTop) { | 998 TEST_F(SingleOverlayOnTopTest, AllowTransparentOnTop) { |
999 output_surface_->GetOverlayCandidateValidator()->SetExpectedRect( | |
1000 kOverlayBottomRightRect); | |
1001 | |
928 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1002 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
929 SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState(); | 1003 SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState(); |
930 shared_state->opacity = 0.f; | 1004 shared_state->opacity = 0.f; |
931 CreateSolidColorQuadAt(shared_state, SK_ColorBLACK, pass.get(), | 1005 CreateSolidColorQuadAt(shared_state, SK_ColorBLACK, pass.get(), |
932 kOverlayBottomRightRect); | 1006 kOverlayBottomRightRect); |
933 shared_state = pass->CreateAndAppendSharedQuadState(); | 1007 shared_state = pass->CreateAndAppendSharedQuadState(); |
934 shared_state->opacity = 1.f; | 1008 shared_state->opacity = 1.f; |
935 CreateCandidateQuadAt(resource_provider_.get(), shared_state, pass.get(), | 1009 CreateCandidateQuadAt(resource_provider_.get(), shared_state, pass.get(), |
936 kOverlayBottomRightRect); | 1010 kOverlayBottomRightRect); |
937 | 1011 |
938 OverlayCandidateList candidate_list; | 1012 OverlayCandidateList candidate_list; |
939 RenderPassFilterList render_pass_filters; | 1013 RenderPassFilterList render_pass_filters; |
940 RenderPassFilterList render_pass_background_filters; | 1014 RenderPassFilterList render_pass_background_filters; |
941 overlay_processor_->ProcessForOverlays( | 1015 overlay_processor_->ProcessForOverlays( |
942 resource_provider_.get(), pass.get(), render_pass_filters, | 1016 resource_provider_.get(), pass.get(), render_pass_filters, |
943 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 1017 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
1018 &content_bounds_); | |
944 EXPECT_EQ(1U, candidate_list.size()); | 1019 EXPECT_EQ(1U, candidate_list.size()); |
945 } | 1020 } |
946 | 1021 |
947 TEST_F(SingleOverlayOnTopTest, AllowTransparentColorOnTop) { | 1022 TEST_F(SingleOverlayOnTopTest, AllowTransparentColorOnTop) { |
1023 output_surface_->GetOverlayCandidateValidator()->SetExpectedRect( | |
1024 kOverlayBottomRightRect); | |
1025 | |
948 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1026 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
949 CreateSolidColorQuadAt(pass->shared_quad_state_list.back(), | 1027 CreateSolidColorQuadAt(pass->shared_quad_state_list.back(), |
950 SK_ColorTRANSPARENT, pass.get(), | 1028 SK_ColorTRANSPARENT, pass.get(), |
951 kOverlayBottomRightRect); | 1029 kOverlayBottomRightRect); |
952 CreateCandidateQuadAt(resource_provider_.get(), | 1030 CreateCandidateQuadAt(resource_provider_.get(), |
953 pass->shared_quad_state_list.back(), pass.get(), | 1031 pass->shared_quad_state_list.back(), pass.get(), |
954 kOverlayBottomRightRect); | 1032 kOverlayBottomRightRect); |
955 | 1033 |
956 OverlayCandidateList candidate_list; | 1034 OverlayCandidateList candidate_list; |
957 RenderPassFilterList render_pass_filters; | 1035 RenderPassFilterList render_pass_filters; |
958 RenderPassFilterList render_pass_background_filters; | 1036 RenderPassFilterList render_pass_background_filters; |
959 overlay_processor_->ProcessForOverlays( | 1037 overlay_processor_->ProcessForOverlays( |
960 resource_provider_.get(), pass.get(), render_pass_filters, | 1038 resource_provider_.get(), pass.get(), render_pass_filters, |
961 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 1039 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
1040 &content_bounds_); | |
962 EXPECT_EQ(1U, candidate_list.size()); | 1041 EXPECT_EQ(1U, candidate_list.size()); |
963 } | 1042 } |
964 | 1043 |
965 TEST_F(SingleOverlayOnTopTest, RejectOpaqueColorOnTop) { | 1044 TEST_F(SingleOverlayOnTopTest, RejectOpaqueColorOnTop) { |
966 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1045 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
967 SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState(); | 1046 SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState(); |
968 shared_state->opacity = 0.5f; | 1047 shared_state->opacity = 0.5f; |
969 CreateSolidColorQuadAt(shared_state, SK_ColorBLACK, pass.get(), | 1048 CreateSolidColorQuadAt(shared_state, SK_ColorBLACK, pass.get(), |
970 kOverlayBottomRightRect); | 1049 kOverlayBottomRightRect); |
971 shared_state = pass->CreateAndAppendSharedQuadState(); | 1050 shared_state = pass->CreateAndAppendSharedQuadState(); |
972 shared_state->opacity = 1.f; | 1051 shared_state->opacity = 1.f; |
973 CreateCandidateQuadAt(resource_provider_.get(), shared_state, pass.get(), | 1052 CreateCandidateQuadAt(resource_provider_.get(), shared_state, pass.get(), |
974 kOverlayBottomRightRect); | 1053 kOverlayBottomRightRect); |
975 | 1054 |
976 OverlayCandidateList candidate_list; | 1055 OverlayCandidateList candidate_list; |
977 RenderPassFilterList render_pass_filters; | 1056 RenderPassFilterList render_pass_filters; |
978 RenderPassFilterList render_pass_background_filters; | 1057 RenderPassFilterList render_pass_background_filters; |
979 overlay_processor_->ProcessForOverlays( | 1058 overlay_processor_->ProcessForOverlays( |
980 resource_provider_.get(), pass.get(), render_pass_filters, | 1059 resource_provider_.get(), pass.get(), render_pass_filters, |
981 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 1060 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
1061 &content_bounds_); | |
982 EXPECT_EQ(0U, candidate_list.size()); | 1062 EXPECT_EQ(0U, candidate_list.size()); |
983 } | 1063 } |
984 | 1064 |
985 TEST_F(SingleOverlayOnTopTest, RejectTransparentColorOnTopWithoutBlending) { | 1065 TEST_F(SingleOverlayOnTopTest, RejectTransparentColorOnTopWithoutBlending) { |
986 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1066 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
987 SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState(); | 1067 SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState(); |
988 CreateSolidColorQuadAt(shared_state, SK_ColorTRANSPARENT, pass.get(), | 1068 CreateSolidColorQuadAt(shared_state, SK_ColorTRANSPARENT, pass.get(), |
989 kOverlayBottomRightRect)->opaque_rect = | 1069 kOverlayBottomRightRect)->opaque_rect = |
990 kOverlayBottomRightRect; | 1070 kOverlayBottomRightRect; |
991 CreateCandidateQuadAt(resource_provider_.get(), shared_state, pass.get(), | 1071 CreateCandidateQuadAt(resource_provider_.get(), shared_state, pass.get(), |
992 kOverlayBottomRightRect); | 1072 kOverlayBottomRightRect); |
993 | 1073 |
994 OverlayCandidateList candidate_list; | 1074 OverlayCandidateList candidate_list; |
995 RenderPassFilterList render_pass_filters; | 1075 RenderPassFilterList render_pass_filters; |
996 RenderPassFilterList render_pass_background_filters; | 1076 RenderPassFilterList render_pass_background_filters; |
997 overlay_processor_->ProcessForOverlays( | 1077 overlay_processor_->ProcessForOverlays( |
998 resource_provider_.get(), pass.get(), render_pass_filters, | 1078 resource_provider_.get(), pass.get(), render_pass_filters, |
999 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 1079 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
1080 &content_bounds_); | |
1000 EXPECT_EQ(0U, candidate_list.size()); | 1081 EXPECT_EQ(0U, candidate_list.size()); |
1001 } | 1082 } |
1002 | 1083 |
1003 TEST_F(SingleOverlayOnTopTest, RejectVideoSwapTransform) { | 1084 TEST_F(SingleOverlayOnTopTest, RejectVideoSwapTransform) { |
1004 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1085 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1005 CreateFullscreenCandidateVideoQuad(resource_provider_.get(), | 1086 CreateFullscreenCandidateVideoQuad(resource_provider_.get(), |
1006 pass->shared_quad_state_list.back(), | 1087 pass->shared_quad_state_list.back(), |
1007 pass.get(), kSwapTransform); | 1088 pass.get(), kSwapTransform); |
1008 | 1089 |
1009 OverlayCandidateList candidate_list; | 1090 OverlayCandidateList candidate_list; |
1010 RenderPassFilterList render_pass_filters; | 1091 RenderPassFilterList render_pass_filters; |
1011 RenderPassFilterList render_pass_background_filters; | 1092 RenderPassFilterList render_pass_background_filters; |
1012 overlay_processor_->ProcessForOverlays( | 1093 overlay_processor_->ProcessForOverlays( |
1013 resource_provider_.get(), pass.get(), render_pass_filters, | 1094 resource_provider_.get(), pass.get(), render_pass_filters, |
1014 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 1095 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
1096 &content_bounds_); | |
1015 EXPECT_EQ(0U, candidate_list.size()); | 1097 EXPECT_EQ(0U, candidate_list.size()); |
1016 } | 1098 } |
1017 | 1099 |
1018 TEST_F(UnderlayTest, AllowVideoXMirrorTransform) { | 1100 TEST_F(UnderlayTest, AllowVideoXMirrorTransform) { |
1019 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1101 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1020 CreateFullscreenCandidateVideoQuad(resource_provider_.get(), | 1102 CreateFullscreenCandidateVideoQuad(resource_provider_.get(), |
1021 pass->shared_quad_state_list.back(), | 1103 pass->shared_quad_state_list.back(), |
1022 pass.get(), kXMirrorTransform); | 1104 pass.get(), kXMirrorTransform); |
1023 | 1105 |
1024 OverlayCandidateList candidate_list; | 1106 OverlayCandidateList candidate_list; |
1025 RenderPassFilterList render_pass_filters; | 1107 RenderPassFilterList render_pass_filters; |
1026 RenderPassFilterList render_pass_background_filters; | 1108 RenderPassFilterList render_pass_background_filters; |
1027 overlay_processor_->ProcessForOverlays( | 1109 overlay_processor_->ProcessForOverlays( |
1028 resource_provider_.get(), pass.get(), render_pass_filters, | 1110 resource_provider_.get(), pass.get(), render_pass_filters, |
1029 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 1111 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
1112 &content_bounds_); | |
1030 EXPECT_EQ(1U, candidate_list.size()); | 1113 EXPECT_EQ(1U, candidate_list.size()); |
1031 } | 1114 } |
1032 | 1115 |
1033 TEST_F(UnderlayTest, AllowVideoBothMirrorTransform) { | 1116 TEST_F(UnderlayTest, AllowVideoBothMirrorTransform) { |
1034 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1117 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1035 CreateFullscreenCandidateVideoQuad(resource_provider_.get(), | 1118 CreateFullscreenCandidateVideoQuad(resource_provider_.get(), |
1036 pass->shared_quad_state_list.back(), | 1119 pass->shared_quad_state_list.back(), |
1037 pass.get(), kBothMirrorTransform); | 1120 pass.get(), kBothMirrorTransform); |
1038 | 1121 |
1039 OverlayCandidateList candidate_list; | 1122 OverlayCandidateList candidate_list; |
1040 RenderPassFilterList render_pass_filters; | 1123 RenderPassFilterList render_pass_filters; |
1041 RenderPassFilterList render_pass_background_filters; | 1124 RenderPassFilterList render_pass_background_filters; |
1042 overlay_processor_->ProcessForOverlays( | 1125 overlay_processor_->ProcessForOverlays( |
1043 resource_provider_.get(), pass.get(), render_pass_filters, | 1126 resource_provider_.get(), pass.get(), render_pass_filters, |
1044 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 1127 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
1128 &content_bounds_); | |
1045 EXPECT_EQ(1U, candidate_list.size()); | 1129 EXPECT_EQ(1U, candidate_list.size()); |
1046 } | 1130 } |
1047 | 1131 |
1048 TEST_F(UnderlayTest, AllowVideoNormalTransform) { | 1132 TEST_F(UnderlayTest, AllowVideoNormalTransform) { |
1049 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1133 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1050 CreateFullscreenCandidateVideoQuad(resource_provider_.get(), | 1134 CreateFullscreenCandidateVideoQuad(resource_provider_.get(), |
1051 pass->shared_quad_state_list.back(), | 1135 pass->shared_quad_state_list.back(), |
1052 pass.get(), kNormalTransform); | 1136 pass.get(), kNormalTransform); |
1053 | 1137 |
1054 OverlayCandidateList candidate_list; | 1138 OverlayCandidateList candidate_list; |
1055 RenderPassFilterList render_pass_filters; | 1139 RenderPassFilterList render_pass_filters; |
1056 RenderPassFilterList render_pass_background_filters; | 1140 RenderPassFilterList render_pass_background_filters; |
1057 overlay_processor_->ProcessForOverlays( | 1141 overlay_processor_->ProcessForOverlays( |
1058 resource_provider_.get(), pass.get(), render_pass_filters, | 1142 resource_provider_.get(), pass.get(), render_pass_filters, |
1059 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 1143 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
1144 &content_bounds_); | |
1060 EXPECT_EQ(1U, candidate_list.size()); | 1145 EXPECT_EQ(1U, candidate_list.size()); |
1061 } | 1146 } |
1062 | 1147 |
1063 TEST_F(SingleOverlayOnTopTest, AllowVideoYMirrorTransform) { | 1148 TEST_F(SingleOverlayOnTopTest, AllowVideoYMirrorTransform) { |
1064 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1149 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1065 CreateFullscreenCandidateVideoQuad(resource_provider_.get(), | 1150 CreateFullscreenCandidateVideoQuad(resource_provider_.get(), |
1066 pass->shared_quad_state_list.back(), | 1151 pass->shared_quad_state_list.back(), |
1067 pass.get(), kYMirrorTransform); | 1152 pass.get(), kYMirrorTransform); |
1068 | 1153 |
1069 OverlayCandidateList candidate_list; | 1154 OverlayCandidateList candidate_list; |
1070 RenderPassFilterList render_pass_filters; | 1155 RenderPassFilterList render_pass_filters; |
1071 RenderPassFilterList render_pass_background_filters; | 1156 RenderPassFilterList render_pass_background_filters; |
1072 overlay_processor_->ProcessForOverlays( | 1157 overlay_processor_->ProcessForOverlays( |
1073 resource_provider_.get(), pass.get(), render_pass_filters, | 1158 resource_provider_.get(), pass.get(), render_pass_filters, |
1074 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 1159 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
1160 &content_bounds_); | |
1075 EXPECT_EQ(1U, candidate_list.size()); | 1161 EXPECT_EQ(1U, candidate_list.size()); |
1076 } | 1162 } |
1077 | 1163 |
1078 TEST_F(UnderlayTest, OverlayLayerUnderMainLayer) { | 1164 TEST_F(UnderlayTest, OverlayLayerUnderMainLayer) { |
1165 output_surface_->GetOverlayCandidateValidator()->SetExpectedRect( | |
1166 kOverlayBottomRightRect); | |
1167 | |
1079 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1168 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1080 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 1169 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
1081 pass->shared_quad_state_list.back(), pass.get()); | 1170 pass->shared_quad_state_list.back(), pass.get()); |
1082 CreateCandidateQuadAt(resource_provider_.get(), | 1171 CreateCandidateQuadAt(resource_provider_.get(), |
1083 pass->shared_quad_state_list.back(), pass.get(), | 1172 pass->shared_quad_state_list.back(), pass.get(), |
1084 kOverlayBottomRightRect); | 1173 kOverlayBottomRightRect); |
1085 | 1174 |
1086 OverlayCandidateList candidate_list; | 1175 OverlayCandidateList candidate_list; |
1087 RenderPassFilterList render_pass_filters; | 1176 RenderPassFilterList render_pass_filters; |
1088 RenderPassFilterList render_pass_background_filters; | 1177 RenderPassFilterList render_pass_background_filters; |
1089 overlay_processor_->ProcessForOverlays( | 1178 overlay_processor_->ProcessForOverlays( |
1090 resource_provider_.get(), pass.get(), render_pass_filters, | 1179 resource_provider_.get(), pass.get(), render_pass_filters, |
1091 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 1180 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
1181 &content_bounds_); | |
1092 ASSERT_EQ(1U, candidate_list.size()); | 1182 ASSERT_EQ(1U, candidate_list.size()); |
1093 EXPECT_EQ(-1, candidate_list[0].plane_z_order); | 1183 EXPECT_EQ(-1, candidate_list[0].plane_z_order); |
1094 EXPECT_EQ(2U, pass->quad_list.size()); | 1184 EXPECT_EQ(2U, pass->quad_list.size()); |
1095 // The overlay quad should have changed to a SOLID_COLOR quad. | 1185 // The overlay quad should have changed to a SOLID_COLOR quad. |
1096 EXPECT_EQ(pass->quad_list.back()->material, DrawQuad::SOLID_COLOR); | 1186 EXPECT_EQ(pass->quad_list.back()->material, DrawQuad::SOLID_COLOR); |
1097 } | 1187 } |
1098 | 1188 |
1099 TEST_F(UnderlayTest, AllowOnTop) { | 1189 TEST_F(UnderlayTest, AllowOnTop) { |
1100 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1190 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1101 CreateFullscreenCandidateQuad(resource_provider_.get(), | 1191 CreateFullscreenCandidateQuad(resource_provider_.get(), |
1102 pass->shared_quad_state_list.back(), | 1192 pass->shared_quad_state_list.back(), |
1103 pass.get()); | 1193 pass.get()); |
1104 pass->CreateAndAppendSharedQuadState()->opacity = 0.5f; | 1194 pass->CreateAndAppendSharedQuadState()->opacity = 0.5f; |
1105 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 1195 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
1106 pass->shared_quad_state_list.back(), pass.get()); | 1196 pass->shared_quad_state_list.back(), pass.get()); |
1107 | 1197 |
1108 OverlayCandidateList candidate_list; | 1198 OverlayCandidateList candidate_list; |
1109 RenderPassFilterList render_pass_filters; | 1199 RenderPassFilterList render_pass_filters; |
1110 RenderPassFilterList render_pass_background_filters; | 1200 RenderPassFilterList render_pass_background_filters; |
1111 overlay_processor_->ProcessForOverlays( | 1201 overlay_processor_->ProcessForOverlays( |
1112 resource_provider_.get(), pass.get(), render_pass_filters, | 1202 resource_provider_.get(), pass.get(), render_pass_filters, |
1113 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 1203 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
1204 &content_bounds_); | |
1114 ASSERT_EQ(1U, candidate_list.size()); | 1205 ASSERT_EQ(1U, candidate_list.size()); |
1115 EXPECT_EQ(-1, candidate_list[0].plane_z_order); | 1206 EXPECT_EQ(-1, candidate_list[0].plane_z_order); |
1116 // The overlay quad should have changed to a SOLID_COLOR quad. | 1207 // The overlay quad should have changed to a SOLID_COLOR quad. |
1117 EXPECT_EQ(pass->quad_list.front()->material, DrawQuad::SOLID_COLOR); | 1208 EXPECT_EQ(pass->quad_list.front()->material, DrawQuad::SOLID_COLOR); |
1118 } | 1209 } |
1119 | 1210 |
1120 // The first time an underlay is scheduled its damage must not be subtracted. | 1211 // The first time an underlay is scheduled its damage must not be subtracted. |
1121 TEST_F(UnderlayTest, InitialUnderlayDamageNotSubtracted) { | 1212 TEST_F(UnderlayTest, InitialUnderlayDamageNotSubtracted) { |
1122 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1213 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1123 CreateFullscreenCandidateQuad(resource_provider_.get(), | 1214 CreateFullscreenCandidateQuad(resource_provider_.get(), |
1124 pass->shared_quad_state_list.back(), | 1215 pass->shared_quad_state_list.back(), |
1125 pass.get()); | 1216 pass.get()); |
1126 | 1217 |
1127 damage_rect_ = kOverlayRect; | 1218 damage_rect_ = kOverlayRect; |
1128 | 1219 |
1129 OverlayCandidateList candidate_list; | 1220 OverlayCandidateList candidate_list; |
1130 RenderPassFilterList render_pass_filters; | 1221 RenderPassFilterList render_pass_filters; |
1131 RenderPassFilterList render_pass_background_filters; | 1222 RenderPassFilterList render_pass_background_filters; |
1132 overlay_processor_->ProcessForOverlays( | 1223 overlay_processor_->ProcessForOverlays( |
1133 resource_provider_.get(), pass.get(), render_pass_filters, | 1224 resource_provider_.get(), pass.get(), render_pass_filters, |
1134 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_); | 1225 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
1226 &content_bounds_); | |
1135 | 1227 |
1136 EXPECT_EQ(kOverlayRect, damage_rect_); | 1228 EXPECT_EQ(kOverlayRect, damage_rect_); |
1137 } | 1229 } |
1138 | 1230 |
1139 // An identical underlay for two frames in a row means the damage can be | 1231 // An identical underlay for two frames in a row means the damage can be |
1140 // subtracted the second time. | 1232 // subtracted the second time. |
1141 TEST_F(UnderlayTest, DamageSubtractedForConsecutiveIdenticalUnderlays) { | 1233 TEST_F(UnderlayTest, DamageSubtractedForConsecutiveIdenticalUnderlays) { |
1142 for (int i = 0; i < 2; ++i) { | 1234 for (int i = 0; i < 2; ++i) { |
1143 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1235 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1144 CreateFullscreenCandidateQuad(resource_provider_.get(), | 1236 CreateFullscreenCandidateQuad(resource_provider_.get(), |
1145 pass->shared_quad_state_list.back(), | 1237 pass->shared_quad_state_list.back(), |
1146 pass.get()); | 1238 pass.get()); |
1147 | 1239 |
1148 damage_rect_ = kOverlayRect; | 1240 damage_rect_ = kOverlayRect; |
1149 | 1241 |
1150 // Add something behind it. | 1242 // Add something behind it. |
1151 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 1243 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
1152 pass->shared_quad_state_list.back(), pass.get()); | 1244 pass->shared_quad_state_list.back(), pass.get()); |
1153 | 1245 |
1154 OverlayCandidateList candidate_list; | 1246 OverlayCandidateList candidate_list; |
1155 RenderPassFilterList render_pass_filters; | 1247 RenderPassFilterList render_pass_filters; |
1156 RenderPassFilterList render_pass_background_filters; | 1248 RenderPassFilterList render_pass_background_filters; |
1157 overlay_processor_->ProcessForOverlays( | 1249 overlay_processor_->ProcessForOverlays( |
1158 resource_provider_.get(), pass.get(), render_pass_filters, | 1250 resource_provider_.get(), pass.get(), render_pass_filters, |
1159 render_pass_background_filters, &candidate_list, nullptr, | 1251 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
1160 &damage_rect_); | 1252 &content_bounds_); |
1161 } | 1253 } |
1162 | 1254 |
1163 // The second time the same overlay rect is scheduled it will be subtracted | 1255 // The second time the same overlay rect is scheduled it will be subtracted |
1164 // from the damage rect. | 1256 // from the damage rect. |
1165 EXPECT_TRUE(damage_rect_.IsEmpty()); | 1257 EXPECT_TRUE(damage_rect_.IsEmpty()); |
1166 } | 1258 } |
1167 | 1259 |
1168 // Underlay damage can only be subtracted if the previous frame's underlay | 1260 // Underlay damage can only be subtracted if the previous frame's underlay |
1169 // was the same rect. | 1261 // was the same rect. |
1170 TEST_F(UnderlayTest, DamageNotSubtractedForNonIdenticalConsecutiveUnderlays) { | 1262 TEST_F(UnderlayTest, DamageNotSubtractedForNonIdenticalConsecutiveUnderlays) { |
1171 gfx::Rect overlay_rects[] = {kOverlayBottomRightRect, kOverlayRect}; | 1263 gfx::Rect overlay_rects[] = {kOverlayBottomRightRect, kOverlayRect}; |
1172 for (int i = 0; i < 2; ++i) { | 1264 for (int i = 0; i < 2; ++i) { |
1265 output_surface_->GetOverlayCandidateValidator()->SetExpectedRect( | |
1266 overlay_rects[i]); | |
1267 | |
1173 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1268 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1174 | 1269 |
1175 CreateCandidateQuadAt(resource_provider_.get(), | 1270 CreateCandidateQuadAt(resource_provider_.get(), |
1176 pass->shared_quad_state_list.back(), pass.get(), | 1271 pass->shared_quad_state_list.back(), pass.get(), |
1177 overlay_rects[i]); | 1272 overlay_rects[i]); |
1178 | 1273 |
1179 damage_rect_ = overlay_rects[i]; | 1274 damage_rect_ = overlay_rects[i]; |
1180 | 1275 |
1181 OverlayCandidateList candidate_list; | 1276 OverlayCandidateList candidate_list; |
1182 RenderPassFilterList render_pass_filters; | 1277 RenderPassFilterList render_pass_filters; |
1183 RenderPassFilterList render_pass_background_filters; | 1278 RenderPassFilterList render_pass_background_filters; |
1184 overlay_processor_->ProcessForOverlays( | 1279 overlay_processor_->ProcessForOverlays( |
1185 resource_provider_.get(), pass.get(), render_pass_filters, | 1280 resource_provider_.get(), pass.get(), render_pass_filters, |
1186 render_pass_background_filters, &candidate_list, nullptr, | 1281 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
1187 &damage_rect_); | 1282 &content_bounds_); |
1188 | 1283 |
1189 EXPECT_EQ(overlay_rects[i], damage_rect_); | 1284 EXPECT_EQ(overlay_rects[i], damage_rect_); |
1190 } | 1285 } |
1191 } | 1286 } |
1192 | 1287 |
1193 TEST_F(UnderlayTest, DamageNotSubtractedWhenQuadsAboveOverlap) { | 1288 TEST_F(UnderlayTest, DamageNotSubtractedWhenQuadsAboveOverlap) { |
1194 for (int i = 0; i < 2; ++i) { | 1289 for (int i = 0; i < 2; ++i) { |
1195 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1290 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1196 // Add an overlapping quad above the candidate. | 1291 // Add an overlapping quad above the candidate. |
1197 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 1292 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
1198 pass->shared_quad_state_list.back(), pass.get()); | 1293 pass->shared_quad_state_list.back(), pass.get()); |
1199 CreateFullscreenCandidateQuad(resource_provider_.get(), | 1294 CreateFullscreenCandidateQuad(resource_provider_.get(), |
1200 pass->shared_quad_state_list.back(), | 1295 pass->shared_quad_state_list.back(), |
1201 pass.get()); | 1296 pass.get()); |
1202 | 1297 |
1203 damage_rect_ = kOverlayRect; | 1298 damage_rect_ = kOverlayRect; |
1204 | 1299 |
1205 OverlayCandidateList candidate_list; | 1300 OverlayCandidateList candidate_list; |
1206 RenderPassFilterList render_pass_filters; | 1301 RenderPassFilterList render_pass_filters; |
1207 RenderPassFilterList render_pass_background_filters; | 1302 RenderPassFilterList render_pass_background_filters; |
1208 overlay_processor_->ProcessForOverlays( | 1303 overlay_processor_->ProcessForOverlays( |
1209 resource_provider_.get(), pass.get(), render_pass_filters, | 1304 resource_provider_.get(), pass.get(), render_pass_filters, |
1210 render_pass_background_filters, &candidate_list, nullptr, | 1305 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
1211 &damage_rect_); | 1306 &content_bounds_); |
1212 } | 1307 } |
1213 | 1308 |
1214 EXPECT_EQ(kOverlayRect, damage_rect_); | 1309 EXPECT_EQ(kOverlayRect, damage_rect_); |
1215 } | 1310 } |
1216 | 1311 |
1217 TEST_F(UnderlayTest, DamageSubtractedWhenQuadsAboveDontOverlap) { | 1312 TEST_F(UnderlayTest, DamageSubtractedWhenQuadsAboveDontOverlap) { |
1313 output_surface_->GetOverlayCandidateValidator()->SetExpectedRect( | |
1314 kOverlayBottomRightRect); | |
1315 | |
1218 for (int i = 0; i < 2; ++i) { | 1316 for (int i = 0; i < 2; ++i) { |
1219 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1317 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1220 // Add a non-overlapping quad above the candidate. | 1318 // Add a non-overlapping quad above the candidate. |
1221 CreateOpaqueQuadAt(resource_provider_.get(), | 1319 CreateOpaqueQuadAt(resource_provider_.get(), |
1222 pass->shared_quad_state_list.back(), pass.get(), | 1320 pass->shared_quad_state_list.back(), pass.get(), |
1223 kOverlayTopLeftRect); | 1321 kOverlayTopLeftRect); |
1224 CreateCandidateQuadAt(resource_provider_.get(), | 1322 CreateCandidateQuadAt(resource_provider_.get(), |
1225 pass->shared_quad_state_list.back(), pass.get(), | 1323 pass->shared_quad_state_list.back(), pass.get(), |
1226 kOverlayBottomRightRect); | 1324 kOverlayBottomRightRect); |
1227 | 1325 |
1228 damage_rect_ = kOverlayBottomRightRect; | 1326 damage_rect_ = kOverlayBottomRightRect; |
1229 | 1327 |
1230 OverlayCandidateList candidate_list; | 1328 OverlayCandidateList candidate_list; |
1231 RenderPassFilterList render_pass_filters; | 1329 RenderPassFilterList render_pass_filters; |
1232 RenderPassFilterList render_pass_background_filters; | 1330 RenderPassFilterList render_pass_background_filters; |
1233 overlay_processor_->ProcessForOverlays( | 1331 overlay_processor_->ProcessForOverlays( |
1234 resource_provider_.get(), pass.get(), render_pass_filters, | 1332 resource_provider_.get(), pass.get(), render_pass_filters, |
1235 render_pass_background_filters, &candidate_list, nullptr, | 1333 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, |
1236 &damage_rect_); | 1334 &content_bounds_); |
1237 } | 1335 } |
1238 | 1336 |
1239 EXPECT_TRUE(damage_rect_.IsEmpty()); | 1337 EXPECT_TRUE(damage_rect_.IsEmpty()); |
1240 } | 1338 } |
1241 | 1339 |
1340 TEST_F(UnderlayCastTest, NoOverlayContentBounds) { | |
1341 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | |
1342 | |
1343 CreateOpaqueQuadAt(resource_provider_.get(), | |
1344 pass->shared_quad_state_list.back(), pass.get(), | |
1345 kOverlayTopLeftRect); | |
1346 | |
1347 OverlayCandidateList candidate_list; | |
1348 RenderPassFilterList render_pass_filters; | |
1349 RenderPassFilterList render_pass_background_filters; | |
1350 overlay_processor_->ProcessForOverlays( | |
1351 resource_provider_.get(), pass.get(), render_pass_filters, | |
1352 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, | |
1353 &content_bounds_); | |
1354 EXPECT_EQ(0U, content_bounds_.size()); | |
1355 } | |
1356 | |
1357 TEST_F(UnderlayCastTest, FullScreenOverlayContentBounds) { | |
1358 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | |
1359 CreateCandidateQuadAt(resource_provider_.get(), | |
1360 pass->shared_quad_state_list.back(), pass.get(), | |
1361 kOverlayRect); | |
1362 | |
1363 OverlayCandidateList candidate_list; | |
1364 RenderPassFilterList render_pass_filters; | |
1365 RenderPassFilterList render_pass_background_filters; | |
1366 overlay_processor_->ProcessForOverlays( | |
1367 resource_provider_.get(), pass.get(), render_pass_filters, | |
1368 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, | |
1369 &content_bounds_); | |
1370 | |
1371 EXPECT_EQ(1U, content_bounds_.size()); | |
1372 EXPECT_TRUE(content_bounds_[0].IsEmpty()); | |
1373 } | |
1374 | |
1375 TEST_F(UnderlayCastTest, BlackOutsideOverlayContentBounds) { | |
1376 output_surface_->GetOverlayCandidateValidator()->SetExpectedRect( | |
1377 kOverlayBottomRightRect); | |
1378 | |
1379 const gfx::Rect kLeftSide(0, 0, 128, 256); | |
1380 const gfx::Rect kTopRight(128, 0, 128, 128); | |
1381 | |
1382 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | |
1383 CreateCandidateQuadAt(resource_provider_.get(), | |
1384 pass->shared_quad_state_list.back(), pass.get(), | |
1385 kOverlayBottomRightRect); | |
1386 CreateOpaqueQuadAt(resource_provider_.get(), | |
1387 pass->shared_quad_state_list.back(), pass.get(), kLeftSide, | |
1388 SK_ColorBLACK); | |
1389 CreateOpaqueQuadAt(resource_provider_.get(), | |
1390 pass->shared_quad_state_list.back(), pass.get(), kTopRight, | |
1391 SK_ColorBLACK); | |
1392 | |
1393 OverlayCandidateList candidate_list; | |
1394 RenderPassFilterList render_pass_filters; | |
1395 RenderPassFilterList render_pass_background_filters; | |
1396 overlay_processor_->ProcessForOverlays( | |
1397 resource_provider_.get(), pass.get(), render_pass_filters, | |
1398 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, | |
1399 &content_bounds_); | |
1400 | |
1401 EXPECT_EQ(1U, content_bounds_.size()); | |
1402 EXPECT_TRUE(content_bounds_[0].IsEmpty()); | |
1403 } | |
1404 | |
1405 TEST_F(UnderlayCastTest, OverlayOccludedContentBounds) { | |
1406 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | |
1407 CreateOpaqueQuadAt(resource_provider_.get(), | |
1408 pass->shared_quad_state_list.back(), pass.get(), | |
1409 kOverlayTopLeftRect); | |
1410 CreateCandidateQuadAt(resource_provider_.get(), | |
1411 pass->shared_quad_state_list.back(), pass.get(), | |
1412 kOverlayRect); | |
1413 | |
1414 OverlayCandidateList candidate_list; | |
1415 RenderPassFilterList render_pass_filters; | |
1416 RenderPassFilterList render_pass_background_filters; | |
1417 overlay_processor_->ProcessForOverlays( | |
1418 resource_provider_.get(), pass.get(), render_pass_filters, | |
1419 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, | |
1420 &content_bounds_); | |
1421 | |
1422 EXPECT_EQ(1U, content_bounds_.size()); | |
1423 EXPECT_EQ(kOverlayTopLeftRect, content_bounds_[0]); | |
1424 } | |
1425 | |
1426 TEST_F(UnderlayCastTest, OverlayOccludedUnionContentBounds) { | |
1427 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | |
1428 CreateOpaqueQuadAt(resource_provider_.get(), | |
1429 pass->shared_quad_state_list.back(), pass.get(), | |
1430 kOverlayTopLeftRect); | |
1431 CreateOpaqueQuadAt(resource_provider_.get(), | |
1432 pass->shared_quad_state_list.back(), pass.get(), | |
1433 kOverlayBottomRightRect); | |
1434 CreateCandidateQuadAt(resource_provider_.get(), | |
1435 pass->shared_quad_state_list.back(), pass.get(), | |
1436 kOverlayRect); | |
1437 | |
1438 OverlayCandidateList candidate_list; | |
1439 RenderPassFilterList render_pass_filters; | |
1440 RenderPassFilterList render_pass_background_filters; | |
1441 overlay_processor_->ProcessForOverlays( | |
1442 resource_provider_.get(), pass.get(), render_pass_filters, | |
1443 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, | |
1444 &content_bounds_); | |
1445 | |
1446 EXPECT_EQ(1U, content_bounds_.size()); | |
1447 EXPECT_EQ(kOverlayRect, content_bounds_[0]); | |
1448 } | |
1449 | |
1450 TEST_F(UnderlayCastTest, RoundOverlayContentBounds) { | |
1451 // Check rounding behaviour on overlay quads. Be conservative (content | |
1452 // potentially visible on boundary). | |
1453 const gfx::Rect overlay_rect(1, 1, 8, 8); | |
1454 output_surface_->GetOverlayCandidateValidator()->SetExpectedRect( | |
1455 gfx::RectF(1.5f, 1.5f, 8, 8)); | |
1456 | |
1457 gfx::Transform transform; | |
1458 transform.Translate(0.5f, 0.5f); | |
1459 | |
1460 std::unique_ptr<RenderPass> pass = CreateRenderPassWithTransform(transform); | |
1461 CreateCandidateQuadAt(resource_provider_.get(), | |
1462 pass->shared_quad_state_list.back(), pass.get(), | |
1463 overlay_rect); | |
1464 CreateOpaqueQuadAt(resource_provider_.get(), | |
1465 pass->shared_quad_state_list.back(), pass.get(), | |
1466 gfx::Rect(0, 0, 10, 10), SK_ColorWHITE); | |
1467 | |
1468 OverlayCandidateList candidate_list; | |
1469 RenderPassFilterList render_pass_filters; | |
1470 RenderPassFilterList render_pass_background_filters; | |
1471 overlay_processor_->ProcessForOverlays( | |
1472 resource_provider_.get(), pass.get(), render_pass_filters, | |
1473 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, | |
1474 &content_bounds_); | |
1475 | |
1476 EXPECT_EQ(1U, content_bounds_.size()); | |
1477 EXPECT_EQ(gfx::Rect(0, 0, 11, 11), content_bounds_[0]); | |
danakj
2017/02/24 22:05:18
fwiw u can skip the position and just pass the siz
| |
1478 } | |
1479 | |
1480 TEST_F(UnderlayCastTest, RoundContentBounds) { | |
1481 // Check rounding behaviour on content quads (bounds should be enclosing | |
1482 // rect). | |
1483 const gfx::Rect overlay_rect(0, 0, 255, 255); | |
danakj
2017/02/24 22:05:18
can you relate this to the kOverlayRect in the tes
halliwell
2017/02/27 22:57:13
Done.
| |
1484 output_surface_->GetOverlayCandidateValidator()->SetExpectedRect( | |
1485 gfx::RectF(0.5f, 0.5f, 255, 255)); | |
1486 | |
1487 gfx::Transform transform; | |
1488 transform.Translate(0.5f, 0.5f); | |
1489 | |
1490 std::unique_ptr<RenderPass> pass = CreateRenderPassWithTransform(transform); | |
1491 CreateCandidateQuadAt(resource_provider_.get(), | |
1492 pass->shared_quad_state_list.back(), pass.get(), | |
1493 overlay_rect); | |
1494 CreateOpaqueQuadAt(resource_provider_.get(), | |
1495 pass->shared_quad_state_list.back(), pass.get(), | |
1496 gfx::Rect(0, 0, 255, 255), SK_ColorWHITE); | |
1497 | |
1498 OverlayCandidateList candidate_list; | |
1499 RenderPassFilterList render_pass_filters; | |
1500 RenderPassFilterList render_pass_background_filters; | |
1501 overlay_processor_->ProcessForOverlays( | |
1502 resource_provider_.get(), pass.get(), render_pass_filters, | |
1503 render_pass_background_filters, &candidate_list, nullptr, &damage_rect_, | |
1504 &content_bounds_); | |
1505 | |
1506 EXPECT_EQ(1U, content_bounds_.size()); | |
1507 EXPECT_EQ(kOverlayRect, content_bounds_[0]); | |
1508 } | |
1509 | |
1242 OverlayCandidateList BackbufferOverlayList(const RenderPass* root_render_pass) { | 1510 OverlayCandidateList BackbufferOverlayList(const RenderPass* root_render_pass) { |
1243 OverlayCandidateList list; | 1511 OverlayCandidateList list; |
1244 OverlayCandidate output_surface_plane; | 1512 OverlayCandidate output_surface_plane; |
1245 output_surface_plane.display_rect = gfx::RectF(root_render_pass->output_rect); | 1513 output_surface_plane.display_rect = gfx::RectF(root_render_pass->output_rect); |
1246 output_surface_plane.quad_rect_in_target_space = | 1514 output_surface_plane.quad_rect_in_target_space = |
1247 root_render_pass->output_rect; | 1515 root_render_pass->output_rect; |
1248 output_surface_plane.use_output_surface_for_resource = true; | 1516 output_surface_plane.use_output_surface_for_resource = true; |
1249 output_surface_plane.overlay_handled = true; | 1517 output_surface_plane.overlay_handled = true; |
1250 list.push_back(output_surface_plane); | 1518 list.push_back(output_surface_plane); |
1251 return list; | 1519 return list; |
1252 } | 1520 } |
1253 | 1521 |
1254 TEST_F(CALayerOverlayTest, AllowNonAxisAlignedTransform) { | 1522 TEST_F(CALayerOverlayTest, AllowNonAxisAlignedTransform) { |
1255 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1523 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1256 CreateFullscreenCandidateQuad(resource_provider_.get(), | 1524 CreateFullscreenCandidateQuad(resource_provider_.get(), |
1257 pass->shared_quad_state_list.back(), | 1525 pass->shared_quad_state_list.back(), |
1258 pass.get()); | 1526 pass.get()); |
1259 pass->shared_quad_state_list.back() | 1527 pass->shared_quad_state_list.back() |
1260 ->quad_to_target_transform.RotateAboutZAxis(45.f); | 1528 ->quad_to_target_transform.RotateAboutZAxis(45.f); |
1261 | 1529 |
1262 gfx::Rect damage_rect; | 1530 gfx::Rect damage_rect; |
1263 CALayerOverlayList ca_layer_list; | 1531 CALayerOverlayList ca_layer_list; |
1264 OverlayCandidateList overlay_list(BackbufferOverlayList(pass.get())); | 1532 OverlayCandidateList overlay_list(BackbufferOverlayList(pass.get())); |
1265 RenderPassFilterList render_pass_filters; | 1533 RenderPassFilterList render_pass_filters; |
1266 RenderPassFilterList render_pass_background_filters; | 1534 RenderPassFilterList render_pass_background_filters; |
1267 overlay_processor_->ProcessForOverlays( | 1535 overlay_processor_->ProcessForOverlays( |
1268 resource_provider_.get(), pass.get(), render_pass_filters, | 1536 resource_provider_.get(), pass.get(), render_pass_filters, |
1269 render_pass_background_filters, &overlay_list, &ca_layer_list, | 1537 render_pass_background_filters, &overlay_list, &ca_layer_list, |
1270 &damage_rect); | 1538 &damage_rect_, &content_bounds_); |
1271 EXPECT_EQ(gfx::Rect(), damage_rect); | 1539 EXPECT_EQ(gfx::Rect(), damage_rect); |
1272 EXPECT_EQ(0U, overlay_list.size()); | 1540 EXPECT_EQ(0U, overlay_list.size()); |
1273 EXPECT_EQ(1U, ca_layer_list.size()); | 1541 EXPECT_EQ(1U, ca_layer_list.size()); |
1274 EXPECT_EQ(0U, output_surface_->bind_framebuffer_count()); | 1542 EXPECT_EQ(0U, output_surface_->bind_framebuffer_count()); |
1275 } | 1543 } |
1276 | 1544 |
1277 TEST_F(CALayerOverlayTest, ThreeDTransform) { | 1545 TEST_F(CALayerOverlayTest, ThreeDTransform) { |
1278 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1546 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1279 CreateFullscreenCandidateQuad(resource_provider_.get(), | 1547 CreateFullscreenCandidateQuad(resource_provider_.get(), |
1280 pass->shared_quad_state_list.back(), | 1548 pass->shared_quad_state_list.back(), |
1281 pass.get()); | 1549 pass.get()); |
1282 pass->shared_quad_state_list.back() | 1550 pass->shared_quad_state_list.back() |
1283 ->quad_to_target_transform.RotateAboutXAxis(45.f); | 1551 ->quad_to_target_transform.RotateAboutXAxis(45.f); |
1284 | 1552 |
1285 gfx::Rect damage_rect; | 1553 gfx::Rect damage_rect; |
1286 CALayerOverlayList ca_layer_list; | 1554 CALayerOverlayList ca_layer_list; |
1287 OverlayCandidateList overlay_list(BackbufferOverlayList(pass.get())); | 1555 OverlayCandidateList overlay_list(BackbufferOverlayList(pass.get())); |
1288 RenderPassFilterList render_pass_filters; | 1556 RenderPassFilterList render_pass_filters; |
1289 RenderPassFilterList render_pass_background_filters; | 1557 RenderPassFilterList render_pass_background_filters; |
1290 overlay_processor_->ProcessForOverlays( | 1558 overlay_processor_->ProcessForOverlays( |
1291 resource_provider_.get(), pass.get(), render_pass_filters, | 1559 resource_provider_.get(), pass.get(), render_pass_filters, |
1292 render_pass_background_filters, &overlay_list, &ca_layer_list, | 1560 render_pass_background_filters, &overlay_list, &ca_layer_list, |
1293 &damage_rect); | 1561 &damage_rect_, &content_bounds_); |
1294 EXPECT_EQ(0U, overlay_list.size()); | 1562 EXPECT_EQ(0U, overlay_list.size()); |
1295 EXPECT_EQ(1U, ca_layer_list.size()); | 1563 EXPECT_EQ(1U, ca_layer_list.size()); |
1296 gfx::Transform expected_transform; | 1564 gfx::Transform expected_transform; |
1297 expected_transform.RotateAboutXAxis(45.f); | 1565 expected_transform.RotateAboutXAxis(45.f); |
1298 gfx::Transform actual_transform(ca_layer_list.back().shared_state->transform); | 1566 gfx::Transform actual_transform(ca_layer_list.back().shared_state->transform); |
1299 EXPECT_EQ(expected_transform.ToString(), actual_transform.ToString()); | 1567 EXPECT_EQ(expected_transform.ToString(), actual_transform.ToString()); |
1300 EXPECT_EQ(0U, output_surface_->bind_framebuffer_count()); | 1568 EXPECT_EQ(0U, output_surface_->bind_framebuffer_count()); |
1301 } | 1569 } |
1302 | 1570 |
1303 TEST_F(CALayerOverlayTest, AllowContainingClip) { | 1571 TEST_F(CALayerOverlayTest, AllowContainingClip) { |
1304 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1572 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1305 CreateFullscreenCandidateQuad(resource_provider_.get(), | 1573 CreateFullscreenCandidateQuad(resource_provider_.get(), |
1306 pass->shared_quad_state_list.back(), | 1574 pass->shared_quad_state_list.back(), |
1307 pass.get()); | 1575 pass.get()); |
1308 pass->shared_quad_state_list.back()->is_clipped = true; | 1576 pass->shared_quad_state_list.back()->is_clipped = true; |
1309 pass->shared_quad_state_list.back()->clip_rect = kOverlayRect; | 1577 pass->shared_quad_state_list.back()->clip_rect = kOverlayRect; |
1310 | 1578 |
1311 gfx::Rect damage_rect; | 1579 gfx::Rect damage_rect; |
1312 CALayerOverlayList ca_layer_list; | 1580 CALayerOverlayList ca_layer_list; |
1313 OverlayCandidateList overlay_list(BackbufferOverlayList(pass.get())); | 1581 OverlayCandidateList overlay_list(BackbufferOverlayList(pass.get())); |
1314 RenderPassFilterList render_pass_filters; | 1582 RenderPassFilterList render_pass_filters; |
1315 RenderPassFilterList render_pass_background_filters; | 1583 RenderPassFilterList render_pass_background_filters; |
1316 overlay_processor_->ProcessForOverlays( | 1584 overlay_processor_->ProcessForOverlays( |
1317 resource_provider_.get(), pass.get(), render_pass_filters, | 1585 resource_provider_.get(), pass.get(), render_pass_filters, |
1318 render_pass_background_filters, &overlay_list, &ca_layer_list, | 1586 render_pass_background_filters, &overlay_list, &ca_layer_list, |
1319 &damage_rect); | 1587 &damage_rect_, &content_bounds_); |
1320 EXPECT_EQ(gfx::Rect(), damage_rect); | 1588 EXPECT_EQ(gfx::Rect(), damage_rect); |
1321 EXPECT_EQ(0U, overlay_list.size()); | 1589 EXPECT_EQ(0U, overlay_list.size()); |
1322 EXPECT_EQ(1U, ca_layer_list.size()); | 1590 EXPECT_EQ(1U, ca_layer_list.size()); |
1323 EXPECT_EQ(0U, output_surface_->bind_framebuffer_count()); | 1591 EXPECT_EQ(0U, output_surface_->bind_framebuffer_count()); |
1324 } | 1592 } |
1325 | 1593 |
1326 TEST_F(CALayerOverlayTest, NontrivialClip) { | 1594 TEST_F(CALayerOverlayTest, NontrivialClip) { |
1327 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1595 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1328 CreateFullscreenCandidateQuad(resource_provider_.get(), | 1596 CreateFullscreenCandidateQuad(resource_provider_.get(), |
1329 pass->shared_quad_state_list.back(), | 1597 pass->shared_quad_state_list.back(), |
1330 pass.get()); | 1598 pass.get()); |
1331 pass->shared_quad_state_list.back()->is_clipped = true; | 1599 pass->shared_quad_state_list.back()->is_clipped = true; |
1332 pass->shared_quad_state_list.back()->clip_rect = gfx::Rect(64, 64, 128, 128); | 1600 pass->shared_quad_state_list.back()->clip_rect = gfx::Rect(64, 64, 128, 128); |
1333 | 1601 |
1334 gfx::Rect damage_rect; | 1602 gfx::Rect damage_rect; |
1335 CALayerOverlayList ca_layer_list; | 1603 CALayerOverlayList ca_layer_list; |
1336 OverlayCandidateList overlay_list(BackbufferOverlayList(pass.get())); | 1604 OverlayCandidateList overlay_list(BackbufferOverlayList(pass.get())); |
1337 RenderPassFilterList render_pass_filters; | 1605 RenderPassFilterList render_pass_filters; |
1338 RenderPassFilterList render_pass_background_filters; | 1606 RenderPassFilterList render_pass_background_filters; |
1339 overlay_processor_->ProcessForOverlays( | 1607 overlay_processor_->ProcessForOverlays( |
1340 resource_provider_.get(), pass.get(), render_pass_filters, | 1608 resource_provider_.get(), pass.get(), render_pass_filters, |
1341 render_pass_background_filters, &overlay_list, &ca_layer_list, | 1609 render_pass_background_filters, &overlay_list, &ca_layer_list, |
1342 &damage_rect); | 1610 &damage_rect_, &content_bounds_); |
1343 EXPECT_EQ(gfx::Rect(), damage_rect); | 1611 EXPECT_EQ(gfx::Rect(), damage_rect); |
1344 EXPECT_EQ(0U, overlay_list.size()); | 1612 EXPECT_EQ(0U, overlay_list.size()); |
1345 EXPECT_EQ(1U, ca_layer_list.size()); | 1613 EXPECT_EQ(1U, ca_layer_list.size()); |
1346 EXPECT_TRUE(ca_layer_list.back().shared_state->is_clipped); | 1614 EXPECT_TRUE(ca_layer_list.back().shared_state->is_clipped); |
1347 EXPECT_EQ(gfx::RectF(64, 64, 128, 128), | 1615 EXPECT_EQ(gfx::RectF(64, 64, 128, 128), |
1348 ca_layer_list.back().shared_state->clip_rect); | 1616 ca_layer_list.back().shared_state->clip_rect); |
1349 EXPECT_EQ(0U, output_surface_->bind_framebuffer_count()); | 1617 EXPECT_EQ(0U, output_surface_->bind_framebuffer_count()); |
1350 } | 1618 } |
1351 | 1619 |
1352 TEST_F(CALayerOverlayTest, SkipTransparent) { | 1620 TEST_F(CALayerOverlayTest, SkipTransparent) { |
1353 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1621 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1354 CreateFullscreenCandidateQuad(resource_provider_.get(), | 1622 CreateFullscreenCandidateQuad(resource_provider_.get(), |
1355 pass->shared_quad_state_list.back(), | 1623 pass->shared_quad_state_list.back(), |
1356 pass.get()); | 1624 pass.get()); |
1357 pass->shared_quad_state_list.back()->opacity = 0; | 1625 pass->shared_quad_state_list.back()->opacity = 0; |
1358 | 1626 |
1359 gfx::Rect damage_rect; | 1627 gfx::Rect damage_rect; |
1360 CALayerOverlayList ca_layer_list; | 1628 CALayerOverlayList ca_layer_list; |
1361 OverlayCandidateList overlay_list(BackbufferOverlayList(pass.get())); | 1629 OverlayCandidateList overlay_list(BackbufferOverlayList(pass.get())); |
1362 RenderPassFilterList render_pass_filters; | 1630 RenderPassFilterList render_pass_filters; |
1363 RenderPassFilterList render_pass_background_filters; | 1631 RenderPassFilterList render_pass_background_filters; |
1364 overlay_processor_->ProcessForOverlays( | 1632 overlay_processor_->ProcessForOverlays( |
1365 resource_provider_.get(), pass.get(), render_pass_filters, | 1633 resource_provider_.get(), pass.get(), render_pass_filters, |
1366 render_pass_background_filters, &overlay_list, &ca_layer_list, | 1634 render_pass_background_filters, &overlay_list, &ca_layer_list, |
1367 &damage_rect); | 1635 &damage_rect_, &content_bounds_); |
1368 EXPECT_EQ(gfx::Rect(), damage_rect); | 1636 EXPECT_EQ(gfx::Rect(), damage_rect); |
1369 EXPECT_EQ(0U, overlay_list.size()); | 1637 EXPECT_EQ(0U, overlay_list.size()); |
1370 EXPECT_EQ(0U, ca_layer_list.size()); | 1638 EXPECT_EQ(0U, ca_layer_list.size()); |
1371 EXPECT_EQ(0U, output_surface_->bind_framebuffer_count()); | 1639 EXPECT_EQ(0U, output_surface_->bind_framebuffer_count()); |
1372 } | 1640 } |
1373 | 1641 |
1374 class OverlayInfoRendererGL : public GLRenderer { | 1642 class OverlayInfoRendererGL : public GLRenderer { |
1375 public: | 1643 public: |
1376 OverlayInfoRendererGL(const RendererSettings* settings, | 1644 OverlayInfoRendererGL(const RendererSettings* settings, |
1377 OutputSurface* output_surface, | 1645 OutputSurface* output_surface, |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1412 public: | 1680 public: |
1413 MOCK_METHOD5(Schedule, | 1681 MOCK_METHOD5(Schedule, |
1414 void(int plane_z_order, | 1682 void(int plane_z_order, |
1415 gfx::OverlayTransform plane_transform, | 1683 gfx::OverlayTransform plane_transform, |
1416 unsigned overlay_texture_id, | 1684 unsigned overlay_texture_id, |
1417 const gfx::Rect& display_bounds, | 1685 const gfx::Rect& display_bounds, |
1418 const gfx::RectF& uv_rect)); | 1686 const gfx::RectF& uv_rect)); |
1419 }; | 1687 }; |
1420 | 1688 |
1421 class GLRendererWithOverlaysTest : public testing::Test { | 1689 class GLRendererWithOverlaysTest : public testing::Test { |
1690 using OutputSurfaceType = OverlayOutputSurface<SingleOverlayValidator>; | |
1691 | |
1422 protected: | 1692 protected: |
1423 GLRendererWithOverlaysTest() { | 1693 GLRendererWithOverlaysTest() { |
1424 provider_ = TestContextProvider::Create(); | 1694 provider_ = TestContextProvider::Create(); |
1425 provider_->BindToCurrentThread(); | 1695 provider_->BindToCurrentThread(); |
1426 output_surface_.reset(new OverlayOutputSurface(provider_)); | 1696 output_surface_.reset(new OutputSurfaceType(provider_)); |
1427 output_surface_->BindToClient(&output_surface_client_); | 1697 output_surface_->BindToClient(&output_surface_client_); |
1428 resource_provider_ = FakeResourceProvider::Create(provider_.get(), nullptr); | 1698 resource_provider_ = FakeResourceProvider::Create(provider_.get(), nullptr); |
1429 | 1699 |
1430 provider_->support()->SetScheduleOverlayPlaneCallback(base::Bind( | 1700 provider_->support()->SetScheduleOverlayPlaneCallback(base::Bind( |
1431 &MockOverlayScheduler::Schedule, base::Unretained(&scheduler_))); | 1701 &MockOverlayScheduler::Schedule, base::Unretained(&scheduler_))); |
1432 } | 1702 } |
1433 | 1703 |
1434 void Init(bool use_validator) { | 1704 void Init(bool use_validator) { |
1435 if (use_validator) | 1705 if (use_validator) |
1436 output_surface_->SetOverlayCandidateValidator(new SingleOverlayValidator); | 1706 output_surface_->SetOverlayCandidateValidator(new SingleOverlayValidator); |
(...skipping 22 matching lines...) Expand all Loading... | |
1459 gpu::TextureInUseResponse response; | 1729 gpu::TextureInUseResponse response; |
1460 response.texture = lock.texture_id(); | 1730 response.texture = lock.texture_id(); |
1461 response.in_use = false; | 1731 response.in_use = false; |
1462 gpu::TextureInUseResponses responses; | 1732 gpu::TextureInUseResponses responses; |
1463 responses.push_back(response); | 1733 responses.push_back(response); |
1464 renderer_->DidReceiveTextureInUseResponses(responses); | 1734 renderer_->DidReceiveTextureInUseResponses(responses); |
1465 } | 1735 } |
1466 | 1736 |
1467 RendererSettings settings_; | 1737 RendererSettings settings_; |
1468 FakeOutputSurfaceClient output_surface_client_; | 1738 FakeOutputSurfaceClient output_surface_client_; |
1469 std::unique_ptr<OverlayOutputSurface> output_surface_; | 1739 std::unique_ptr<OutputSurfaceType> output_surface_; |
1470 std::unique_ptr<ResourceProvider> resource_provider_; | 1740 std::unique_ptr<ResourceProvider> resource_provider_; |
1471 std::unique_ptr<OverlayInfoRendererGL> renderer_; | 1741 std::unique_ptr<OverlayInfoRendererGL> renderer_; |
1472 scoped_refptr<TestContextProvider> provider_; | 1742 scoped_refptr<TestContextProvider> provider_; |
1473 MockOverlayScheduler scheduler_; | 1743 MockOverlayScheduler scheduler_; |
1474 }; | 1744 }; |
1475 | 1745 |
1476 TEST_F(GLRendererWithOverlaysTest, OverlayQuadNotDrawn) { | 1746 TEST_F(GLRendererWithOverlaysTest, OverlayQuadNotDrawn) { |
1477 bool use_validator = true; | 1747 bool use_validator = true; |
1478 Init(use_validator); | 1748 Init(use_validator); |
1479 renderer_->set_expect_overlays(true); | 1749 renderer_->set_expect_overlays(true); |
1750 output_surface_->GetOverlayCandidateValidator()->SetExpectedRect( | |
1751 kOverlayBottomRightRect); | |
1752 | |
1480 gfx::Size viewport_size(16, 16); | 1753 gfx::Size viewport_size(16, 16); |
1481 | 1754 |
1482 std::unique_ptr<RenderPass> pass = CreateRenderPass(); | 1755 std::unique_ptr<RenderPass> pass = CreateRenderPass(); |
1483 | 1756 |
1484 CreateCandidateQuadAt(resource_provider_.get(), | 1757 CreateCandidateQuadAt(resource_provider_.get(), |
1485 pass->shared_quad_state_list.back(), pass.get(), | 1758 pass->shared_quad_state_list.back(), pass.get(), |
1486 kOverlayBottomRightRect); | 1759 kOverlayBottomRightRect); |
1487 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 1760 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
1488 pass->shared_quad_state_list.back(), pass.get()); | 1761 pass->shared_quad_state_list.back(), pass.get()); |
1489 CreateFullscreenOpaqueQuad(resource_provider_.get(), | 1762 CreateFullscreenOpaqueQuad(resource_provider_.get(), |
(...skipping 407 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1897 quad_ = pass_->CreateAndAppendDrawQuad<RenderPassDrawQuad>(); | 2170 quad_ = pass_->CreateAndAppendDrawQuad<RenderPassDrawQuad>(); |
1898 render_pass_id_ = 3; | 2171 render_pass_id_ = 3; |
1899 } | 2172 } |
1900 | 2173 |
1901 void ProcessForOverlays() { | 2174 void ProcessForOverlays() { |
1902 gfx::Rect damage_rect; | 2175 gfx::Rect damage_rect; |
1903 overlay_list_ = BackbufferOverlayList(pass_.get()); | 2176 overlay_list_ = BackbufferOverlayList(pass_.get()); |
1904 overlay_processor_->ProcessForOverlays( | 2177 overlay_processor_->ProcessForOverlays( |
1905 resource_provider_.get(), pass_.get(), render_pass_filters_, | 2178 resource_provider_.get(), pass_.get(), render_pass_filters_, |
1906 render_pass_background_filters_, &overlay_list_, &ca_layer_list_, | 2179 render_pass_background_filters_, &overlay_list_, &ca_layer_list_, |
1907 &damage_rect); | 2180 &damage_rect_, &content_bounds_); |
1908 } | 2181 } |
1909 std::unique_ptr<RenderPass> pass_; | 2182 std::unique_ptr<RenderPass> pass_; |
1910 RenderPassDrawQuad* quad_; | 2183 RenderPassDrawQuad* quad_; |
1911 int render_pass_id_; | 2184 int render_pass_id_; |
1912 FilterOperations filters_; | 2185 FilterOperations filters_; |
1913 FilterOperations background_filters_; | 2186 FilterOperations background_filters_; |
1914 RenderPassFilterList render_pass_filters_; | 2187 RenderPassFilterList render_pass_filters_; |
1915 RenderPassFilterList render_pass_background_filters_; | 2188 RenderPassFilterList render_pass_background_filters_; |
1916 CALayerOverlayList ca_layer_list_; | 2189 CALayerOverlayList ca_layer_list_; |
1917 OverlayCandidateList overlay_list_; | 2190 OverlayCandidateList overlay_list_; |
(...skipping 100 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2018 kOverlayRect, render_pass_id_, 2, gfx::Vector2dF(), | 2291 kOverlayRect, render_pass_id_, 2, gfx::Vector2dF(), |
2019 gfx::Size(), gfx::Vector2dF(1, 1), gfx::PointF()); | 2292 gfx::Size(), gfx::Vector2dF(1, 1), gfx::PointF()); |
2020 } | 2293 } |
2021 | 2294 |
2022 ProcessForOverlays(); | 2295 ProcessForOverlays(); |
2023 EXPECT_EQ(0U, ca_layer_list_.size()); | 2296 EXPECT_EQ(0U, ca_layer_list_.size()); |
2024 } | 2297 } |
2025 | 2298 |
2026 } // namespace | 2299 } // namespace |
2027 } // namespace cc | 2300 } // namespace cc |
OLD | NEW |