1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "ui/compositor/compositor.h"
6
7 #include <algorithm>
8 #include <deque>
9
10 #include "base/bind.h"
11 #include "base/command_line.h"
12 #include "base/debug/trace_event.h"
13 #include "base/message_loop/message_loop.h"
14 #include "base/metrics/histogram.h"
15 #include "base/strings/string_util.h"
16 #include "base/sys_info.h"
17 #include "cc/base/latency_info_swap_promise.h"
18 #include "cc/base/switches.h"
19 #include "cc/input/input_handler.h"
20 #include "cc/layers/layer.h"
21 #include "cc/output/context_provider.h"
22 #include "cc/trees/layer_tree_host.h"
23 #include "third_party/skia/include/core/SkBitmap.h"
24 #include "ui/compositor/compositor_observer.h"
25 #include "ui/compositor/compositor_switches.h"
26 #include "ui/compositor/compositor_vsync_manager.h"
27 #include "ui/compositor/dip_util.h"
28 #include "ui/compositor/layer.h"
29 #include "ui/compositor/layer_animator_collection.h"
30 #include "ui/gfx/frame_time.h"
31 #include "ui/gl/gl_context.h"
32 #include "ui/gl/gl_switches.h"
33
34 namespace {
35
36 const double kDefaultRefreshRate = 60.0;
37 const double kTestRefreshRate = 200.0;
38
39 const int kCompositorLockTimeoutMs = 67;
40
41 } // namespace
42
43 namespace ui {
44
CompositorLock(Compositor * compositor)45 CompositorLock::CompositorLock(Compositor* compositor)
46 : compositor_(compositor) {
47 base::MessageLoop::current()->PostDelayedTask(
48 FROM_HERE,
49 base::Bind(&CompositorLock::CancelLock, AsWeakPtr()),
50 base::TimeDelta::FromMilliseconds(kCompositorLockTimeoutMs));
51 }
52
~CompositorLock()53 CompositorLock::~CompositorLock() {
54 CancelLock();
55 }
56
CancelLock()57 void CompositorLock::CancelLock() {
58 if (!compositor_)
59 return;
60 compositor_->UnlockCompositor();
61 compositor_ = NULL;
62 }
63
64 } // namespace ui
65
66 namespace {
67
68 } // namespace
69
70 namespace ui {
71
Compositor(gfx::AcceleratedWidget widget,ui::ContextFactory * context_factory)72 Compositor::Compositor(gfx::AcceleratedWidget widget,
73 ui::ContextFactory* context_factory)
74 : context_factory_(context_factory),
75 root_layer_(NULL),
76 widget_(widget),
77 compositor_thread_loop_(context_factory->GetCompositorMessageLoop()),
78 vsync_manager_(new CompositorVSyncManager()),
79 device_scale_factor_(0.0f),
80 last_started_frame_(0),
81 last_ended_frame_(0),
82 disable_schedule_composite_(false),
83 compositor_lock_(NULL),
84 defer_draw_scheduling_(false),
85 waiting_on_compositing_end_(false),
86 draw_on_compositing_end_(false),
87 swap_state_(SWAP_NONE),
88 layer_animator_collection_(this),
89 schedule_draw_factory_(this) {
90 root_web_layer_ = cc::Layer::Create();
91
92 CommandLine* command_line = CommandLine::ForCurrentProcess();
93
94 cc::LayerTreeSettings settings;
95 settings.refresh_rate =
96 context_factory_->DoesCreateTestContexts()
97 ? kTestRefreshRate
98 : kDefaultRefreshRate;
99 settings.main_frame_before_draw_enabled = false;
100 settings.main_frame_before_activation_enabled = false;
101 settings.throttle_frame_production =
102 !command_line->HasSwitch(switches::kDisableGpuVsync);
103 #if !defined(OS_MACOSX)
104 settings.partial_swap_enabled =
105 !command_line->HasSwitch(cc::switches::kUIDisablePartialSwap);
106 #endif
107 #if defined(OS_CHROMEOS)
108 settings.per_tile_painting_enabled = true;
109 #endif
110
111 // These flags should be mirrored by renderer versions in content/renderer/.
112 settings.initial_debug_state.show_debug_borders =
113 command_line->HasSwitch(cc::switches::kUIShowCompositedLayerBorders);
114 settings.initial_debug_state.show_fps_counter =
115 command_line->HasSwitch(cc::switches::kUIShowFPSCounter);
116 settings.initial_debug_state.show_layer_animation_bounds_rects =
117 command_line->HasSwitch(cc::switches::kUIShowLayerAnimationBounds);
118 settings.initial_debug_state.show_paint_rects =
119 command_line->HasSwitch(switches::kUIShowPaintRects);
120 settings.initial_debug_state.show_property_changed_rects =
121 command_line->HasSwitch(cc::switches::kUIShowPropertyChangedRects);
122 settings.initial_debug_state.show_surface_damage_rects =
123 command_line->HasSwitch(cc::switches::kUIShowSurfaceDamageRects);
124 settings.initial_debug_state.show_screen_space_rects =
125 command_line->HasSwitch(cc::switches::kUIShowScreenSpaceRects);
126 settings.initial_debug_state.show_replica_screen_space_rects =
127 command_line->HasSwitch(cc::switches::kUIShowReplicaScreenSpaceRects);
128 settings.initial_debug_state.show_occluding_rects =
129 command_line->HasSwitch(cc::switches::kUIShowOccludingRects);
130 settings.initial_debug_state.show_non_occluding_rects =
131 command_line->HasSwitch(cc::switches::kUIShowNonOccludingRects);
132
133 settings.initial_debug_state.SetRecordRenderingStats(
134 command_line->HasSwitch(cc::switches::kEnableGpuBenchmarking));
135
136 settings.impl_side_painting = IsUIImplSidePaintingEnabled();
137 settings.use_zero_copy = IsUIZeroCopyEnabled();
138
139 base::TimeTicks before_create = base::TimeTicks::Now();
140 if (compositor_thread_loop_) {
141 host_ = cc::LayerTreeHost::CreateThreaded(
142 this,
143 context_factory_->GetSharedBitmapManager(),
144 settings,
145 compositor_thread_loop_);
146 } else {
147 host_ = cc::LayerTreeHost::CreateSingleThreaded(
148 this, this, context_factory_->GetSharedBitmapManager(), settings);
149 }
150 UMA_HISTOGRAM_TIMES("GPU.CreateBrowserCompositor",
151 base::TimeTicks::Now() - before_create);
152 host_->SetRootLayer(root_web_layer_);
153 host_->SetLayerTreeHostClientReady();
154 }
155
~Compositor()156 Compositor::~Compositor() {
157 TRACE_EVENT0("shutdown", "Compositor::destructor");
158
159 CancelCompositorLock();
160 DCHECK(!compositor_lock_);
161
162 if (root_layer_)
163 root_layer_->SetCompositor(NULL);
164
165 // Stop all outstanding draws before telling the ContextFactory to tear
166 // down any contexts that the |host_| may rely upon.
167 host_.reset();
168
169 context_factory_->RemoveCompositor(this);
170 }
171
ScheduleDraw()172 void Compositor::ScheduleDraw() {
173 if (compositor_thread_loop_) {
174 host_->SetNeedsCommit();
175 } else if (!defer_draw_scheduling_) {
176 defer_draw_scheduling_ = true;
177 base::MessageLoop::current()->PostTask(
178 FROM_HERE,
179 base::Bind(&Compositor::Draw, schedule_draw_factory_.GetWeakPtr()));
180 }
181 }
182
SetRootLayer(Layer * root_layer)183 void Compositor::SetRootLayer(Layer* root_layer) {
184 if (root_layer_ == root_layer)
185 return;
186 if (root_layer_)
187 root_layer_->SetCompositor(NULL);
188 root_layer_ = root_layer;
189 if (root_layer_ && !root_layer_->GetCompositor())
190 root_layer_->SetCompositor(this);
191 root_web_layer_->RemoveAllChildren();
192 if (root_layer_)
193 root_web_layer_->AddChild(root_layer_->cc_layer());
194 }
195
SetHostHasTransparentBackground(bool host_has_transparent_background)196 void Compositor::SetHostHasTransparentBackground(
197 bool host_has_transparent_background) {
198 host_->set_has_transparent_background(host_has_transparent_background);
199 }
200
Draw()201 void Compositor::Draw() {
202 DCHECK(!compositor_thread_loop_);
203
204 defer_draw_scheduling_ = false;
205 if (waiting_on_compositing_end_) {
206 draw_on_compositing_end_ = true;
207 return;
208 }
209 waiting_on_compositing_end_ = true;
210
211 TRACE_EVENT_ASYNC_BEGIN0("ui", "Compositor::Draw", last_started_frame_ + 1);
212
213 if (!root_layer_)
214 return;
215
216 DCHECK_NE(swap_state_, SWAP_POSTED);
217 swap_state_ = SWAP_NONE;
218
219 last_started_frame_++;
220 if (!IsLocked()) {
221 // TODO(nduca): Temporary while compositor calls
222 // compositeImmediately() directly.
223 base::TimeTicks now = gfx::FrameTime::Now();
224 Animate(now);
225 Layout();
226 host_->Composite(now);
227 }
228 if (swap_state_ == SWAP_NONE)
229 NotifyEnd();
230 }
231
ScheduleFullRedraw()232 void Compositor::ScheduleFullRedraw() {
233 host_->SetNeedsRedraw();
234 }
235
ScheduleRedrawRect(const gfx::Rect & damage_rect)236 void Compositor::ScheduleRedrawRect(const gfx::Rect& damage_rect) {
237 host_->SetNeedsRedrawRect(damage_rect);
238 }
239
FinishAllRendering()240 void Compositor::FinishAllRendering() {
241 host_->FinishAllRendering();
242 }
243
SetLatencyInfo(const ui::LatencyInfo & latency_info)244 void Compositor::SetLatencyInfo(const ui::LatencyInfo& latency_info) {
245 scoped_ptr<cc::SwapPromise> swap_promise(
246 new cc::LatencyInfoSwapPromise(latency_info));
247 host_->QueueSwapPromise(swap_promise.Pass());
248 }
249
SetScaleAndSize(float scale,const gfx::Size & size_in_pixel)250 void Compositor::SetScaleAndSize(float scale, const gfx::Size& size_in_pixel) {
251 DCHECK_GT(scale, 0);
252 if (!size_in_pixel.IsEmpty()) {
253 size_ = size_in_pixel;
254 host_->SetViewportSize(size_in_pixel);
255 root_web_layer_->SetBounds(size_in_pixel);
256 }
257 if (device_scale_factor_ != scale) {
258 device_scale_factor_ = scale;
259 host_->SetDeviceScaleFactor(scale);
260 if (root_layer_)
261 root_layer_->OnDeviceScaleFactorChanged(scale);
262 }
263 }
264
SetBackgroundColor(SkColor color)265 void Compositor::SetBackgroundColor(SkColor color) {
266 host_->set_background_color(color);
267 ScheduleDraw();
268 }
269
vsync_manager() const270 scoped_refptr<CompositorVSyncManager> Compositor::vsync_manager() const {
271 return vsync_manager_;
272 }
273
AddObserver(CompositorObserver * observer)274 void Compositor::AddObserver(CompositorObserver* observer) {
275 observer_list_.AddObserver(observer);
276 }
277
RemoveObserver(CompositorObserver * observer)278 void Compositor::RemoveObserver(CompositorObserver* observer) {
279 observer_list_.RemoveObserver(observer);
280 }
281
HasObserver(CompositorObserver * observer)282 bool Compositor::HasObserver(CompositorObserver* observer) {
283 return observer_list_.HasObserver(observer);
284 }
285
Animate(base::TimeTicks frame_begin_time)286 void Compositor::Animate(base::TimeTicks frame_begin_time) {
287 layer_animator_collection_.Progress(frame_begin_time);
288 if (layer_animator_collection_.HasActiveAnimators())
289 host_->SetNeedsAnimate();
290 }
291
Layout()292 void Compositor::Layout() {
293 // We're sending damage that will be addressed during this composite
294 // cycle, so we don't need to schedule another composite to address it.
295 disable_schedule_composite_ = true;
296 if (root_layer_)
297 root_layer_->SendDamagedRects();
298 disable_schedule_composite_ = false;
299 }
300
CreateOutputSurface(bool fallback)301 scoped_ptr<cc::OutputSurface> Compositor::CreateOutputSurface(bool fallback) {
302 return context_factory_->CreateOutputSurface(this, fallback);
303 }
304
DidCommit()305 void Compositor::DidCommit() {
306 DCHECK(!IsLocked());
307 FOR_EACH_OBSERVER(CompositorObserver,
308 observer_list_,
309 OnCompositingDidCommit(this));
310 }
311
DidCommitAndDrawFrame()312 void Compositor::DidCommitAndDrawFrame() {
313 base::TimeTicks start_time = gfx::FrameTime::Now();
314 FOR_EACH_OBSERVER(CompositorObserver,
315 observer_list_,
316 OnCompositingStarted(this, start_time));
317 }
318
DidCompleteSwapBuffers()319 void Compositor::DidCompleteSwapBuffers() {
320 if (compositor_thread_loop_) {
321 NotifyEnd();
322 } else {
323 DCHECK_EQ(swap_state_, SWAP_POSTED);
324 NotifyEnd();
325 swap_state_ = SWAP_COMPLETED;
326 }
327 }
328
ScheduleComposite()329 void Compositor::ScheduleComposite() {
330 if (!disable_schedule_composite_)
331 ScheduleDraw();
332 }
333
ScheduleAnimation()334 void Compositor::ScheduleAnimation() {
335 ScheduleComposite();
336 }
337
DidPostSwapBuffers()338 void Compositor::DidPostSwapBuffers() {
339 DCHECK(!compositor_thread_loop_);
340 DCHECK_EQ(swap_state_, SWAP_NONE);
341 swap_state_ = SWAP_POSTED;
342 }
343
DidAbortSwapBuffers()344 void Compositor::DidAbortSwapBuffers() {
345 if (!compositor_thread_loop_) {
346 if (swap_state_ == SWAP_POSTED) {
347 NotifyEnd();
348 swap_state_ = SWAP_COMPLETED;
349 }
350 }
351
352 FOR_EACH_OBSERVER(CompositorObserver,
353 observer_list_,
354 OnCompositingAborted(this));
355 }
356
ScheduleAnimationForLayerCollection()357 void Compositor::ScheduleAnimationForLayerCollection() {
358 host_->SetNeedsAnimate();
359 }
360
GetLayerTreeDebugState() const361 const cc::LayerTreeDebugState& Compositor::GetLayerTreeDebugState() const {
362 return host_->debug_state();
363 }
364
SetLayerTreeDebugState(const cc::LayerTreeDebugState & debug_state)365 void Compositor::SetLayerTreeDebugState(
366 const cc::LayerTreeDebugState& debug_state) {
367 host_->SetDebugState(debug_state);
368 }
369
GetCompositorLock()370 scoped_refptr<CompositorLock> Compositor::GetCompositorLock() {
371 if (!compositor_lock_) {
372 compositor_lock_ = new CompositorLock(this);
373 if (compositor_thread_loop_)
374 host_->SetDeferCommits(true);
375 FOR_EACH_OBSERVER(CompositorObserver,
376 observer_list_,
377 OnCompositingLockStateChanged(this));
378 }
379 return compositor_lock_;
380 }
381
UnlockCompositor()382 void Compositor::UnlockCompositor() {
383 DCHECK(compositor_lock_);
384 compositor_lock_ = NULL;
385 if (compositor_thread_loop_)
386 host_->SetDeferCommits(false);
387 FOR_EACH_OBSERVER(CompositorObserver,
388 observer_list_,
389 OnCompositingLockStateChanged(this));
390 }
391
CancelCompositorLock()392 void Compositor::CancelCompositorLock() {
393 if (compositor_lock_)
394 compositor_lock_->CancelLock();
395 }
396
NotifyEnd()397 void Compositor::NotifyEnd() {
398 last_ended_frame_++;
399 TRACE_EVENT_ASYNC_END0("ui", "Compositor::Draw", last_ended_frame_);
400 waiting_on_compositing_end_ = false;
401 if (draw_on_compositing_end_) {
402 draw_on_compositing_end_ = false;
403
404 // Call ScheduleDraw() instead of Draw() in order to allow other
405 // CompositorObservers to be notified before starting another
406 // draw cycle.
407 ScheduleDraw();
408 }
409 FOR_EACH_OBSERVER(CompositorObserver,
410 observer_list_,
411 OnCompositingEnded(this));
412 }
413
414 } // namespace ui
415