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