1 // Copyright (c) 2013 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 "content/renderer/gpu/render_widget_compositor.h"
6
7 #include <limits>
8 #include <string>
9
10 #if defined(OS_ANDROID)
11 #include "base/android/sys_utils.h"
12 #endif
13
14 #include "base/command_line.h"
15 #include "base/logging.h"
16 #include "base/strings/string_number_conversions.h"
17 #include "base/synchronization/lock.h"
18 #include "base/time/time.h"
19 #include "base/values.h"
20 #include "cc/base/latency_info_swap_promise.h"
21 #include "cc/base/latency_info_swap_promise_monitor.h"
22 #include "cc/base/switches.h"
23 #include "cc/debug/layer_tree_debug_state.h"
24 #include "cc/debug/micro_benchmark.h"
25 #include "cc/layers/layer.h"
26 #include "cc/output/copy_output_request.h"
27 #include "cc/output/copy_output_result.h"
28 #include "cc/resources/single_release_callback.h"
29 #include "cc/trees/layer_tree_host.h"
30 #include "content/child/child_shared_bitmap_manager.h"
31 #include "content/common/content_switches_internal.h"
32 #include "content/common/gpu/client/context_provider_command_buffer.h"
33 #include "content/public/common/content_switches.h"
34 #include "content/renderer/compositor_bindings/web_layer_impl.h"
35 #include "content/renderer/input/input_handler_manager.h"
36 #include "content/renderer/render_thread_impl.h"
37 #include "gpu/command_buffer/client/gles2_interface.h"
38 #include "third_party/WebKit/public/platform/WebCompositeAndReadbackAsyncCallback.h"
39 #include "third_party/WebKit/public/platform/WebSize.h"
40 #include "third_party/WebKit/public/web/WebWidget.h"
41 #include "ui/gfx/frame_time.h"
42 #include "ui/gl/gl_switches.h"
43 #include "ui/native_theme/native_theme_switches.h"
44
45 #if defined(OS_ANDROID)
46 #include "content/renderer/android/synchronous_compositor_factory.h"
47 #endif
48
49 namespace base {
50 class Value;
51 }
52
53 namespace cc {
54 class Layer;
55 }
56
57 using blink::WebFloatPoint;
58 using blink::WebSize;
59 using blink::WebRect;
60
61 namespace content {
62 namespace {
63
GetSwitchValueAsInt(const CommandLine & command_line,const std::string & switch_string,int min_value,int max_value,int * result)64 bool GetSwitchValueAsInt(
65 const CommandLine& command_line,
66 const std::string& switch_string,
67 int min_value,
68 int max_value,
69 int* result) {
70 std::string string_value = command_line.GetSwitchValueASCII(switch_string);
71 int int_value;
72 if (base::StringToInt(string_value, &int_value) &&
73 int_value >= min_value && int_value <= max_value) {
74 *result = int_value;
75 return true;
76 } else {
77 LOG(WARNING) << "Failed to parse switch " << switch_string << ": " <<
78 string_value;
79 return false;
80 }
81 }
82
83 } // namespace
84
85 // static
Create(RenderWidget * widget,bool threaded)86 scoped_ptr<RenderWidgetCompositor> RenderWidgetCompositor::Create(
87 RenderWidget* widget,
88 bool threaded) {
89 scoped_ptr<RenderWidgetCompositor> compositor(
90 new RenderWidgetCompositor(widget, threaded));
91
92 CommandLine* cmd = CommandLine::ForCurrentProcess();
93
94 cc::LayerTreeSettings settings;
95
96 // For web contents, layer transforms should scale up the contents of layers
97 // to keep content always crisp when possible.
98 settings.layer_transforms_should_scale_layer_contents = true;
99
100 settings.throttle_frame_production =
101 !cmd->HasSwitch(switches::kDisableGpuVsync);
102 settings.begin_frame_scheduling_enabled =
103 cmd->HasSwitch(switches::kEnableBeginFrameScheduling);
104 settings.main_frame_before_activation_enabled =
105 cmd->HasSwitch(cc::switches::kEnableMainFrameBeforeActivation) &&
106 !cmd->HasSwitch(cc::switches::kDisableMainFrameBeforeActivation);
107 settings.main_frame_before_draw_enabled =
108 !cmd->HasSwitch(cc::switches::kDisableMainFrameBeforeDraw);
109 settings.report_overscroll_only_for_scrollable_axes = true;
110 settings.accelerated_animation_enabled =
111 !cmd->HasSwitch(cc::switches::kDisableThreadedAnimation);
112 settings.touch_hit_testing =
113 !cmd->HasSwitch(cc::switches::kDisableCompositorTouchHitTesting);
114
115 int default_tile_width = settings.default_tile_size.width();
116 if (cmd->HasSwitch(switches::kDefaultTileWidth)) {
117 GetSwitchValueAsInt(*cmd, switches::kDefaultTileWidth, 1,
118 std::numeric_limits<int>::max(), &default_tile_width);
119 }
120 int default_tile_height = settings.default_tile_size.height();
121 if (cmd->HasSwitch(switches::kDefaultTileHeight)) {
122 GetSwitchValueAsInt(*cmd, switches::kDefaultTileHeight, 1,
123 std::numeric_limits<int>::max(), &default_tile_height);
124 }
125 settings.default_tile_size = gfx::Size(default_tile_width,
126 default_tile_height);
127
128 int max_untiled_layer_width = settings.max_untiled_layer_size.width();
129 if (cmd->HasSwitch(switches::kMaxUntiledLayerWidth)) {
130 GetSwitchValueAsInt(*cmd, switches::kMaxUntiledLayerWidth, 1,
131 std::numeric_limits<int>::max(),
132 &max_untiled_layer_width);
133 }
134 int max_untiled_layer_height = settings.max_untiled_layer_size.height();
135 if (cmd->HasSwitch(switches::kMaxUntiledLayerHeight)) {
136 GetSwitchValueAsInt(*cmd, switches::kMaxUntiledLayerHeight, 1,
137 std::numeric_limits<int>::max(),
138 &max_untiled_layer_height);
139 }
140
141 settings.max_untiled_layer_size = gfx::Size(max_untiled_layer_width,
142 max_untiled_layer_height);
143
144 RenderThreadImpl* render_thread = RenderThreadImpl::current();
145 // render_thread may be NULL in tests.
146 if (render_thread) {
147 settings.impl_side_painting =
148 render_thread->is_impl_side_painting_enabled();
149 settings.gpu_rasterization_forced =
150 render_thread->is_gpu_rasterization_forced();
151 settings.gpu_rasterization_enabled =
152 render_thread->is_gpu_rasterization_enabled();
153 settings.create_low_res_tiling = render_thread->is_low_res_tiling_enabled();
154 settings.can_use_lcd_text = render_thread->is_lcd_text_enabled();
155 settings.use_distance_field_text =
156 render_thread->is_distance_field_text_enabled();
157 settings.use_zero_copy = render_thread->is_zero_copy_enabled();
158 settings.use_one_copy = render_thread->is_one_copy_enabled();
159 }
160
161 if (cmd->HasSwitch(switches::kEnableBleedingEdgeRenderingFastPaths)) {
162 settings.recording_mode = cc::LayerTreeSettings::RecordWithSkRecord;
163 }
164
165 settings.calculate_top_controls_position =
166 cmd->HasSwitch(cc::switches::kEnableTopControlsPositionCalculation);
167 if (cmd->HasSwitch(cc::switches::kTopControlsHeight)) {
168 std::string controls_height_str =
169 cmd->GetSwitchValueASCII(cc::switches::kTopControlsHeight);
170 double controls_height;
171 if (base::StringToDouble(controls_height_str, &controls_height) &&
172 controls_height > 0)
173 settings.top_controls_height = controls_height;
174 }
175
176 if (settings.calculate_top_controls_position &&
177 settings.top_controls_height <= 0) {
178 DCHECK(false)
179 << "Top controls repositioning enabled without valid height set.";
180 settings.calculate_top_controls_position = false;
181 }
182
183 if (cmd->HasSwitch(cc::switches::kTopControlsShowThreshold)) {
184 std::string top_threshold_str =
185 cmd->GetSwitchValueASCII(cc::switches::kTopControlsShowThreshold);
186 double show_threshold;
187 if (base::StringToDouble(top_threshold_str, &show_threshold) &&
188 show_threshold >= 0.f && show_threshold <= 1.f)
189 settings.top_controls_show_threshold = show_threshold;
190 }
191
192 if (cmd->HasSwitch(cc::switches::kTopControlsHideThreshold)) {
193 std::string top_threshold_str =
194 cmd->GetSwitchValueASCII(cc::switches::kTopControlsHideThreshold);
195 double hide_threshold;
196 if (base::StringToDouble(top_threshold_str, &hide_threshold) &&
197 hide_threshold >= 0.f && hide_threshold <= 1.f)
198 settings.top_controls_hide_threshold = hide_threshold;
199 }
200
201 settings.use_pinch_virtual_viewport =
202 cmd->HasSwitch(cc::switches::kEnablePinchVirtualViewport);
203 settings.allow_antialiasing &=
204 !cmd->HasSwitch(cc::switches::kDisableCompositedAntialiasing);
205
206 // These flags should be mirrored by UI versions in ui/compositor/.
207 settings.initial_debug_state.show_debug_borders =
208 cmd->HasSwitch(cc::switches::kShowCompositedLayerBorders);
209 settings.initial_debug_state.show_fps_counter =
210 cmd->HasSwitch(cc::switches::kShowFPSCounter);
211 settings.initial_debug_state.show_layer_animation_bounds_rects =
212 cmd->HasSwitch(cc::switches::kShowLayerAnimationBounds);
213 settings.initial_debug_state.show_paint_rects =
214 cmd->HasSwitch(switches::kShowPaintRects);
215 settings.initial_debug_state.show_property_changed_rects =
216 cmd->HasSwitch(cc::switches::kShowPropertyChangedRects);
217 settings.initial_debug_state.show_surface_damage_rects =
218 cmd->HasSwitch(cc::switches::kShowSurfaceDamageRects);
219 settings.initial_debug_state.show_screen_space_rects =
220 cmd->HasSwitch(cc::switches::kShowScreenSpaceRects);
221 settings.initial_debug_state.show_replica_screen_space_rects =
222 cmd->HasSwitch(cc::switches::kShowReplicaScreenSpaceRects);
223 settings.initial_debug_state.show_occluding_rects =
224 cmd->HasSwitch(cc::switches::kShowOccludingRects);
225 settings.initial_debug_state.show_non_occluding_rects =
226 cmd->HasSwitch(cc::switches::kShowNonOccludingRects);
227
228 settings.initial_debug_state.SetRecordRenderingStats(
229 cmd->HasSwitch(cc::switches::kEnableGpuBenchmarking));
230
231 if (cmd->HasSwitch(cc::switches::kSlowDownRasterScaleFactor)) {
232 const int kMinSlowDownScaleFactor = 0;
233 const int kMaxSlowDownScaleFactor = INT_MAX;
234 GetSwitchValueAsInt(
235 *cmd,
236 cc::switches::kSlowDownRasterScaleFactor,
237 kMinSlowDownScaleFactor,
238 kMaxSlowDownScaleFactor,
239 &settings.initial_debug_state.slow_down_raster_scale_factor);
240 }
241
242 if (cmd->HasSwitch(cc::switches::kMaxTilesForInterestArea)) {
243 int max_tiles_for_interest_area;
244 if (GetSwitchValueAsInt(*cmd,
245 cc::switches::kMaxTilesForInterestArea,
246 1, std::numeric_limits<int>::max(),
247 &max_tiles_for_interest_area))
248 settings.max_tiles_for_interest_area = max_tiles_for_interest_area;
249 }
250
251 if (cmd->HasSwitch(cc::switches::kMaxUnusedResourceMemoryUsagePercentage)) {
252 int max_unused_resource_memory_percentage;
253 if (GetSwitchValueAsInt(
254 *cmd,
255 cc::switches::kMaxUnusedResourceMemoryUsagePercentage,
256 0, 100,
257 &max_unused_resource_memory_percentage)) {
258 settings.max_unused_resource_memory_percentage =
259 max_unused_resource_memory_percentage;
260 }
261 }
262
263 settings.strict_layer_property_change_checking =
264 cmd->HasSwitch(cc::switches::kStrictLayerPropertyChangeChecking);
265
266 #if defined(OS_ANDROID)
267 SynchronousCompositorFactory* synchronous_compositor_factory =
268 SynchronousCompositorFactory::GetInstance();
269
270 settings.using_synchronous_renderer_compositor =
271 synchronous_compositor_factory;
272 settings.record_full_layer =
273 synchronous_compositor_factory &&
274 synchronous_compositor_factory->RecordFullLayer();
275 settings.report_overscroll_only_for_scrollable_axes =
276 !synchronous_compositor_factory;
277 settings.max_partial_texture_updates = 0;
278 if (synchronous_compositor_factory) {
279 // Android WebView uses system scrollbars, so make ours invisible.
280 settings.scrollbar_animator = cc::LayerTreeSettings::NoAnimator;
281 settings.solid_color_scrollbar_color = SK_ColorTRANSPARENT;
282 } else {
283 settings.scrollbar_animator = cc::LayerTreeSettings::LinearFade;
284 settings.scrollbar_fade_delay_ms = 300;
285 settings.scrollbar_fade_duration_ms = 300;
286 settings.solid_color_scrollbar_color = SkColorSetARGB(128, 128, 128, 128);
287 }
288 settings.highp_threshold_min = 2048;
289 // Android WebView handles root layer flings itself.
290 settings.ignore_root_layer_flings =
291 synchronous_compositor_factory;
292 // Memory policy on Android WebView does not depend on whether device is
293 // low end, so always use default policy.
294 bool is_low_end_device =
295 base::android::SysUtils::IsLowEndDevice() &&
296 !synchronous_compositor_factory;
297 // RGBA_4444 textures are only enabled for low end devices
298 // and are disabled for Android WebView as it doesn't support the format.
299 settings.use_rgba_4444_textures = is_low_end_device;
300 if (is_low_end_device) {
301 // On low-end we want to be very carefull about killing other
302 // apps. So initially we use 50% more memory to avoid flickering
303 // or raster-on-demand.
304 settings.max_memory_for_prepaint_percentage = 67;
305 } else {
306 // On other devices we have increased memory excessively to avoid
307 // raster-on-demand already, so now we reserve 50% _only_ to avoid
308 // raster-on-demand, and use 50% of the memory otherwise.
309 settings.max_memory_for_prepaint_percentage = 50;
310 }
311 // Webview does not own the surface so should not clear it.
312 settings.should_clear_root_render_pass =
313 !synchronous_compositor_factory;
314
315 #elif !defined(OS_MACOSX)
316 if (ui::IsOverlayScrollbarEnabled()) {
317 settings.scrollbar_animator = cc::LayerTreeSettings::Thinning;
318 settings.solid_color_scrollbar_color = SkColorSetARGB(128, 128, 128, 128);
319 } else if (cmd->HasSwitch(cc::switches::kEnablePinchVirtualViewport)) {
320 // use_pinch_zoom_scrollbars is only true on desktop when non-overlay
321 // scrollbars are in use.
322 settings.use_pinch_zoom_scrollbars = true;
323 settings.scrollbar_animator = cc::LayerTreeSettings::LinearFade;
324 settings.solid_color_scrollbar_color = SkColorSetARGB(128, 128, 128, 128);
325 }
326 settings.scrollbar_fade_delay_ms = 500;
327 settings.scrollbar_fade_duration_ms = 300;
328 #endif
329
330 compositor->Initialize(settings);
331
332 return compositor.Pass();
333 }
334
RenderWidgetCompositor(RenderWidget * widget,bool threaded)335 RenderWidgetCompositor::RenderWidgetCompositor(RenderWidget* widget,
336 bool threaded)
337 : threaded_(threaded),
338 suppress_schedule_composite_(false),
339 widget_(widget) {
340 }
341
~RenderWidgetCompositor()342 RenderWidgetCompositor::~RenderWidgetCompositor() {}
343
344 const base::WeakPtr<cc::InputHandler>&
GetInputHandler()345 RenderWidgetCompositor::GetInputHandler() {
346 return layer_tree_host_->GetInputHandler();
347 }
348
SetSuppressScheduleComposite(bool suppress)349 void RenderWidgetCompositor::SetSuppressScheduleComposite(bool suppress) {
350 if (suppress_schedule_composite_ == suppress)
351 return;
352
353 if (suppress)
354 TRACE_EVENT_ASYNC_BEGIN0("gpu",
355 "RenderWidgetCompositor::SetSuppressScheduleComposite", this);
356 else
357 TRACE_EVENT_ASYNC_END0("gpu",
358 "RenderWidgetCompositor::SetSuppressScheduleComposite", this);
359 suppress_schedule_composite_ = suppress;
360 }
361
BeginMainFrameRequested() const362 bool RenderWidgetCompositor::BeginMainFrameRequested() const {
363 return layer_tree_host_->BeginMainFrameRequested();
364 }
365
UpdateAnimations(base::TimeTicks time)366 void RenderWidgetCompositor::UpdateAnimations(base::TimeTicks time) {
367 layer_tree_host_->UpdateClientAnimations(time);
368 }
369
SetNeedsDisplayOnAllLayers()370 void RenderWidgetCompositor::SetNeedsDisplayOnAllLayers() {
371 layer_tree_host_->SetNeedsDisplayOnAllLayers();
372 }
373
SetRasterizeOnlyVisibleContent()374 void RenderWidgetCompositor::SetRasterizeOnlyVisibleContent() {
375 cc::LayerTreeDebugState current = layer_tree_host_->debug_state();
376 current.rasterize_only_visible_content = true;
377 layer_tree_host_->SetDebugState(current);
378 }
379
UpdateTopControlsState(cc::TopControlsState constraints,cc::TopControlsState current,bool animate)380 void RenderWidgetCompositor::UpdateTopControlsState(
381 cc::TopControlsState constraints,
382 cc::TopControlsState current,
383 bool animate) {
384 layer_tree_host_->UpdateTopControlsState(constraints,
385 current,
386 animate);
387 }
388
SetOverdrawBottomHeight(float overdraw_bottom_height)389 void RenderWidgetCompositor::SetOverdrawBottomHeight(
390 float overdraw_bottom_height) {
391 layer_tree_host_->SetOverdrawBottomHeight(overdraw_bottom_height);
392 }
393
SetNeedsRedrawRect(gfx::Rect damage_rect)394 void RenderWidgetCompositor::SetNeedsRedrawRect(gfx::Rect damage_rect) {
395 layer_tree_host_->SetNeedsRedrawRect(damage_rect);
396 }
397
SetNeedsForcedRedraw()398 void RenderWidgetCompositor::SetNeedsForcedRedraw() {
399 layer_tree_host_->SetNextCommitForcesRedraw();
400 setNeedsAnimate();
401 }
402
403 scoped_ptr<cc::SwapPromiseMonitor>
CreateLatencyInfoSwapPromiseMonitor(ui::LatencyInfo * latency)404 RenderWidgetCompositor::CreateLatencyInfoSwapPromiseMonitor(
405 ui::LatencyInfo* latency) {
406 return scoped_ptr<cc::SwapPromiseMonitor>(
407 new cc::LatencyInfoSwapPromiseMonitor(
408 latency, layer_tree_host_.get(), NULL));
409 }
410
QueueSwapPromise(scoped_ptr<cc::SwapPromise> swap_promise)411 void RenderWidgetCompositor::QueueSwapPromise(
412 scoped_ptr<cc::SwapPromise> swap_promise) {
413 layer_tree_host_->QueueSwapPromise(swap_promise.Pass());
414 }
415
GetLayerTreeId() const416 int RenderWidgetCompositor::GetLayerTreeId() const {
417 return layer_tree_host_->id();
418 }
419
NotifyInputThrottledUntilCommit()420 void RenderWidgetCompositor::NotifyInputThrottledUntilCommit() {
421 layer_tree_host_->NotifyInputThrottledUntilCommit();
422 }
423
GetRootLayer() const424 const cc::Layer* RenderWidgetCompositor::GetRootLayer() const {
425 return layer_tree_host_->root_layer();
426 }
427
ScheduleMicroBenchmark(const std::string & name,scoped_ptr<base::Value> value,const base::Callback<void (scoped_ptr<base::Value>)> & callback)428 int RenderWidgetCompositor::ScheduleMicroBenchmark(
429 const std::string& name,
430 scoped_ptr<base::Value> value,
431 const base::Callback<void(scoped_ptr<base::Value>)>& callback) {
432 return layer_tree_host_->ScheduleMicroBenchmark(name, value.Pass(), callback);
433 }
434
SendMessageToMicroBenchmark(int id,scoped_ptr<base::Value> value)435 bool RenderWidgetCompositor::SendMessageToMicroBenchmark(
436 int id,
437 scoped_ptr<base::Value> value) {
438 return layer_tree_host_->SendMessageToMicroBenchmark(id, value.Pass());
439 }
440
Initialize(cc::LayerTreeSettings settings)441 void RenderWidgetCompositor::Initialize(cc::LayerTreeSettings settings) {
442 scoped_refptr<base::MessageLoopProxy> compositor_message_loop_proxy;
443 RenderThreadImpl* render_thread = RenderThreadImpl::current();
444 cc::SharedBitmapManager* shared_bitmap_manager = NULL;
445 // render_thread may be NULL in tests.
446 if (render_thread) {
447 compositor_message_loop_proxy =
448 render_thread->compositor_message_loop_proxy();
449 shared_bitmap_manager = render_thread->shared_bitmap_manager();
450 }
451 if (compositor_message_loop_proxy.get()) {
452 layer_tree_host_ = cc::LayerTreeHost::CreateThreaded(
453 this, shared_bitmap_manager, settings, compositor_message_loop_proxy);
454 } else {
455 layer_tree_host_ = cc::LayerTreeHost::CreateSingleThreaded(
456 this, this, shared_bitmap_manager, settings);
457 }
458 DCHECK(layer_tree_host_);
459 }
460
setSurfaceReady()461 void RenderWidgetCompositor::setSurfaceReady() {
462 layer_tree_host_->SetLayerTreeHostClientReady();
463 }
464
setRootLayer(const blink::WebLayer & layer)465 void RenderWidgetCompositor::setRootLayer(const blink::WebLayer& layer) {
466 layer_tree_host_->SetRootLayer(
467 static_cast<const WebLayerImpl*>(&layer)->layer());
468 }
469
clearRootLayer()470 void RenderWidgetCompositor::clearRootLayer() {
471 layer_tree_host_->SetRootLayer(scoped_refptr<cc::Layer>());
472 }
473
setViewportSize(const WebSize &,const WebSize & device_viewport_size)474 void RenderWidgetCompositor::setViewportSize(
475 const WebSize&,
476 const WebSize& device_viewport_size) {
477 layer_tree_host_->SetViewportSize(device_viewport_size);
478 }
479
setViewportSize(const WebSize & device_viewport_size)480 void RenderWidgetCompositor::setViewportSize(
481 const WebSize& device_viewport_size) {
482 layer_tree_host_->SetViewportSize(device_viewport_size);
483 }
484
layoutViewportSize() const485 WebSize RenderWidgetCompositor::layoutViewportSize() const {
486 return layer_tree_host_->device_viewport_size();
487 }
488
deviceViewportSize() const489 WebSize RenderWidgetCompositor::deviceViewportSize() const {
490 return layer_tree_host_->device_viewport_size();
491 }
492
adjustEventPointForPinchZoom(const WebFloatPoint & point) const493 WebFloatPoint RenderWidgetCompositor::adjustEventPointForPinchZoom(
494 const WebFloatPoint& point) const {
495 return point;
496 }
497
setDeviceScaleFactor(float device_scale)498 void RenderWidgetCompositor::setDeviceScaleFactor(float device_scale) {
499 layer_tree_host_->SetDeviceScaleFactor(device_scale);
500 }
501
deviceScaleFactor() const502 float RenderWidgetCompositor::deviceScaleFactor() const {
503 return layer_tree_host_->device_scale_factor();
504 }
505
setBackgroundColor(blink::WebColor color)506 void RenderWidgetCompositor::setBackgroundColor(blink::WebColor color) {
507 layer_tree_host_->set_background_color(color);
508 }
509
setHasTransparentBackground(bool transparent)510 void RenderWidgetCompositor::setHasTransparentBackground(bool transparent) {
511 layer_tree_host_->set_has_transparent_background(transparent);
512 }
513
setOverhangBitmap(const SkBitmap & bitmap)514 void RenderWidgetCompositor::setOverhangBitmap(const SkBitmap& bitmap) {
515 layer_tree_host_->SetOverhangBitmap(bitmap);
516 }
517
setVisible(bool visible)518 void RenderWidgetCompositor::setVisible(bool visible) {
519 layer_tree_host_->SetVisible(visible);
520 }
521
setPageScaleFactorAndLimits(float page_scale_factor,float minimum,float maximum)522 void RenderWidgetCompositor::setPageScaleFactorAndLimits(
523 float page_scale_factor, float minimum, float maximum) {
524 layer_tree_host_->SetPageScaleFactorAndLimits(
525 page_scale_factor, minimum, maximum);
526 }
527
startPageScaleAnimation(const blink::WebPoint & destination,bool use_anchor,float new_page_scale,double duration_sec)528 void RenderWidgetCompositor::startPageScaleAnimation(
529 const blink::WebPoint& destination,
530 bool use_anchor,
531 float new_page_scale,
532 double duration_sec) {
533 base::TimeDelta duration = base::TimeDelta::FromMicroseconds(
534 duration_sec * base::Time::kMicrosecondsPerSecond);
535 layer_tree_host_->StartPageScaleAnimation(
536 gfx::Vector2d(destination.x, destination.y),
537 use_anchor,
538 new_page_scale,
539 duration);
540 }
541
heuristicsForGpuRasterizationUpdated(bool matches_heuristics)542 void RenderWidgetCompositor::heuristicsForGpuRasterizationUpdated(
543 bool matches_heuristics) {
544 layer_tree_host_->SetHasGpuRasterizationTrigger(matches_heuristics);
545 }
546
setNeedsAnimate()547 void RenderWidgetCompositor::setNeedsAnimate() {
548 layer_tree_host_->SetNeedsAnimate();
549 }
550
commitRequested() const551 bool RenderWidgetCompositor::commitRequested() const {
552 return layer_tree_host_->CommitRequested();
553 }
554
didStopFlinging()555 void RenderWidgetCompositor::didStopFlinging() {
556 layer_tree_host_->DidStopFlinging();
557 }
558
registerForAnimations(blink::WebLayer * layer)559 void RenderWidgetCompositor::registerForAnimations(blink::WebLayer* layer) {
560 cc::Layer* cc_layer = static_cast<WebLayerImpl*>(layer)->layer();
561 cc_layer->layer_animation_controller()->SetAnimationRegistrar(
562 layer_tree_host_->animation_registrar());
563 }
564
registerViewportLayers(const blink::WebLayer * pageScaleLayer,const blink::WebLayer * innerViewportScrollLayer,const blink::WebLayer * outerViewportScrollLayer)565 void RenderWidgetCompositor::registerViewportLayers(
566 const blink::WebLayer* pageScaleLayer,
567 const blink::WebLayer* innerViewportScrollLayer,
568 const blink::WebLayer* outerViewportScrollLayer) {
569 layer_tree_host_->RegisterViewportLayers(
570 static_cast<const WebLayerImpl*>(pageScaleLayer)->layer(),
571 static_cast<const WebLayerImpl*>(innerViewportScrollLayer)->layer(),
572 // The outer viewport layer will only exist when using pinch virtual
573 // viewports.
574 outerViewportScrollLayer
575 ? static_cast<const WebLayerImpl*>(outerViewportScrollLayer)->layer()
576 : NULL);
577 }
578
clearViewportLayers()579 void RenderWidgetCompositor::clearViewportLayers() {
580 layer_tree_host_->RegisterViewportLayers(scoped_refptr<cc::Layer>(),
581 scoped_refptr<cc::Layer>(),
582 scoped_refptr<cc::Layer>());
583 }
584
CompositeAndReadbackAsyncCallback(blink::WebCompositeAndReadbackAsyncCallback * callback,scoped_ptr<cc::CopyOutputResult> result)585 void CompositeAndReadbackAsyncCallback(
586 blink::WebCompositeAndReadbackAsyncCallback* callback,
587 scoped_ptr<cc::CopyOutputResult> result) {
588 if (result->HasBitmap()) {
589 scoped_ptr<SkBitmap> result_bitmap = result->TakeBitmap();
590 callback->didCompositeAndReadback(*result_bitmap);
591 } else {
592 callback->didCompositeAndReadback(SkBitmap());
593 }
594 }
595
compositeAndReadbackAsync(blink::WebCompositeAndReadbackAsyncCallback * callback)596 void RenderWidgetCompositor::compositeAndReadbackAsync(
597 blink::WebCompositeAndReadbackAsyncCallback* callback) {
598 DCHECK(layer_tree_host_->root_layer());
599 scoped_ptr<cc::CopyOutputRequest> request =
600 cc::CopyOutputRequest::CreateBitmapRequest(
601 base::Bind(&CompositeAndReadbackAsyncCallback, callback));
602 layer_tree_host_->root_layer()->RequestCopyOfOutput(request.Pass());
603 if (!threaded_) {
604 widget_->webwidget()->animate(0.0);
605 widget_->webwidget()->layout();
606 layer_tree_host_->Composite(gfx::FrameTime::Now());
607 }
608 }
609
finishAllRendering()610 void RenderWidgetCompositor::finishAllRendering() {
611 layer_tree_host_->FinishAllRendering();
612 }
613
setDeferCommits(bool defer_commits)614 void RenderWidgetCompositor::setDeferCommits(bool defer_commits) {
615 layer_tree_host_->SetDeferCommits(defer_commits);
616 }
617
setShowFPSCounter(bool show)618 void RenderWidgetCompositor::setShowFPSCounter(bool show) {
619 cc::LayerTreeDebugState debug_state = layer_tree_host_->debug_state();
620 debug_state.show_fps_counter = show;
621 layer_tree_host_->SetDebugState(debug_state);
622 }
623
setShowPaintRects(bool show)624 void RenderWidgetCompositor::setShowPaintRects(bool show) {
625 cc::LayerTreeDebugState debug_state = layer_tree_host_->debug_state();
626 debug_state.show_paint_rects = show;
627 layer_tree_host_->SetDebugState(debug_state);
628 }
629
setShowDebugBorders(bool show)630 void RenderWidgetCompositor::setShowDebugBorders(bool show) {
631 cc::LayerTreeDebugState debug_state = layer_tree_host_->debug_state();
632 debug_state.show_debug_borders = show;
633 layer_tree_host_->SetDebugState(debug_state);
634 }
635
setContinuousPaintingEnabled(bool enabled)636 void RenderWidgetCompositor::setContinuousPaintingEnabled(bool enabled) {
637 cc::LayerTreeDebugState debug_state = layer_tree_host_->debug_state();
638 debug_state.continuous_painting = enabled;
639 layer_tree_host_->SetDebugState(debug_state);
640 }
641
setShowScrollBottleneckRects(bool show)642 void RenderWidgetCompositor::setShowScrollBottleneckRects(bool show) {
643 cc::LayerTreeDebugState debug_state = layer_tree_host_->debug_state();
644 debug_state.show_touch_event_handler_rects = show;
645 debug_state.show_wheel_event_handler_rects = show;
646 debug_state.show_non_fast_scrollable_rects = show;
647 layer_tree_host_->SetDebugState(debug_state);
648 }
649
WillBeginMainFrame(int frame_id)650 void RenderWidgetCompositor::WillBeginMainFrame(int frame_id) {
651 widget_->InstrumentWillBeginFrame(frame_id);
652 widget_->willBeginCompositorFrame();
653 }
654
DidBeginMainFrame()655 void RenderWidgetCompositor::DidBeginMainFrame() {
656 widget_->InstrumentDidBeginFrame();
657 }
658
Animate(base::TimeTicks frame_begin_time)659 void RenderWidgetCompositor::Animate(base::TimeTicks frame_begin_time) {
660 widget_->webwidget()->animate(
661 (frame_begin_time - base::TimeTicks()).InSecondsF());
662 }
663
Layout()664 void RenderWidgetCompositor::Layout() {
665 widget_->webwidget()->layout();
666 }
667
ApplyScrollAndScale(const gfx::Vector2d & scroll_delta,float page_scale)668 void RenderWidgetCompositor::ApplyScrollAndScale(
669 const gfx::Vector2d& scroll_delta,
670 float page_scale) {
671 widget_->webwidget()->applyScrollAndScale(scroll_delta, page_scale);
672 }
673
CreateOutputSurface(bool fallback)674 scoped_ptr<cc::OutputSurface> RenderWidgetCompositor::CreateOutputSurface(
675 bool fallback) {
676 return widget_->CreateOutputSurface(fallback);
677 }
678
DidInitializeOutputSurface()679 void RenderWidgetCompositor::DidInitializeOutputSurface() {
680 }
681
WillCommit()682 void RenderWidgetCompositor::WillCommit() {
683 widget_->InstrumentWillComposite();
684 }
685
DidCommit()686 void RenderWidgetCompositor::DidCommit() {
687 widget_->DidCommitCompositorFrame();
688 widget_->didBecomeReadyForAdditionalInput();
689 }
690
DidCommitAndDrawFrame()691 void RenderWidgetCompositor::DidCommitAndDrawFrame() {
692 widget_->didCommitAndDrawCompositorFrame();
693 }
694
DidCompleteSwapBuffers()695 void RenderWidgetCompositor::DidCompleteSwapBuffers() {
696 widget_->didCompleteSwapBuffers();
697 if (!threaded_)
698 widget_->OnSwapBuffersComplete();
699 }
700
ScheduleComposite()701 void RenderWidgetCompositor::ScheduleComposite() {
702 if (!suppress_schedule_composite_)
703 widget_->scheduleComposite();
704 }
705
ScheduleAnimation()706 void RenderWidgetCompositor::ScheduleAnimation() {
707 widget_->scheduleAnimation();
708 }
709
DidPostSwapBuffers()710 void RenderWidgetCompositor::DidPostSwapBuffers() {
711 widget_->OnSwapBuffersPosted();
712 }
713
DidAbortSwapBuffers()714 void RenderWidgetCompositor::DidAbortSwapBuffers() {
715 widget_->OnSwapBuffersAborted();
716 }
717
RateLimitSharedMainThreadContext()718 void RenderWidgetCompositor::RateLimitSharedMainThreadContext() {
719 cc::ContextProvider* provider =
720 RenderThreadImpl::current()->SharedMainThreadContextProvider().get();
721 provider->ContextGL()->RateLimitOffscreenContextCHROMIUM();
722 }
723
724 } // namespace content
725