OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 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 "base/test/null_task_runner.h" |
5 #include "cc/output/compositor_frame.h" | 6 #include "cc/output/compositor_frame.h" |
6 #include "cc/output/copy_output_result.h" | 7 #include "cc/output/copy_output_result.h" |
7 #include "cc/output/delegated_frame_data.h" | 8 #include "cc/output/delegated_frame_data.h" |
8 #include "cc/quads/render_pass.h" | 9 #include "cc/quads/render_pass.h" |
9 #include "cc/resources/shared_bitmap_manager.h" | 10 #include "cc/resources/shared_bitmap_manager.h" |
10 #include "cc/surfaces/display.h" | 11 #include "cc/surfaces/display.h" |
11 #include "cc/surfaces/display_client.h" | 12 #include "cc/surfaces/display_client.h" |
12 #include "cc/surfaces/surface.h" | 13 #include "cc/surfaces/surface.h" |
13 #include "cc/surfaces/surface_factory.h" | 14 #include "cc/surfaces/surface_factory.h" |
14 #include "cc/surfaces/surface_factory_client.h" | 15 #include "cc/surfaces/surface_factory_client.h" |
15 #include "cc/surfaces/surface_id_allocator.h" | 16 #include "cc/surfaces/surface_id_allocator.h" |
16 #include "cc/surfaces/surface_manager.h" | 17 #include "cc/surfaces/surface_manager.h" |
17 #include "cc/test/fake_output_surface.h" | 18 #include "cc/test/fake_output_surface.h" |
| 19 #include "cc/test/scheduler_test_common.h" |
18 #include "cc/test/test_shared_bitmap_manager.h" | 20 #include "cc/test/test_shared_bitmap_manager.h" |
19 #include "testing/gmock/include/gmock/gmock.h" | 21 #include "testing/gmock/include/gmock/gmock.h" |
20 #include "testing/gtest/include/gtest/gtest.h" | 22 #include "testing/gtest/include/gtest/gtest.h" |
21 | 23 |
22 namespace cc { | 24 namespace cc { |
23 namespace { | 25 namespace { |
24 | 26 |
25 class EmptySurfaceFactoryClient : public SurfaceFactoryClient { | 27 class EmptySurfaceFactoryClient : public SurfaceFactoryClient { |
26 public: | 28 public: |
27 void ReturnResources(const ReturnedResourceArray& resources) override {} | 29 void ReturnResources(const ReturnedResourceArray& resources) override {} |
(...skipping 20 matching lines...) Expand all Loading... |
48 | 50 |
49 factory_.SubmitFrame(surface_id, frame.Pass(), | 51 factory_.SubmitFrame(surface_id, frame.Pass(), |
50 SurfaceFactory::DrawCallback()); | 52 SurfaceFactory::DrawCallback()); |
51 } | 53 } |
52 | 54 |
53 SurfaceManager manager_; | 55 SurfaceManager manager_; |
54 EmptySurfaceFactoryClient empty_client_; | 56 EmptySurfaceFactoryClient empty_client_; |
55 SurfaceFactory factory_; | 57 SurfaceFactory factory_; |
56 scoped_ptr<FakeOutputSurface> output_surface_; | 58 scoped_ptr<FakeOutputSurface> output_surface_; |
57 FakeOutputSurface* output_surface_ptr_; | 59 FakeOutputSurface* output_surface_ptr_; |
| 60 FakeBeginFrameSource fake_begin_frame_source_; |
58 scoped_ptr<SharedBitmapManager> shared_bitmap_manager_; | 61 scoped_ptr<SharedBitmapManager> shared_bitmap_manager_; |
59 }; | 62 }; |
60 | 63 |
61 class TestDisplayClient : public DisplayClient { | 64 class TestDisplayClient : public DisplayClient { |
62 public: | 65 public: |
63 TestDisplayClient() : damaged(false), swapped(false) {} | 66 TestDisplayClient() {} |
64 ~TestDisplayClient() override {} | 67 ~TestDisplayClient() override {} |
65 | 68 |
66 void DisplayDamaged() override { damaged = true; } | |
67 void DidSwapBuffers() override { swapped = true; } | |
68 void DidSwapBuffersComplete() override {} | |
69 void CommitVSyncParameters(base::TimeTicks timebase, | 69 void CommitVSyncParameters(base::TimeTicks timebase, |
70 base::TimeDelta interval) override {} | 70 base::TimeDelta interval) override {} |
71 void OutputSurfaceLost() override {} | 71 void OutputSurfaceLost() override {} |
72 void SetMemoryPolicy(const ManagedMemoryPolicy& policy) override {} | 72 void SetMemoryPolicy(const ManagedMemoryPolicy& policy) override {} |
| 73 }; |
| 74 |
| 75 class TestDisplayScheduler : public DisplayScheduler { |
| 76 public: |
| 77 TestDisplayScheduler(DisplaySchedulerClient* client, |
| 78 BeginFrameSource* begin_frame_source) |
| 79 : DisplayScheduler(client, |
| 80 begin_frame_source, |
| 81 make_scoped_refptr(new base::NullTaskRunner), |
| 82 1), |
| 83 damaged(false), |
| 84 entire_display_damaged(false), |
| 85 swapped(false) {} |
| 86 |
| 87 ~TestDisplayScheduler() override {} |
| 88 |
| 89 void EntireDisplayDamaged(SurfaceId root_surface_id) override { |
| 90 entire_display_damaged = true; |
| 91 } |
| 92 |
| 93 void SurfaceDamaged(SurfaceId surface_id) override { damaged = true; } |
| 94 |
| 95 void DidSwapBuffers() override { swapped = true; } |
| 96 |
| 97 void ResetDamageForTest() { |
| 98 damaged = false; |
| 99 entire_display_damaged = false; |
| 100 } |
73 | 101 |
74 bool damaged; | 102 bool damaged; |
| 103 bool entire_display_damaged; |
75 bool swapped; | 104 bool swapped; |
76 }; | 105 }; |
77 | 106 |
78 void CopyCallback(bool* called, scoped_ptr<CopyOutputResult> result) { | 107 void CopyCallback(bool* called, scoped_ptr<CopyOutputResult> result) { |
79 *called = true; | 108 *called = true; |
80 } | 109 } |
81 | 110 |
82 // Check that frame is damaged and swapped only under correct conditions. | 111 // Check that frame is damaged and swapped only under correct conditions. |
83 TEST_F(DisplayTest, DisplayDamaged) { | 112 TEST_F(DisplayTest, DisplayDamaged) { |
84 TestDisplayClient client; | 113 TestDisplayClient client; |
85 RendererSettings settings; | 114 RendererSettings settings; |
86 settings.partial_swap_enabled = true; | 115 settings.partial_swap_enabled = true; |
87 Display display(&client, &manager_, shared_bitmap_manager_.get(), nullptr, | 116 Display display(&client, &manager_, shared_bitmap_manager_.get(), nullptr, |
88 settings); | 117 settings); |
89 | 118 |
90 display.Initialize(output_surface_.Pass()); | 119 TestDisplayScheduler scheduler(&display, &fake_begin_frame_source_); |
| 120 display.Initialize(output_surface_.Pass(), &scheduler); |
91 | 121 |
92 SurfaceId surface_id(7u); | 122 SurfaceId surface_id(7u); |
93 EXPECT_FALSE(client.damaged); | 123 EXPECT_FALSE(scheduler.damaged); |
| 124 EXPECT_FALSE(scheduler.entire_display_damaged); |
94 display.SetSurfaceId(surface_id, 1.f); | 125 display.SetSurfaceId(surface_id, 1.f); |
95 EXPECT_TRUE(client.damaged); | 126 EXPECT_FALSE(scheduler.damaged); |
| 127 EXPECT_TRUE(scheduler.entire_display_damaged); |
96 | 128 |
97 client.damaged = false; | 129 scheduler.ResetDamageForTest(); |
98 display.Resize(gfx::Size(100, 100)); | 130 display.Resize(gfx::Size(100, 100)); |
99 EXPECT_TRUE(client.damaged); | 131 EXPECT_FALSE(scheduler.damaged); |
| 132 EXPECT_TRUE(scheduler.entire_display_damaged); |
100 | 133 |
101 factory_.Create(surface_id); | 134 factory_.Create(surface_id); |
102 | 135 |
103 // First draw from surface should have full damage. | 136 // First draw from surface should have full damage. |
104 RenderPassList pass_list; | 137 RenderPassList pass_list; |
105 scoped_ptr<RenderPass> pass = RenderPass::Create(); | 138 scoped_ptr<RenderPass> pass = RenderPass::Create(); |
106 pass->output_rect = gfx::Rect(0, 0, 100, 100); | 139 pass->output_rect = gfx::Rect(0, 0, 100, 100); |
107 pass->damage_rect = gfx::Rect(10, 10, 1, 1); | 140 pass->damage_rect = gfx::Rect(10, 10, 1, 1); |
108 pass->id = RenderPassId(1, 1); | 141 pass->id = RenderPassId(1, 1); |
109 pass_list.push_back(pass.Pass()); | 142 pass_list.push_back(pass.Pass()); |
110 | 143 |
111 client.damaged = false; | 144 scheduler.ResetDamageForTest(); |
112 SubmitFrame(&pass_list, surface_id); | 145 SubmitFrame(&pass_list, surface_id); |
113 EXPECT_TRUE(client.damaged); | 146 EXPECT_TRUE(scheduler.damaged); |
| 147 EXPECT_FALSE(scheduler.entire_display_damaged); |
114 | 148 |
115 EXPECT_FALSE(client.swapped); | 149 EXPECT_FALSE(scheduler.swapped); |
116 EXPECT_EQ(0u, output_surface_ptr_->num_sent_frames()); | 150 EXPECT_EQ(0u, output_surface_ptr_->num_sent_frames()); |
117 display.Draw(); | 151 display.DrawAndSwap(); |
118 EXPECT_TRUE(client.swapped); | 152 EXPECT_TRUE(scheduler.swapped); |
119 EXPECT_EQ(1u, output_surface_ptr_->num_sent_frames()); | 153 EXPECT_EQ(1u, output_surface_ptr_->num_sent_frames()); |
120 SoftwareFrameData* software_data = | 154 SoftwareFrameData* software_data = |
121 output_surface_ptr_->last_sent_frame().software_frame_data.get(); | 155 output_surface_ptr_->last_sent_frame().software_frame_data.get(); |
122 ASSERT_NE(nullptr, software_data); | 156 ASSERT_NE(nullptr, software_data); |
123 EXPECT_EQ(gfx::Size(100, 100).ToString(), software_data->size.ToString()); | 157 EXPECT_EQ(gfx::Size(100, 100).ToString(), software_data->size.ToString()); |
124 EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(), | 158 EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(), |
125 software_data->damage_rect.ToString()); | 159 software_data->damage_rect.ToString()); |
126 | 160 |
127 { | 161 { |
128 // Only damaged portion should be swapped. | 162 // Only damaged portion should be swapped. |
129 pass = RenderPass::Create(); | 163 pass = RenderPass::Create(); |
130 pass->output_rect = gfx::Rect(0, 0, 100, 100); | 164 pass->output_rect = gfx::Rect(0, 0, 100, 100); |
131 pass->damage_rect = gfx::Rect(10, 10, 1, 1); | 165 pass->damage_rect = gfx::Rect(10, 10, 1, 1); |
132 pass->id = RenderPassId(1, 1); | 166 pass->id = RenderPassId(1, 1); |
133 | 167 |
134 pass_list.push_back(pass.Pass()); | 168 pass_list.push_back(pass.Pass()); |
135 client.damaged = false; | 169 scheduler.ResetDamageForTest(); |
136 SubmitFrame(&pass_list, surface_id); | 170 SubmitFrame(&pass_list, surface_id); |
137 EXPECT_TRUE(client.damaged); | 171 EXPECT_TRUE(scheduler.damaged); |
| 172 EXPECT_FALSE(scheduler.entire_display_damaged); |
138 | 173 |
139 client.swapped = false; | 174 scheduler.swapped = false; |
140 display.Draw(); | 175 display.DrawAndSwap(); |
141 EXPECT_TRUE(client.swapped); | 176 EXPECT_TRUE(scheduler.swapped); |
142 EXPECT_EQ(2u, output_surface_ptr_->num_sent_frames()); | 177 EXPECT_EQ(2u, output_surface_ptr_->num_sent_frames()); |
143 software_data = | 178 software_data = |
144 output_surface_ptr_->last_sent_frame().software_frame_data.get(); | 179 output_surface_ptr_->last_sent_frame().software_frame_data.get(); |
145 ASSERT_NE(nullptr, software_data); | 180 ASSERT_NE(nullptr, software_data); |
146 EXPECT_EQ(gfx::Size(100, 100).ToString(), software_data->size.ToString()); | 181 EXPECT_EQ(gfx::Size(100, 100).ToString(), software_data->size.ToString()); |
147 EXPECT_EQ(gfx::Rect(10, 10, 1, 1).ToString(), | 182 EXPECT_EQ(gfx::Rect(10, 10, 1, 1).ToString(), |
148 software_data->damage_rect.ToString()); | 183 software_data->damage_rect.ToString()); |
149 } | 184 } |
150 | 185 |
151 { | 186 { |
152 // Pass has no damage so shouldn't be swapped. | 187 // Pass has no damage so shouldn't be swapped. |
153 pass = RenderPass::Create(); | 188 pass = RenderPass::Create(); |
154 pass->output_rect = gfx::Rect(0, 0, 100, 100); | 189 pass->output_rect = gfx::Rect(0, 0, 100, 100); |
155 pass->damage_rect = gfx::Rect(10, 10, 0, 0); | 190 pass->damage_rect = gfx::Rect(10, 10, 0, 0); |
156 pass->id = RenderPassId(1, 1); | 191 pass->id = RenderPassId(1, 1); |
157 | 192 |
158 pass_list.push_back(pass.Pass()); | 193 pass_list.push_back(pass.Pass()); |
159 client.damaged = false; | 194 scheduler.ResetDamageForTest(); |
160 SubmitFrame(&pass_list, surface_id); | 195 SubmitFrame(&pass_list, surface_id); |
161 EXPECT_TRUE(client.damaged); | 196 EXPECT_TRUE(scheduler.damaged); |
| 197 EXPECT_FALSE(scheduler.entire_display_damaged); |
162 | 198 |
163 client.swapped = false; | 199 scheduler.swapped = false; |
164 display.Draw(); | 200 display.DrawAndSwap(); |
165 EXPECT_TRUE(client.swapped); | 201 EXPECT_TRUE(scheduler.swapped); |
166 EXPECT_EQ(2u, output_surface_ptr_->num_sent_frames()); | 202 EXPECT_EQ(2u, output_surface_ptr_->num_sent_frames()); |
167 } | 203 } |
168 | 204 |
169 { | 205 { |
170 // Pass is wrong size so shouldn't be swapped. | 206 // Pass is wrong size so shouldn't be swapped. |
171 pass = RenderPass::Create(); | 207 pass = RenderPass::Create(); |
172 pass->output_rect = gfx::Rect(0, 0, 99, 99); | 208 pass->output_rect = gfx::Rect(0, 0, 99, 99); |
173 pass->damage_rect = gfx::Rect(10, 10, 10, 10); | 209 pass->damage_rect = gfx::Rect(10, 10, 10, 10); |
174 pass->id = RenderPassId(1, 1); | 210 pass->id = RenderPassId(1, 1); |
175 | 211 |
176 pass_list.push_back(pass.Pass()); | 212 pass_list.push_back(pass.Pass()); |
177 client.damaged = false; | 213 scheduler.ResetDamageForTest(); |
178 SubmitFrame(&pass_list, surface_id); | 214 SubmitFrame(&pass_list, surface_id); |
179 EXPECT_TRUE(client.damaged); | 215 EXPECT_TRUE(scheduler.damaged); |
| 216 EXPECT_FALSE(scheduler.entire_display_damaged); |
180 | 217 |
181 client.swapped = false; | 218 scheduler.swapped = false; |
182 display.Draw(); | 219 display.DrawAndSwap(); |
183 EXPECT_TRUE(client.swapped); | 220 EXPECT_TRUE(scheduler.swapped); |
184 EXPECT_EQ(2u, output_surface_ptr_->num_sent_frames()); | 221 EXPECT_EQ(2u, output_surface_ptr_->num_sent_frames()); |
185 } | 222 } |
186 | 223 |
187 { | 224 { |
188 // Pass has copy output request so should be swapped. | 225 // Pass has copy output request so should be swapped. |
189 pass = RenderPass::Create(); | 226 pass = RenderPass::Create(); |
190 pass->output_rect = gfx::Rect(0, 0, 100, 100); | 227 pass->output_rect = gfx::Rect(0, 0, 100, 100); |
191 pass->damage_rect = gfx::Rect(10, 10, 0, 0); | 228 pass->damage_rect = gfx::Rect(10, 10, 0, 0); |
192 bool copy_called = false; | 229 bool copy_called = false; |
193 pass->copy_requests.push_back(CopyOutputRequest::CreateRequest( | 230 pass->copy_requests.push_back(CopyOutputRequest::CreateRequest( |
194 base::Bind(&CopyCallback, ©_called))); | 231 base::Bind(&CopyCallback, ©_called))); |
195 pass->id = RenderPassId(1, 1); | 232 pass->id = RenderPassId(1, 1); |
196 | 233 |
197 pass_list.push_back(pass.Pass()); | 234 pass_list.push_back(pass.Pass()); |
198 client.damaged = false; | 235 scheduler.ResetDamageForTest(); |
199 SubmitFrame(&pass_list, surface_id); | 236 SubmitFrame(&pass_list, surface_id); |
200 EXPECT_TRUE(client.damaged); | 237 EXPECT_TRUE(scheduler.damaged); |
| 238 EXPECT_FALSE(scheduler.entire_display_damaged); |
201 | 239 |
202 client.swapped = false; | 240 scheduler.swapped = false; |
203 display.Draw(); | 241 display.DrawAndSwap(); |
204 EXPECT_TRUE(client.swapped); | 242 EXPECT_TRUE(scheduler.swapped); |
205 EXPECT_EQ(3u, output_surface_ptr_->num_sent_frames()); | 243 EXPECT_EQ(3u, output_surface_ptr_->num_sent_frames()); |
206 EXPECT_TRUE(copy_called); | 244 EXPECT_TRUE(copy_called); |
207 } | 245 } |
208 | 246 |
209 // Pass has latency info so should be swapped. | 247 // Pass has latency info so should be swapped. |
210 { | 248 { |
211 pass = RenderPass::Create(); | 249 pass = RenderPass::Create(); |
212 pass->output_rect = gfx::Rect(0, 0, 100, 100); | 250 pass->output_rect = gfx::Rect(0, 0, 100, 100); |
213 pass->damage_rect = gfx::Rect(10, 10, 0, 0); | 251 pass->damage_rect = gfx::Rect(10, 10, 0, 0); |
214 pass->id = RenderPassId(1, 1); | 252 pass->id = RenderPassId(1, 1); |
215 | 253 |
216 pass_list.push_back(pass.Pass()); | 254 pass_list.push_back(pass.Pass()); |
217 client.damaged = false; | 255 scheduler.ResetDamageForTest(); |
218 scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData); | 256 scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData); |
219 pass_list.swap(frame_data->render_pass_list); | 257 pass_list.swap(frame_data->render_pass_list); |
220 | 258 |
221 scoped_ptr<CompositorFrame> frame(new CompositorFrame); | 259 scoped_ptr<CompositorFrame> frame(new CompositorFrame); |
222 frame->delegated_frame_data = frame_data.Pass(); | 260 frame->delegated_frame_data = frame_data.Pass(); |
223 frame->metadata.latency_info.push_back(ui::LatencyInfo()); | 261 frame->metadata.latency_info.push_back(ui::LatencyInfo()); |
224 | 262 |
225 factory_.SubmitFrame(surface_id, frame.Pass(), | 263 factory_.SubmitFrame(surface_id, frame.Pass(), |
226 SurfaceFactory::DrawCallback()); | 264 SurfaceFactory::DrawCallback()); |
227 EXPECT_TRUE(client.damaged); | 265 EXPECT_TRUE(scheduler.damaged); |
| 266 EXPECT_FALSE(scheduler.entire_display_damaged); |
228 | 267 |
229 client.swapped = false; | 268 scheduler.swapped = false; |
230 display.Draw(); | 269 display.DrawAndSwap(); |
231 EXPECT_TRUE(client.swapped); | 270 EXPECT_TRUE(scheduler.swapped); |
232 EXPECT_EQ(4u, output_surface_ptr_->num_sent_frames()); | 271 EXPECT_EQ(4u, output_surface_ptr_->num_sent_frames()); |
233 } | 272 } |
234 | 273 |
235 factory_.Destroy(surface_id); | 274 factory_.Destroy(surface_id); |
236 } | 275 } |
237 | 276 |
238 } // namespace | 277 } // namespace |
239 } // namespace cc | 278 } // namespace cc |
OLD | NEW |