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