src/content/renderer/gpu/render_widget_compositor.cc

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