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/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
  40 namespace base {
  41 class Value;
  42 }
  43
  44 namespace cc {
  45 class Layer;
  46 }
  47
  48 using blink::WebFloatPoint;
  49 using blink::WebSize;
  50 using blink::WebRect;
  51
  52 namespace content {
  53 namespace {
  54
  55 bool 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
  77 scoped_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   // Webview does not own the surface so should not clear it.
 283   settings.should_clear_root_render_pass =
 284       !widget->UsingSynchronousRendererCompositor();
 285
 286 #elif !defined(OS_MACOSX)
 287   if (ui::IsOverlayScrollbarEnabled()) {
 288 #if defined(OS_TIZEN)
 289     // Tizen fades out the scrollbar after contents interaction ends.
 290     settings.scrollbar_animator = cc::LayerTreeSettings::LinearFade;
 291 #else
 292     settings.scrollbar_animator = cc::LayerTreeSettings::Thinning;
 293 #endif
 294     settings.solid_color_scrollbar_color = SkColorSetARGB(128, 128, 128, 128);
 295   } else if (cmd->HasSwitch(cc::switches::kEnablePinchVirtualViewport)) {
 296     settings.scrollbar_animator = cc::LayerTreeSettings::LinearFade;
 297     settings.solid_color_scrollbar_color = SkColorSetARGB(128, 128, 128, 128);
 298   }
 299 #endif
 300
 301   compositor->Initialize(settings);
 302
 303   return compositor.Pass();
 304 }
 305
 306 RenderWidgetCompositor::RenderWidgetCompositor(RenderWidget* widget,
 307                                                bool threaded)
 308     : threaded_(threaded),
 309       suppress_schedule_composite_(false),
 310       widget_(widget) {
 311 }
 312
 313 RenderWidgetCompositor::~RenderWidgetCompositor() {}
 314
 315 const base::WeakPtr<cc::InputHandler>&
 316 RenderWidgetCompositor::GetInputHandler() {
 317   return layer_tree_host_->GetInputHandler();
 318 }
 319
 320 void RenderWidgetCompositor::SetSuppressScheduleComposite(bool suppress) {
 321   if (suppress_schedule_composite_ == suppress)
 322     return;
 323
 324   if (suppress)
 325     TRACE_EVENT_ASYNC_BEGIN0("gpu",
 326         "RenderWidgetCompositor::SetSuppressScheduleComposite", this);
 327   else
 328     TRACE_EVENT_ASYNC_END0("gpu",
 329         "RenderWidgetCompositor::SetSuppressScheduleComposite", this);
 330   suppress_schedule_composite_ = suppress;
 331 }
 332
 333 bool RenderWidgetCompositor::BeginMainFrameRequested() const {
 334   return layer_tree_host_->BeginMainFrameRequested();
 335 }
 336
 337 void RenderWidgetCompositor::UpdateAnimations(base::TimeTicks time) {
 338   layer_tree_host_->UpdateClientAnimations(time);
 339 }
 340
 341 void RenderWidgetCompositor::Composite(base::TimeTicks frame_begin_time) {
 342   layer_tree_host_->Composite(frame_begin_time);
 343 }
 344
 345 void RenderWidgetCompositor::SetNeedsDisplayOnAllLayers() {
 346   layer_tree_host_->SetNeedsDisplayOnAllLayers();
 347 }
 348
 349 void RenderWidgetCompositor::SetRasterizeOnlyVisibleContent() {
 350   cc::LayerTreeDebugState current = layer_tree_host_->debug_state();
 351   current.rasterize_only_visible_content = true;
 352   layer_tree_host_->SetDebugState(current);
 353 }
 354
 355 void RenderWidgetCompositor::UpdateTopControlsState(
 356     cc::TopControlsState constraints,
 357     cc::TopControlsState current,
 358     bool animate) {
 359   layer_tree_host_->UpdateTopControlsState(constraints,
 360                                            current,
 361                                            animate);
 362 }
 363
 364 void RenderWidgetCompositor::SetOverdrawBottomHeight(
 365     float overdraw_bottom_height) {
 366   layer_tree_host_->SetOverdrawBottomHeight(overdraw_bottom_height);
 367 }
 368
 369 void RenderWidgetCompositor::SetNeedsRedrawRect(gfx::Rect damage_rect) {
 370   layer_tree_host_->SetNeedsRedrawRect(damage_rect);
 371 }
 372
 373 void RenderWidgetCompositor::SetNeedsForcedRedraw() {
 374   layer_tree_host_->SetNextCommitForcesRedraw();
 375   setNeedsAnimate();
 376 }
 377
 378 scoped_ptr<cc::SwapPromiseMonitor>
 379 RenderWidgetCompositor::CreateLatencyInfoSwapPromiseMonitor(
 380     ui::LatencyInfo* latency) {
 381   return scoped_ptr<cc::SwapPromiseMonitor>(
 382       new cc::LatencyInfoSwapPromiseMonitor(
 383           latency, layer_tree_host_.get(), NULL));
 384 }
 385
 386 int RenderWidgetCompositor::GetLayerTreeId() const {
 387   return layer_tree_host_->id();
 388 }
 389
 390 void RenderWidgetCompositor::NotifyInputThrottledUntilCommit() {
 391   layer_tree_host_->NotifyInputThrottledUntilCommit();
 392 }
 393
 394 const cc::Layer* RenderWidgetCompositor::GetRootLayer() const {
 395   return layer_tree_host_->root_layer();
 396 }
 397
 398 bool RenderWidgetCompositor::ScheduleMicroBenchmark(
 399     const std::string& name,
 400     scoped_ptr<base::Value> value,
 401     const base::Callback<void(scoped_ptr<base::Value>)>& callback) {
 402   return layer_tree_host_->ScheduleMicroBenchmark(name, value.Pass(), callback);
 403 }
 404
 405 void RenderWidgetCompositor::Initialize(cc::LayerTreeSettings settings) {
 406   scoped_refptr<base::MessageLoopProxy> compositor_message_loop_proxy =
 407       RenderThreadImpl::current()->compositor_message_loop_proxy();
 408   if (compositor_message_loop_proxy.get()) {
 409     layer_tree_host_ = cc::LayerTreeHost::CreateThreaded(
 410         this,
 411         ChildThread::current()->shared_bitmap_manager(),
 412         settings,
 413         compositor_message_loop_proxy);
 414   } else {
 415     layer_tree_host_ = cc::LayerTreeHost::CreateSingleThreaded(
 416         this, this, ChildThread::current()->shared_bitmap_manager(), settings);
 417   }
 418   DCHECK(layer_tree_host_);
 419 }
 420
 421 void RenderWidgetCompositor::setSurfaceReady() {
 422   layer_tree_host_->SetLayerTreeHostClientReady();
 423 }
 424
 425 void RenderWidgetCompositor::setRootLayer(const blink::WebLayer& layer) {
 426   layer_tree_host_->SetRootLayer(
 427       static_cast<const webkit::WebLayerImpl*>(&layer)->layer());
 428 }
 429
 430 void RenderWidgetCompositor::clearRootLayer() {
 431   layer_tree_host_->SetRootLayer(scoped_refptr<cc::Layer>());
 432 }
 433
 434 void RenderWidgetCompositor::setViewportSize(
 435     const WebSize&,
 436     const WebSize& device_viewport_size) {
 437   layer_tree_host_->SetViewportSize(device_viewport_size);
 438 }
 439
 440 WebSize RenderWidgetCompositor::layoutViewportSize() const {
 441   return layer_tree_host_->device_viewport_size();
 442 }
 443
 444 WebSize RenderWidgetCompositor::deviceViewportSize() const {
 445   return layer_tree_host_->device_viewport_size();
 446 }
 447
 448 WebFloatPoint RenderWidgetCompositor::adjustEventPointForPinchZoom(
 449     const WebFloatPoint& point) const {
 450   return point;
 451 }
 452
 453 void RenderWidgetCompositor::setDeviceScaleFactor(float device_scale) {
 454   layer_tree_host_->SetDeviceScaleFactor(device_scale);
 455 }
 456
 457 float RenderWidgetCompositor::deviceScaleFactor() const {
 458   return layer_tree_host_->device_scale_factor();
 459 }
 460
 461 void RenderWidgetCompositor::setBackgroundColor(blink::WebColor color) {
 462   layer_tree_host_->set_background_color(color);
 463 }
 464
 465 void RenderWidgetCompositor::setHasTransparentBackground(bool transparent) {
 466   layer_tree_host_->set_has_transparent_background(transparent);
 467 }
 468
 469 void RenderWidgetCompositor::setOverhangBitmap(const SkBitmap& bitmap) {
 470   layer_tree_host_->SetOverhangBitmap(bitmap);
 471 }
 472
 473 void RenderWidgetCompositor::setVisible(bool visible) {
 474   layer_tree_host_->SetVisible(visible);
 475 }
 476
 477 void RenderWidgetCompositor::setPageScaleFactorAndLimits(
 478     float page_scale_factor, float minimum, float maximum) {
 479   layer_tree_host_->SetPageScaleFactorAndLimits(
 480       page_scale_factor, minimum, maximum);
 481 }
 482
 483 void RenderWidgetCompositor::startPageScaleAnimation(
 484     const blink::WebPoint& destination,
 485     bool use_anchor,
 486     float new_page_scale,
 487     double duration_sec) {
 488   base::TimeDelta duration = base::TimeDelta::FromMicroseconds(
 489       duration_sec * base::Time::kMicrosecondsPerSecond);
 490   layer_tree_host_->StartPageScaleAnimation(
 491       gfx::Vector2d(destination.x, destination.y),
 492       use_anchor,
 493       new_page_scale,
 494       duration);
 495 }
 496
 497 void RenderWidgetCompositor::setNeedsAnimate() {
 498   layer_tree_host_->SetNeedsAnimate();
 499 }
 500
 501 bool RenderWidgetCompositor::commitRequested() const {
 502   return layer_tree_host_->CommitRequested();
 503 }
 504
 505 void RenderWidgetCompositor::didStopFlinging() {
 506   layer_tree_host_->DidStopFlinging();
 507 }
 508
 509 void RenderWidgetCompositor::registerForAnimations(blink::WebLayer* layer) {
 510   cc::Layer* cc_layer = static_cast<webkit::WebLayerImpl*>(layer)->layer();
 511   cc_layer->layer_animation_controller()->SetAnimationRegistrar(
 512       layer_tree_host_->animation_registrar());
 513 }
 514
 515 void RenderWidgetCompositor::registerViewportLayers(
 516     const blink::WebLayer* pageScaleLayer,
 517     const blink::WebLayer* innerViewportScrollLayer,
 518     const blink::WebLayer* outerViewportScrollLayer) {
 519   layer_tree_host_->RegisterViewportLayers(
 520       static_cast<const webkit::WebLayerImpl*>(pageScaleLayer)->layer(),
 521       static_cast<const webkit::WebLayerImpl*>(innerViewportScrollLayer)
 522           ->layer(),
 523       // The outer viewport layer will only exist when using pinch virtual
 524       // viewports.
 525       outerViewportScrollLayer ? static_cast<const webkit::WebLayerImpl*>(
 526                                      outerViewportScrollLayer)->layer()
 527                                : NULL);
 528 }
 529
 530 void RenderWidgetCompositor::clearViewportLayers() {
 531   layer_tree_host_->RegisterViewportLayers(scoped_refptr<cc::Layer>(),
 532                                            scoped_refptr<cc::Layer>(),
 533                                            scoped_refptr<cc::Layer>());
 534 }
 535
 536 bool RenderWidgetCompositor::compositeAndReadback(
 537     void *pixels, const WebRect& rect_in_device_viewport) {
 538   return layer_tree_host_->CompositeAndReadback(pixels,
 539                                                 rect_in_device_viewport);
 540 }
 541
 542 void RenderWidgetCompositor::finishAllRendering() {
 543   layer_tree_host_->FinishAllRendering();
 544 }
 545
 546 void RenderWidgetCompositor::setDeferCommits(bool defer_commits) {
 547   layer_tree_host_->SetDeferCommits(defer_commits);
 548 }
 549
 550 void RenderWidgetCompositor::setShowFPSCounter(bool show) {
 551   cc::LayerTreeDebugState debug_state = layer_tree_host_->debug_state();
 552   debug_state.show_fps_counter = show;
 553   layer_tree_host_->SetDebugState(debug_state);
 554 }
 555
 556 void RenderWidgetCompositor::setShowPaintRects(bool show) {
 557   cc::LayerTreeDebugState debug_state = layer_tree_host_->debug_state();
 558   debug_state.show_paint_rects = show;
 559   layer_tree_host_->SetDebugState(debug_state);
 560 }
 561
 562 void RenderWidgetCompositor::setShowDebugBorders(bool show) {
 563   cc::LayerTreeDebugState debug_state = layer_tree_host_->debug_state();
 564   debug_state.show_debug_borders = show;
 565   layer_tree_host_->SetDebugState(debug_state);
 566 }
 567
 568 void RenderWidgetCompositor::setContinuousPaintingEnabled(bool enabled) {
 569   cc::LayerTreeDebugState debug_state = layer_tree_host_->debug_state();
 570   debug_state.continuous_painting = enabled;
 571   layer_tree_host_->SetDebugState(debug_state);
 572 }
 573
 574 void RenderWidgetCompositor::setShowScrollBottleneckRects(bool show) {
 575   cc::LayerTreeDebugState debug_state = layer_tree_host_->debug_state();
 576   debug_state.show_touch_event_handler_rects = show;
 577   debug_state.show_wheel_event_handler_rects = show;
 578   debug_state.show_non_fast_scrollable_rects = show;
 579   layer_tree_host_->SetDebugState(debug_state);
 580 }
 581
 582 void RenderWidgetCompositor::WillBeginMainFrame(int frame_id) {
 583   widget_->InstrumentWillBeginFrame(frame_id);
 584   widget_->willBeginCompositorFrame();
 585 }
 586
 587 void RenderWidgetCompositor::DidBeginMainFrame() {
 588   widget_->InstrumentDidBeginFrame();
 589 }
 590
 591 void RenderWidgetCompositor::Animate(base::TimeTicks frame_begin_time) {
 592   widget_->webwidget()->animate(
 593       (frame_begin_time - base::TimeTicks()).InSecondsF());
 594 }
 595
 596 void RenderWidgetCompositor::Layout() {
 597   widget_->webwidget()->layout();
 598 }
 599
 600 void RenderWidgetCompositor::ApplyScrollAndScale(
 601     const gfx::Vector2d& scroll_delta,
 602     float page_scale) {
 603   widget_->webwidget()->applyScrollAndScale(scroll_delta, page_scale);
 604 }
 605
 606 scoped_ptr<cc::OutputSurface> RenderWidgetCompositor::CreateOutputSurface(
 607     bool fallback) {
 608   return widget_->CreateOutputSurface(fallback);
 609 }
 610
 611 void RenderWidgetCompositor::DidInitializeOutputSurface(bool success) {
 612   if (!success)
 613     widget_->webwidget()->didExitCompositingMode();
 614 }
 615
 616 void RenderWidgetCompositor::WillCommit() {
 617   widget_->InstrumentWillComposite();
 618 }
 619
 620 void RenderWidgetCompositor::DidCommit() {
 621   widget_->DidCommitCompositorFrame();
 622   widget_->didBecomeReadyForAdditionalInput();
 623 }
 624
 625 void RenderWidgetCompositor::DidCommitAndDrawFrame() {
 626   widget_->didCommitAndDrawCompositorFrame();
 627 }
 628
 629 void RenderWidgetCompositor::DidCompleteSwapBuffers() {
 630   widget_->didCompleteSwapBuffers();
 631   if (!threaded_)
 632     widget_->OnSwapBuffersComplete();
 633 }
 634
 635 scoped_refptr<cc::ContextProvider>
 636 RenderWidgetCompositor::OffscreenContextProvider() {
 637   return RenderThreadImpl::current()->OffscreenCompositorContextProvider();
 638 }
 639
 640 void RenderWidgetCompositor::ScheduleComposite() {
 641   if (!suppress_schedule_composite_)
 642     widget_->scheduleComposite();
 643 }
 644
 645 void RenderWidgetCompositor::ScheduleAnimation() {
 646   widget_->scheduleAnimation();
 647 }
 648
 649 void RenderWidgetCompositor::DidPostSwapBuffers() {
 650   widget_->OnSwapBuffersPosted();
 651 }
 652
 653 void RenderWidgetCompositor::DidAbortSwapBuffers() {
 654   widget_->OnSwapBuffersAborted();
 655 }
 656
 657 void RenderWidgetCompositor::RateLimitSharedMainThreadContext() {
 658   cc::ContextProvider* provider =
 659       RenderThreadImpl::current()->SharedMainThreadContextProvider().get();
 660   provider->ContextGL()->RateLimitOffscreenContextCHROMIUM();
 661 }
 662
 663 }  // namespace content