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 "cc/surfaces/display.h" | 5 #include "cc/surfaces/display.h" |
6 | 6 |
7 #include "base/thread_task_runner_handle.h" | 7 #include "base/thread_task_runner_handle.h" |
8 #include "base/trace_event/trace_event.h" | 8 #include "base/trace_event/trace_event.h" |
9 #include "cc/debug/benchmark_instrumentation.h" | 9 #include "cc/debug/benchmark_instrumentation.h" |
10 #include "cc/output/compositor_frame.h" | 10 #include "cc/output/compositor_frame.h" |
11 #include "cc/output/compositor_frame_ack.h" | 11 #include "cc/output/compositor_frame_ack.h" |
12 #include "cc/output/direct_renderer.h" | 12 #include "cc/output/direct_renderer.h" |
13 #include "cc/output/gl_renderer.h" | 13 #include "cc/output/gl_renderer.h" |
14 #include "cc/output/renderer_settings.h" | 14 #include "cc/output/renderer_settings.h" |
15 #include "cc/output/software_renderer.h" | 15 #include "cc/output/software_renderer.h" |
16 #include "cc/output/texture_mailbox_deleter.h" | 16 #include "cc/output/texture_mailbox_deleter.h" |
17 #include "cc/surfaces/display_client.h" | 17 #include "cc/surfaces/display_client.h" |
| 18 #include "cc/surfaces/display_scheduler.h" |
18 #include "cc/surfaces/surface.h" | 19 #include "cc/surfaces/surface.h" |
19 #include "cc/surfaces/surface_aggregator.h" | 20 #include "cc/surfaces/surface_aggregator.h" |
20 #include "cc/surfaces/surface_manager.h" | 21 #include "cc/surfaces/surface_manager.h" |
21 #include "cc/trees/blocking_task_runner.h" | 22 #include "cc/trees/blocking_task_runner.h" |
22 | 23 |
23 namespace cc { | 24 namespace cc { |
24 | 25 |
25 Display::Display(DisplayClient* client, | 26 Display::Display(DisplayClient* client, |
26 SurfaceManager* manager, | 27 SurfaceManager* manager, |
27 SharedBitmapManager* bitmap_manager, | 28 SharedBitmapManager* bitmap_manager, |
28 gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager, | 29 gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager, |
29 const RendererSettings& settings) | 30 const RendererSettings& settings) |
30 : client_(client), | 31 : client_(client), |
31 manager_(manager), | 32 manager_(manager), |
32 bitmap_manager_(bitmap_manager), | 33 bitmap_manager_(bitmap_manager), |
33 gpu_memory_buffer_manager_(gpu_memory_buffer_manager), | 34 gpu_memory_buffer_manager_(gpu_memory_buffer_manager), |
34 settings_(settings), | 35 settings_(settings), |
35 device_scale_factor_(1.f), | 36 device_scale_factor_(1.f), |
| 37 scheduler_(nullptr), |
36 blocking_main_thread_task_runner_( | 38 blocking_main_thread_task_runner_( |
37 BlockingTaskRunner::Create(base::ThreadTaskRunnerHandle::Get())), | 39 BlockingTaskRunner::Create(base::ThreadTaskRunnerHandle::Get())), |
38 texture_mailbox_deleter_( | 40 texture_mailbox_deleter_( |
39 new TextureMailboxDeleter(base::ThreadTaskRunnerHandle::Get())) { | 41 new TextureMailboxDeleter(base::ThreadTaskRunnerHandle::Get())) { |
40 manager_->AddObserver(this); | 42 manager_->AddObserver(this); |
41 } | 43 } |
42 | 44 |
43 Display::~Display() { | 45 Display::~Display() { |
44 manager_->RemoveObserver(this); | 46 manager_->RemoveObserver(this); |
45 if (aggregator_) { | 47 if (aggregator_) { |
46 for (const auto& id_entry : aggregator_->previous_contained_surfaces()) { | 48 for (const auto& id_entry : aggregator_->previous_contained_surfaces()) { |
47 Surface* surface = manager_->GetSurfaceForId(id_entry.first); | 49 Surface* surface = manager_->GetSurfaceForId(id_entry.first); |
48 if (surface) | 50 if (surface) |
49 surface->RunDrawCallbacks(SurfaceDrawStatus::DRAW_SKIPPED); | 51 surface->RunDrawCallbacks(SurfaceDrawStatus::DRAW_SKIPPED); |
50 } | 52 } |
51 } | 53 } |
52 } | 54 } |
53 | 55 |
54 bool Display::Initialize(scoped_ptr<OutputSurface> output_surface) { | 56 bool Display::Initialize(scoped_ptr<OutputSurface> output_surface, |
| 57 DisplayScheduler* scheduler) { |
55 output_surface_ = output_surface.Pass(); | 58 output_surface_ = output_surface.Pass(); |
| 59 scheduler_ = scheduler; |
56 return output_surface_->BindToClient(this); | 60 return output_surface_->BindToClient(this); |
57 } | 61 } |
58 | 62 |
59 void Display::SetSurfaceId(SurfaceId id, float device_scale_factor) { | 63 void Display::SetSurfaceId(SurfaceId id, float device_scale_factor) { |
| 64 if (current_surface_id_ == id && device_scale_factor_ == device_scale_factor) |
| 65 return; |
| 66 |
60 current_surface_id_ = id; | 67 current_surface_id_ = id; |
61 device_scale_factor_ = device_scale_factor; | 68 device_scale_factor_ = device_scale_factor; |
62 client_->DisplayDamaged(); | 69 |
| 70 UpdateRootSurfaceResourcesLocked(); |
| 71 if (scheduler_) |
| 72 scheduler_->EntireDisplayDamaged(id); |
63 } | 73 } |
64 | 74 |
65 void Display::Resize(const gfx::Size& size) { | 75 void Display::Resize(const gfx::Size& size) { |
66 if (size == current_surface_size_) | 76 if (size == current_surface_size_) |
67 return; | 77 return; |
68 // Need to ensure all pending swaps have executed before the window is | 78 // Need to ensure all pending swaps have executed before the window is |
69 // resized, or D3D11 will scale the swap output. | 79 // resized, or D3D11 will scale the swap output. |
70 if (renderer_ && settings_.finish_rendering_on_resize) | 80 if (renderer_ && settings_.finish_rendering_on_resize) |
71 renderer_->Finish(); | 81 renderer_->Finish(); |
72 current_surface_size_ = size; | 82 current_surface_size_ = size; |
73 client_->DisplayDamaged(); | 83 if (scheduler_) |
| 84 scheduler_->EntireDisplayDamaged(current_surface_id_); |
74 } | 85 } |
75 | 86 |
76 void Display::InitializeRenderer() { | 87 void Display::InitializeRenderer() { |
77 if (resource_provider_) | 88 if (resource_provider_) |
78 return; | 89 return; |
79 | 90 |
80 scoped_ptr<ResourceProvider> resource_provider = ResourceProvider::Create( | 91 scoped_ptr<ResourceProvider> resource_provider = ResourceProvider::Create( |
81 output_surface_.get(), bitmap_manager_, gpu_memory_buffer_manager_, | 92 output_surface_.get(), bitmap_manager_, gpu_memory_buffer_manager_, |
82 blocking_main_thread_task_runner_.get(), settings_.highp_threshold_min, | 93 blocking_main_thread_task_runner_.get(), settings_.highp_threshold_min, |
83 settings_.use_rgba_4444_textures, | 94 settings_.use_rgba_4444_textures, |
(...skipping 15 matching lines...) Expand all Loading... |
99 return; | 110 return; |
100 renderer_ = renderer.Pass(); | 111 renderer_ = renderer.Pass(); |
101 } | 112 } |
102 | 113 |
103 resource_provider_ = resource_provider.Pass(); | 114 resource_provider_ = resource_provider.Pass(); |
104 aggregator_.reset(new SurfaceAggregator(manager_, resource_provider_.get())); | 115 aggregator_.reset(new SurfaceAggregator(manager_, resource_provider_.get())); |
105 } | 116 } |
106 | 117 |
107 void Display::DidLoseOutputSurface() { | 118 void Display::DidLoseOutputSurface() { |
108 client_->OutputSurfaceLost(); | 119 client_->OutputSurfaceLost(); |
| 120 if (scheduler_) |
| 121 scheduler_->OutputSurfaceLost(); |
109 } | 122 } |
110 | 123 |
111 bool Display::Draw() { | 124 void Display::UpdateRootSurfaceResourcesLocked() { |
| 125 Surface* surface = manager_->GetSurfaceForId(current_surface_id_); |
| 126 bool root_surface_resources_locked = !surface || !surface->GetEligibleFrame(); |
| 127 if (scheduler_) |
| 128 scheduler_->SetRootSurfaceResourcesLocked(root_surface_resources_locked); |
| 129 } |
| 130 |
| 131 bool Display::DrawAndSwap() { |
112 if (current_surface_id_.is_null()) | 132 if (current_surface_id_.is_null()) |
113 return false; | 133 return false; |
114 | 134 |
115 InitializeRenderer(); | 135 InitializeRenderer(); |
116 if (!output_surface_) | 136 if (!output_surface_) |
117 return false; | 137 return false; |
118 | 138 |
119 // TODO(skyostil): We should hold a BlockingTaskRunner::CapturePostTasks | 139 // TODO(skyostil): We should hold a BlockingTaskRunner::CapturePostTasks |
120 // while Aggregate is called to immediately run release callbacks afterward. | 140 // while Aggregate is called to immediately run release callbacks afterward. |
121 scoped_ptr<CompositorFrame> frame = | 141 scoped_ptr<CompositorFrame> frame = |
122 aggregator_->Aggregate(current_surface_id_); | 142 aggregator_->Aggregate(current_surface_id_); |
123 if (!frame) | 143 if (!frame) |
124 return false; | 144 return false; |
125 | 145 |
126 TRACE_EVENT0("cc", "Display::Draw"); | 146 TRACE_EVENT0("cc", "Display::DrawAndSwap"); |
127 benchmark_instrumentation::IssueDisplayRenderingStatsEvent(); | 147 benchmark_instrumentation::IssueDisplayRenderingStatsEvent(); |
128 | 148 |
129 // Run callbacks early to allow pipelining. | 149 // Run callbacks early to allow pipelining. |
130 for (const auto& id_entry : aggregator_->previous_contained_surfaces()) { | 150 for (const auto& id_entry : aggregator_->previous_contained_surfaces()) { |
131 Surface* surface = manager_->GetSurfaceForId(id_entry.first); | 151 Surface* surface = manager_->GetSurfaceForId(id_entry.first); |
132 if (surface) | 152 if (surface) |
133 surface->RunDrawCallbacks(SurfaceDrawStatus::DRAWN); | 153 surface->RunDrawCallbacks(SurfaceDrawStatus::DRAWN); |
134 } | 154 } |
135 DelegatedFrameData* frame_data = frame->delegated_frame_data.get(); | 155 DelegatedFrameData* frame_data = frame->delegated_frame_data.get(); |
136 | 156 |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
173 frame->metadata.latency_info.begin(), | 193 frame->metadata.latency_info.begin(), |
174 frame->metadata.latency_info.end()); | 194 frame->metadata.latency_info.end()); |
175 DidSwapBuffers(); | 195 DidSwapBuffers(); |
176 DidSwapBuffersComplete(); | 196 DidSwapBuffersComplete(); |
177 } | 197 } |
178 | 198 |
179 return true; | 199 return true; |
180 } | 200 } |
181 | 201 |
182 void Display::DidSwapBuffers() { | 202 void Display::DidSwapBuffers() { |
183 client_->DidSwapBuffers(); | 203 if (scheduler_) |
| 204 scheduler_->DidSwapBuffers(); |
184 } | 205 } |
185 | 206 |
186 void Display::DidSwapBuffersComplete() { | 207 void Display::DidSwapBuffersComplete() { |
187 client_->DidSwapBuffersComplete(); | 208 if (scheduler_) |
| 209 scheduler_->DidSwapBuffersComplete(); |
188 } | 210 } |
189 | 211 |
190 void Display::CommitVSyncParameters(base::TimeTicks timebase, | 212 void Display::CommitVSyncParameters(base::TimeTicks timebase, |
191 base::TimeDelta interval) { | 213 base::TimeDelta interval) { |
192 client_->CommitVSyncParameters(timebase, interval); | 214 client_->CommitVSyncParameters(timebase, interval); |
193 } | 215 } |
194 | 216 |
195 void Display::SetMemoryPolicy(const ManagedMemoryPolicy& policy) { | 217 void Display::SetMemoryPolicy(const ManagedMemoryPolicy& policy) { |
196 client_->SetMemoryPolicy(policy); | 218 client_->SetMemoryPolicy(policy); |
197 } | 219 } |
(...skipping 29 matching lines...) Expand all Loading... |
227 aggregator_->SetFullDamageForSurface(current_surface_id_); | 249 aggregator_->SetFullDamageForSurface(current_surface_id_); |
228 } | 250 } |
229 | 251 |
230 void Display::OnSurfaceDamaged(SurfaceId surface_id, bool* changed) { | 252 void Display::OnSurfaceDamaged(SurfaceId surface_id, bool* changed) { |
231 if (aggregator_ && | 253 if (aggregator_ && |
232 aggregator_->previous_contained_surfaces().count(surface_id)) { | 254 aggregator_->previous_contained_surfaces().count(surface_id)) { |
233 Surface* surface = manager_->GetSurfaceForId(surface_id); | 255 Surface* surface = manager_->GetSurfaceForId(surface_id); |
234 if (surface) { | 256 if (surface) { |
235 const CompositorFrame* current_frame = surface->GetEligibleFrame(); | 257 const CompositorFrame* current_frame = surface->GetEligibleFrame(); |
236 if (!current_frame || !current_frame->delegated_frame_data || | 258 if (!current_frame || !current_frame->delegated_frame_data || |
237 !current_frame->delegated_frame_data->resource_list.size()) | 259 !current_frame->delegated_frame_data->resource_list.size()) { |
238 aggregator_->ReleaseResources(surface_id); | 260 aggregator_->ReleaseResources(surface_id); |
| 261 } |
239 } | 262 } |
240 client_->DisplayDamaged(); | 263 if (scheduler_) |
| 264 scheduler_->SurfaceDamaged(surface_id); |
241 *changed = true; | 265 *changed = true; |
242 } else if (surface_id == current_surface_id_) { | 266 } else if (surface_id == current_surface_id_) { |
243 client_->DisplayDamaged(); | 267 if (scheduler_) |
| 268 scheduler_->SurfaceDamaged(surface_id); |
244 *changed = true; | 269 *changed = true; |
245 } | 270 } |
| 271 |
| 272 if (surface_id == current_surface_id_) |
| 273 UpdateRootSurfaceResourcesLocked(); |
246 } | 274 } |
247 | 275 |
248 SurfaceId Display::CurrentSurfaceId() { | 276 SurfaceId Display::CurrentSurfaceId() { |
249 return current_surface_id_; | 277 return current_surface_id_; |
250 } | 278 } |
251 | 279 |
252 int Display::GetMaxFramesPending() { | |
253 int max_frames_pending = | |
254 output_surface_ ? output_surface_->capabilities().max_frames_pending : 0; | |
255 if (max_frames_pending <= 0) | |
256 max_frames_pending = OutputSurface::DEFAULT_MAX_FRAMES_PENDING; | |
257 return max_frames_pending; | |
258 } | |
259 | |
260 } // namespace cc | 280 } // namespace cc |
OLD | NEW |