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 #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/swap_promise.h"
  20 #include "cc/base/switches.h"
  21 #include "cc/blink/web_layer_impl.h"
  22 #include "cc/debug/layer_tree_debug_state.h"
  23 #include "cc/debug/micro_benchmark.h"
  24 #include "cc/input/layer_selection_bound.h"
  25 #include "cc/layers/layer.h"
  26 #include "cc/output/begin_frame_args.h"
  27 #include "cc/output/copy_output_request.h"
  28 #include "cc/output/copy_output_result.h"
  29 #include "cc/resources/single_release_callback.h"
  30 #include "cc/trees/layer_tree_host.h"
  31 #include "content/child/child_gpu_memory_buffer_manager.h"
  32 #include "content/child/child_shared_bitmap_manager.h"
  33 #include "content/common/content_switches_internal.h"
  34 #include "content/common/gpu/client/context_provider_command_buffer.h"
  35 #include "content/public/common/content_switches.h"
  36 #include "content/renderer/input/input_handler_manager.h"
  37 #include "content/renderer/render_thread_impl.h"
  38 #include "gpu/command_buffer/client/gles2_interface.h"
  39 #include "third_party/WebKit/public/platform/WebCompositeAndReadbackAsyncCallback.h"
  40 #include "third_party/WebKit/public/platform/WebSelectionBound.h"
  41 #include "third_party/WebKit/public/platform/WebSize.h"
  42 #include "third_party/WebKit/public/web/WebKit.h"
  43 #include "third_party/WebKit/public/web/WebWidget.h"
  44 #include "ui/gfx/frame_time.h"
  45 #include "ui/gl/gl_switches.h"
  46 #include "ui/native_theme/native_theme_switches.h"
  47
  48 #if defined(OS_ANDROID)
  49 #include "content/renderer/android/synchronous_compositor_factory.h"
  50 #include "ui/gfx/android/device_display_info.h"
  51 #endif
  52
  53 namespace base {
  54 class Value;
  55 }
  56
  57 namespace cc {
  58 class Layer;
  59 }
  60
  61 using blink::WebBeginFrameArgs;
  62 using blink::WebFloatPoint;
  63 using blink::WebRect;
  64 using blink::WebSelectionBound;
  65 using blink::WebSize;
  66
  67 namespace content {
  68 namespace {
  69
  70 bool GetSwitchValueAsInt(
  71     const CommandLine& command_line,
  72     const std::string& switch_string,
  73     int min_value,
  74     int max_value,
  75     int* result) {
  76   std::string string_value = command_line.GetSwitchValueASCII(switch_string);
  77   int int_value;
  78   if (base::StringToInt(string_value, &int_value) &&
  79       int_value >= min_value && int_value <= max_value) {
  80     *result = int_value;
  81     return true;
  82   } else {
  83     LOG(WARNING) << "Failed to parse switch " << switch_string  << ": " <<
  84         string_value;
  85     return false;
  86   }
  87 }
  88
  89 cc::LayerSelectionBound ConvertWebSelectionBound(
  90     const WebSelectionBound& web_bound) {
  91   DCHECK(web_bound.layerId);
  92
  93   cc::LayerSelectionBound cc_bound;
  94   switch (web_bound.type) {
  95     case blink::WebSelectionBound::Caret:
  96       cc_bound.type = cc::SELECTION_BOUND_CENTER;
  97       break;
  98     case blink::WebSelectionBound::SelectionLeft:
  99       cc_bound.type = cc::SELECTION_BOUND_LEFT;
 100       break;
 101     case blink::WebSelectionBound::SelectionRight:
 102       cc_bound.type = cc::SELECTION_BOUND_RIGHT;
 103       break;
 104   }
 105   cc_bound.layer_id = web_bound.layerId;
 106   cc_bound.edge_top = gfx::Point(web_bound.edgeTopInLayer);
 107   cc_bound.edge_bottom = gfx::Point(web_bound.edgeBottomInLayer);
 108   return cc_bound;
 109 }
 110
 111 gfx::Size CalculateDefaultTileSize() {
 112   int default_tile_size = 256;
 113 #if defined(OS_ANDROID)
 114   // TODO(epenner): unify this for all platforms if it
 115   // makes sense (http://crbug.com/159524)
 116
 117   gfx::DeviceDisplayInfo info;
 118   bool real_size_supported = true;
 119   int display_width = info.GetPhysicalDisplayWidth();
 120   int display_height = info.GetPhysicalDisplayHeight();
 121   if (display_width == 0 || display_height == 0) {
 122     real_size_supported = false;
 123     display_width = info.GetDisplayWidth();
 124     display_height = info.GetDisplayHeight();
 125   }
 126
 127   int portrait_width = std::min(display_width, display_height);
 128   int landscape_width = std::max(display_width, display_height);
 129
 130   if (real_size_supported) {
 131     // Maximum HD dimensions should be 768x1280
 132     // Maximum FHD dimensions should be 1200x1920
 133     if (portrait_width > 768 || landscape_width > 1280)
 134       default_tile_size = 384;
 135     if (portrait_width > 1200 || landscape_width > 1920)
 136       default_tile_size = 512;
 137
 138     // Adjust for some resolutions that barely straddle an extra
 139     // tile when in portrait mode. This helps worst case scroll/raster
 140     // by not needing a full extra tile for each row.
 141     if (default_tile_size == 256 && portrait_width == 768)
 142       default_tile_size += 32;
 143     if (default_tile_size == 384 && portrait_width == 1200)
 144       default_tile_size += 32;
 145   } else {
 146     // We don't know the exact resolution due to screen controls etc.
 147     // So this just estimates the values above using tile counts.
 148     int numTiles = (display_width * display_height) / (256 * 256);
 149     if (numTiles > 16)
 150       default_tile_size = 384;
 151     if (numTiles >= 40)
 152       default_tile_size = 512;
 153   }
 154 #endif
 155   return gfx::Size(default_tile_size, default_tile_size);
 156 }
 157
 158 }  // namespace
 159
 160 // static
 161 scoped_ptr<RenderWidgetCompositor> RenderWidgetCompositor::Create(
 162     RenderWidget* widget,
 163     bool threaded) {
 164   scoped_ptr<RenderWidgetCompositor> compositor(
 165       new RenderWidgetCompositor(widget, threaded));
 166
 167   CommandLine* cmd = CommandLine::ForCurrentProcess();
 168
 169   cc::LayerTreeSettings settings;
 170
 171   // For web contents, layer transforms should scale up the contents of layers
 172   // to keep content always crisp when possible.
 173   settings.layer_transforms_should_scale_layer_contents = true;
 174
 175   settings.throttle_frame_production =
 176       !cmd->HasSwitch(switches::kDisableGpuVsync);
 177   settings.begin_frame_scheduling_enabled =
 178       cmd->HasSwitch(switches::kEnableBeginFrameScheduling);
 179   settings.main_frame_before_activation_enabled =
 180       cmd->HasSwitch(cc::switches::kEnableMainFrameBeforeActivation) &&
 181       !cmd->HasSwitch(cc::switches::kDisableMainFrameBeforeActivation);
 182   settings.report_overscroll_only_for_scrollable_axes = true;
 183   settings.accelerated_animation_enabled =
 184       !cmd->HasSwitch(cc::switches::kDisableThreadedAnimation);
 185
 186   settings.default_tile_size = CalculateDefaultTileSize();
 187   if (cmd->HasSwitch(switches::kDefaultTileWidth)) {
 188     int tile_width = 0;
 189     GetSwitchValueAsInt(*cmd,
 190                         switches::kDefaultTileWidth,
 191                         1,
 192                         std::numeric_limits<int>::max(),
 193                         &tile_width);
 194     settings.default_tile_size.set_width(tile_width);
 195   }
 196   if (cmd->HasSwitch(switches::kDefaultTileHeight)) {
 197     int tile_height = 0;
 198     GetSwitchValueAsInt(*cmd,
 199                         switches::kDefaultTileHeight,
 200                         1,
 201                         std::numeric_limits<int>::max(),
 202                         &tile_height);
 203     settings.default_tile_size.set_height(tile_height);
 204   }
 205
 206   int max_untiled_layer_width = settings.max_untiled_layer_size.width();
 207   if (cmd->HasSwitch(switches::kMaxUntiledLayerWidth)) {
 208     GetSwitchValueAsInt(*cmd, switches::kMaxUntiledLayerWidth, 1,
 209                         std::numeric_limits<int>::max(),
 210                         &max_untiled_layer_width);
 211   }
 212   int max_untiled_layer_height = settings.max_untiled_layer_size.height();
 213   if (cmd->HasSwitch(switches::kMaxUntiledLayerHeight)) {
 214     GetSwitchValueAsInt(*cmd, switches::kMaxUntiledLayerHeight, 1,
 215                         std::numeric_limits<int>::max(),
 216                         &max_untiled_layer_height);
 217   }
 218
 219   settings.max_untiled_layer_size = gfx::Size(max_untiled_layer_width,
 220                                            max_untiled_layer_height);
 221
 222   RenderThreadImpl* render_thread = RenderThreadImpl::current();
 223   // render_thread may be NULL in tests.
 224   if (render_thread) {
 225     settings.impl_side_painting =
 226         render_thread->is_impl_side_painting_enabled();
 227     settings.gpu_rasterization_forced =
 228         render_thread->is_gpu_rasterization_forced();
 229     settings.gpu_rasterization_enabled =
 230         render_thread->is_gpu_rasterization_enabled();
 231     settings.can_use_lcd_text = render_thread->is_lcd_text_enabled();
 232     settings.use_distance_field_text =
 233         render_thread->is_distance_field_text_enabled();
 234     settings.use_zero_copy = render_thread->is_zero_copy_enabled();
 235     settings.use_one_copy = render_thread->is_one_copy_enabled();
 236   }
 237
 238   settings.calculate_top_controls_position =
 239       cmd->HasSwitch(cc::switches::kEnableTopControlsPositionCalculation);
 240   if (cmd->HasSwitch(cc::switches::kTopControlsHeight)) {
 241     std::string controls_height_str =
 242         cmd->GetSwitchValueASCII(cc::switches::kTopControlsHeight);
 243     double controls_height;
 244     if (base::StringToDouble(controls_height_str, &controls_height) &&
 245         controls_height > 0)
 246       settings.top_controls_height = controls_height;
 247   }
 248
 249   if (settings.calculate_top_controls_position &&
 250       settings.top_controls_height <= 0) {
 251     DCHECK(false)
 252         << "Top controls repositioning enabled without valid height set.";
 253     settings.calculate_top_controls_position = false;
 254   }
 255
 256   if (cmd->HasSwitch(cc::switches::kTopControlsShowThreshold)) {
 257       std::string top_threshold_str =
 258           cmd->GetSwitchValueASCII(cc::switches::kTopControlsShowThreshold);
 259       double show_threshold;
 260       if (base::StringToDouble(top_threshold_str, &show_threshold) &&
 261           show_threshold >= 0.f && show_threshold <= 1.f)
 262         settings.top_controls_show_threshold = show_threshold;
 263   }
 264
 265   if (cmd->HasSwitch(cc::switches::kTopControlsHideThreshold)) {
 266       std::string top_threshold_str =
 267           cmd->GetSwitchValueASCII(cc::switches::kTopControlsHideThreshold);
 268       double hide_threshold;
 269       if (base::StringToDouble(top_threshold_str, &hide_threshold) &&
 270           hide_threshold >= 0.f && hide_threshold <= 1.f)
 271         settings.top_controls_hide_threshold = hide_threshold;
 272   }
 273
 274   settings.use_pinch_virtual_viewport =
 275       cmd->HasSwitch(cc::switches::kEnablePinchVirtualViewport);
 276   settings.allow_antialiasing &=
 277       !cmd->HasSwitch(cc::switches::kDisableCompositedAntialiasing);
 278   settings.single_thread_proxy_scheduler =
 279       !cmd->HasSwitch(switches::kDisableSingleThreadProxyScheduler);
 280
 281   // These flags should be mirrored by UI versions in ui/compositor/.
 282   settings.initial_debug_state.show_debug_borders =
 283       cmd->HasSwitch(cc::switches::kShowCompositedLayerBorders);
 284   settings.initial_debug_state.show_fps_counter =
 285       cmd->HasSwitch(cc::switches::kShowFPSCounter);
 286   settings.initial_debug_state.show_layer_animation_bounds_rects =
 287       cmd->HasSwitch(cc::switches::kShowLayerAnimationBounds);
 288   settings.initial_debug_state.show_paint_rects =
 289       cmd->HasSwitch(switches::kShowPaintRects);
 290   settings.initial_debug_state.show_property_changed_rects =
 291       cmd->HasSwitch(cc::switches::kShowPropertyChangedRects);
 292   settings.initial_debug_state.show_surface_damage_rects =
 293       cmd->HasSwitch(cc::switches::kShowSurfaceDamageRects);
 294   settings.initial_debug_state.show_screen_space_rects =
 295       cmd->HasSwitch(cc::switches::kShowScreenSpaceRects);
 296   settings.initial_debug_state.show_replica_screen_space_rects =
 297       cmd->HasSwitch(cc::switches::kShowReplicaScreenSpaceRects);
 298   settings.initial_debug_state.show_occluding_rects =
 299       cmd->HasSwitch(cc::switches::kShowOccludingRects);
 300   settings.initial_debug_state.show_non_occluding_rects =
 301       cmd->HasSwitch(cc::switches::kShowNonOccludingRects);
 302
 303   settings.initial_debug_state.SetRecordRenderingStats(
 304       cmd->HasSwitch(cc::switches::kEnableGpuBenchmarking));
 305
 306   if (cmd->HasSwitch(cc::switches::kSlowDownRasterScaleFactor)) {
 307     const int kMinSlowDownScaleFactor = 0;
 308     const int kMaxSlowDownScaleFactor = INT_MAX;
 309     GetSwitchValueAsInt(
 310         *cmd,
 311         cc::switches::kSlowDownRasterScaleFactor,
 312         kMinSlowDownScaleFactor,
 313         kMaxSlowDownScaleFactor,
 314         &settings.initial_debug_state.slow_down_raster_scale_factor);
 315   }
 316
 317   if (cmd->HasSwitch(cc::switches::kMaxTilesForInterestArea)) {
 318     int max_tiles_for_interest_area;
 319     if (GetSwitchValueAsInt(*cmd,
 320                             cc::switches::kMaxTilesForInterestArea,
 321                             1, std::numeric_limits<int>::max(),
 322                             &max_tiles_for_interest_area))
 323       settings.max_tiles_for_interest_area = max_tiles_for_interest_area;
 324   }
 325
 326   if (cmd->HasSwitch(cc::switches::kMaxUnusedResourceMemoryUsagePercentage)) {
 327     int max_unused_resource_memory_percentage;
 328     if (GetSwitchValueAsInt(
 329             *cmd,
 330             cc::switches::kMaxUnusedResourceMemoryUsagePercentage,
 331             0, 100,
 332             &max_unused_resource_memory_percentage)) {
 333       settings.max_unused_resource_memory_percentage =
 334           max_unused_resource_memory_percentage;
 335     }
 336   }
 337
 338   settings.strict_layer_property_change_checking =
 339       cmd->HasSwitch(cc::switches::kStrictLayerPropertyChangeChecking);
 340
 341 #if defined(OS_ANDROID)
 342   SynchronousCompositorFactory* synchronous_compositor_factory =
 343       SynchronousCompositorFactory::GetInstance();
 344
 345   settings.using_synchronous_renderer_compositor =
 346       synchronous_compositor_factory;
 347   settings.record_full_layer =
 348       synchronous_compositor_factory &&
 349       synchronous_compositor_factory->RecordFullLayer();
 350   settings.report_overscroll_only_for_scrollable_axes =
 351       !synchronous_compositor_factory;
 352   settings.max_partial_texture_updates = 0;
 353   if (synchronous_compositor_factory) {
 354     // Android WebView uses system scrollbars, so make ours invisible.
 355     settings.scrollbar_animator = cc::LayerTreeSettings::NoAnimator;
 356     settings.solid_color_scrollbar_color = SK_ColorTRANSPARENT;
 357   } else {
 358     settings.scrollbar_animator = cc::LayerTreeSettings::LinearFade;
 359     settings.scrollbar_fade_delay_ms = 300;
 360     settings.scrollbar_fade_resize_delay_ms = 2000;
 361     settings.scrollbar_fade_duration_ms = 300;
 362     settings.solid_color_scrollbar_color = SkColorSetARGB(128, 128, 128, 128);
 363   }
 364   settings.highp_threshold_min = 2048;
 365   // Android WebView handles root layer flings itself.
 366   settings.ignore_root_layer_flings =
 367       synchronous_compositor_factory;
 368   // Memory policy on Android WebView does not depend on whether device is
 369   // low end, so always use default policy.
 370   bool is_low_end_device =
 371       base::SysInfo::IsLowEndDevice() && !synchronous_compositor_factory;
 372   // RGBA_4444 textures are only enabled for low end devices
 373   // and are disabled for Android WebView as it doesn't support the format.
 374   settings.use_rgba_4444_textures = is_low_end_device;
 375   if (is_low_end_device) {
 376     // On low-end we want to be very carefull about killing other
 377     // apps. So initially we use 50% more memory to avoid flickering
 378     // or raster-on-demand.
 379     settings.max_memory_for_prepaint_percentage = 67;
 380   } else {
 381     // On other devices we have increased memory excessively to avoid
 382     // raster-on-demand already, so now we reserve 50% _only_ to avoid
 383     // raster-on-demand, and use 50% of the memory otherwise.
 384     settings.max_memory_for_prepaint_percentage = 50;
 385   }
 386   // Webview does not own the surface so should not clear it.
 387   settings.should_clear_root_render_pass =
 388       !synchronous_compositor_factory;
 389
 390   // TODO(danakj): Only do this on low end devices.
 391   settings.create_low_res_tiling = true;
 392
 393 #elif !defined(OS_MACOSX)
 394   if (ui::IsOverlayScrollbarEnabled()) {
 395 #if defined(OS_TIZEN)
 396     // Tizen fades out the scrollbar after contents interaction ends.
 397     settings.scrollbar_animator = cc::LayerTreeSettings::LinearFade;
 398 #else
 399     settings.scrollbar_animator = cc::LayerTreeSettings::Thinning;
 400 #endif
 401     settings.solid_color_scrollbar_color = SkColorSetARGB(128, 128, 128, 128);
 402   } else if (cmd->HasSwitch(cc::switches::kEnablePinchVirtualViewport)) {
 403     // use_pinch_zoom_scrollbars is only true on desktop when non-overlay
 404     // scrollbars are in use.
 405     settings.use_pinch_zoom_scrollbars = true;
 406     settings.scrollbar_animator = cc::LayerTreeSettings::LinearFade;
 407     settings.solid_color_scrollbar_color = SkColorSetARGB(128, 128, 128, 128);
 408   }
 409   settings.scrollbar_fade_delay_ms = 500;
 410   settings.scrollbar_fade_resize_delay_ms = 500;
 411   settings.scrollbar_fade_duration_ms = 300;
 412 #endif
 413
 414   if (cmd->HasSwitch(switches::kEnableLowResTiling))
 415     settings.create_low_res_tiling = true;
 416   if (cmd->HasSwitch(switches::kDisableLowResTiling))
 417     settings.create_low_res_tiling = false;
 418
 419   compositor->Initialize(settings);
 420
 421   return compositor.Pass();
 422 }
 423
 424 RenderWidgetCompositor::RenderWidgetCompositor(RenderWidget* widget,
 425                                                bool threaded)
 426     : threaded_(threaded),
 427       widget_(widget),
 428       send_v8_idle_notification_after_commit_(true) {
 429   CommandLine* cmd = CommandLine::ForCurrentProcess();
 430
 431   if (cmd->HasSwitch(switches::kEnableV8IdleNotificationAfterCommit))
 432     send_v8_idle_notification_after_commit_ = true;
 433   if (cmd->HasSwitch(switches::kDisableV8IdleNotificationAfterCommit))
 434     send_v8_idle_notification_after_commit_ = false;
 435 }
 436
 437 RenderWidgetCompositor::~RenderWidgetCompositor() {}
 438
 439 const base::WeakPtr<cc::InputHandler>&
 440 RenderWidgetCompositor::GetInputHandler() {
 441   return layer_tree_host_->GetInputHandler();
 442 }
 443
 444 bool RenderWidgetCompositor::BeginMainFrameRequested() const {
 445   return layer_tree_host_->BeginMainFrameRequested();
 446 }
 447
 448 void RenderWidgetCompositor::SetNeedsDisplayOnAllLayers() {
 449   layer_tree_host_->SetNeedsDisplayOnAllLayers();
 450 }
 451
 452 void RenderWidgetCompositor::SetRasterizeOnlyVisibleContent() {
 453   cc::LayerTreeDebugState current = layer_tree_host_->debug_state();
 454   current.rasterize_only_visible_content = true;
 455   layer_tree_host_->SetDebugState(current);
 456 }
 457
 458 void RenderWidgetCompositor::UpdateTopControlsState(
 459     cc::TopControlsState constraints,
 460     cc::TopControlsState current,
 461     bool animate) {
 462   layer_tree_host_->UpdateTopControlsState(constraints,
 463                                            current,
 464                                            animate);
 465 }
 466
 467 void RenderWidgetCompositor::SetTopControlsLayoutHeight(float height) {
 468   layer_tree_host_->SetTopControlsLayoutHeight(height);
 469 }
 470
 471 void RenderWidgetCompositor::SetNeedsRedrawRect(gfx::Rect damage_rect) {
 472   layer_tree_host_->SetNeedsRedrawRect(damage_rect);
 473 }
 474
 475 void RenderWidgetCompositor::SetNeedsForcedRedraw() {
 476   layer_tree_host_->SetNextCommitForcesRedraw();
 477   setNeedsAnimate();
 478 }
 479
 480 scoped_ptr<cc::SwapPromiseMonitor>
 481 RenderWidgetCompositor::CreateLatencyInfoSwapPromiseMonitor(
 482     ui::LatencyInfo* latency) {
 483   return scoped_ptr<cc::SwapPromiseMonitor>(
 484       new cc::LatencyInfoSwapPromiseMonitor(
 485           latency, layer_tree_host_.get(), NULL));
 486 }
 487
 488 void RenderWidgetCompositor::QueueSwapPromise(
 489     scoped_ptr<cc::SwapPromise> swap_promise) {
 490   layer_tree_host_->QueueSwapPromise(swap_promise.Pass());
 491 }
 492
 493 int RenderWidgetCompositor::GetLayerTreeId() const {
 494   return layer_tree_host_->id();
 495 }
 496
 497 int RenderWidgetCompositor::GetSourceFrameNumber() const {
 498   return layer_tree_host_->source_frame_number();
 499 }
 500
 501 void RenderWidgetCompositor::SetNeedsCommit() {
 502   layer_tree_host_->SetNeedsCommit();
 503 }
 504
 505 void RenderWidgetCompositor::NotifyInputThrottledUntilCommit() {
 506   layer_tree_host_->NotifyInputThrottledUntilCommit();
 507 }
 508
 509 const cc::Layer* RenderWidgetCompositor::GetRootLayer() const {
 510   return layer_tree_host_->root_layer();
 511 }
 512
 513 int RenderWidgetCompositor::ScheduleMicroBenchmark(
 514     const std::string& name,
 515     scoped_ptr<base::Value> value,
 516     const base::Callback<void(scoped_ptr<base::Value>)>& callback) {
 517   return layer_tree_host_->ScheduleMicroBenchmark(name, value.Pass(), callback);
 518 }
 519
 520 bool RenderWidgetCompositor::SendMessageToMicroBenchmark(
 521     int id,
 522     scoped_ptr<base::Value> value) {
 523   return layer_tree_host_->SendMessageToMicroBenchmark(id, value.Pass());
 524 }
 525
 526 void RenderWidgetCompositor::Initialize(cc::LayerTreeSettings settings) {
 527   scoped_refptr<base::MessageLoopProxy> compositor_message_loop_proxy;
 528   scoped_refptr<base::SingleThreadTaskRunner>
 529       main_thread_compositor_task_runner(base::MessageLoopProxy::current());
 530   RenderThreadImpl* render_thread = RenderThreadImpl::current();
 531   cc::SharedBitmapManager* shared_bitmap_manager = NULL;
 532   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager = NULL;
 533   // render_thread may be NULL in tests.
 534   if (render_thread) {
 535     compositor_message_loop_proxy =
 536         render_thread->compositor_message_loop_proxy();
 537     shared_bitmap_manager = render_thread->shared_bitmap_manager();
 538     gpu_memory_buffer_manager = render_thread->gpu_memory_buffer_manager();
 539     main_thread_compositor_task_runner =
 540         render_thread->main_thread_compositor_task_runner();
 541   }
 542   if (compositor_message_loop_proxy.get()) {
 543     layer_tree_host_ =
 544         cc::LayerTreeHost::CreateThreaded(this,
 545                                           shared_bitmap_manager,
 546                                           gpu_memory_buffer_manager,
 547                                           settings,
 548                                           main_thread_compositor_task_runner,
 549                                           compositor_message_loop_proxy);
 550   } else {
 551     layer_tree_host_ = cc::LayerTreeHost::CreateSingleThreaded(
 552         this,
 553         this,
 554         shared_bitmap_manager,
 555         gpu_memory_buffer_manager,
 556         settings,
 557         main_thread_compositor_task_runner);
 558   }
 559   DCHECK(layer_tree_host_);
 560 }
 561
 562 void RenderWidgetCompositor::setSurfaceReady() {
 563   // In tests without a RenderThreadImpl, don't set ready as this kicks
 564   // off creating output surfaces that the test can't create.
 565   if (RenderThreadImpl::current())
 566     layer_tree_host_->SetLayerTreeHostClientReady();
 567 }
 568
 569 void RenderWidgetCompositor::setRootLayer(const blink::WebLayer& layer) {
 570   layer_tree_host_->SetRootLayer(
 571       static_cast<const cc_blink::WebLayerImpl*>(&layer)->layer());
 572 }
 573
 574 void RenderWidgetCompositor::clearRootLayer() {
 575   layer_tree_host_->SetRootLayer(scoped_refptr<cc::Layer>());
 576 }
 577
 578 void RenderWidgetCompositor::setViewportSize(
 579     const WebSize&,
 580     const WebSize& device_viewport_size) {
 581   layer_tree_host_->SetViewportSize(device_viewport_size);
 582 }
 583
 584 void RenderWidgetCompositor::setViewportSize(
 585     const WebSize& device_viewport_size) {
 586   layer_tree_host_->SetViewportSize(device_viewport_size);
 587 }
 588
 589 WebSize RenderWidgetCompositor::layoutViewportSize() const {
 590   return layer_tree_host_->device_viewport_size();
 591 }
 592
 593 WebSize RenderWidgetCompositor::deviceViewportSize() const {
 594   return layer_tree_host_->device_viewport_size();
 595 }
 596
 597 WebFloatPoint RenderWidgetCompositor::adjustEventPointForPinchZoom(
 598     const WebFloatPoint& point) const {
 599   return point;
 600 }
 601
 602 void RenderWidgetCompositor::setDeviceScaleFactor(float device_scale) {
 603   layer_tree_host_->SetDeviceScaleFactor(device_scale);
 604 }
 605
 606 float RenderWidgetCompositor::deviceScaleFactor() const {
 607   return layer_tree_host_->device_scale_factor();
 608 }
 609
 610 void RenderWidgetCompositor::setBackgroundColor(blink::WebColor color) {
 611   layer_tree_host_->set_background_color(color);
 612 }
 613
 614 void RenderWidgetCompositor::setHasTransparentBackground(bool transparent) {
 615   layer_tree_host_->set_has_transparent_background(transparent);
 616 }
 617
 618 void RenderWidgetCompositor::setOverhangBitmap(const SkBitmap& bitmap) {
 619   layer_tree_host_->SetOverhangBitmap(bitmap);
 620 }
 621
 622 void RenderWidgetCompositor::setVisible(bool visible) {
 623   layer_tree_host_->SetVisible(visible);
 624 }
 625
 626 void RenderWidgetCompositor::setPageScaleFactorAndLimits(
 627     float page_scale_factor, float minimum, float maximum) {
 628   layer_tree_host_->SetPageScaleFactorAndLimits(
 629       page_scale_factor, minimum, maximum);
 630 }
 631
 632 void RenderWidgetCompositor::startPageScaleAnimation(
 633     const blink::WebPoint& destination,
 634     bool use_anchor,
 635     float new_page_scale,
 636     double duration_sec) {
 637   base::TimeDelta duration = base::TimeDelta::FromMicroseconds(
 638       duration_sec * base::Time::kMicrosecondsPerSecond);
 639   layer_tree_host_->StartPageScaleAnimation(
 640       gfx::Vector2d(destination.x, destination.y),
 641       use_anchor,
 642       new_page_scale,
 643       duration);
 644 }
 645
 646 void RenderWidgetCompositor::heuristicsForGpuRasterizationUpdated(
 647     bool matches_heuristics) {
 648   layer_tree_host_->SetHasGpuRasterizationTrigger(matches_heuristics);
 649 }
 650
 651 void RenderWidgetCompositor::setNeedsAnimate() {
 652   layer_tree_host_->SetNeedsAnimate();
 653 }
 654
 655 bool RenderWidgetCompositor::commitRequested() const {
 656   return layer_tree_host_->CommitRequested();
 657 }
 658
 659 void RenderWidgetCompositor::didStopFlinging() {
 660   layer_tree_host_->DidStopFlinging();
 661 }
 662
 663 void RenderWidgetCompositor::registerForAnimations(blink::WebLayer* layer) {
 664   cc::Layer* cc_layer = static_cast<cc_blink::WebLayerImpl*>(layer)->layer();
 665   cc_layer->layer_animation_controller()->SetAnimationRegistrar(
 666       layer_tree_host_->animation_registrar());
 667 }
 668
 669 void RenderWidgetCompositor::registerViewportLayers(
 670     const blink::WebLayer* pageScaleLayer,
 671     const blink::WebLayer* innerViewportScrollLayer,
 672     const blink::WebLayer* outerViewportScrollLayer) {
 673   layer_tree_host_->RegisterViewportLayers(
 674       static_cast<const cc_blink::WebLayerImpl*>(pageScaleLayer)->layer(),
 675       static_cast<const cc_blink::WebLayerImpl*>(innerViewportScrollLayer)
 676           ->layer(),
 677       // The outer viewport layer will only exist when using pinch virtual
 678       // viewports.
 679       outerViewportScrollLayer ? static_cast<const cc_blink::WebLayerImpl*>(
 680                                      outerViewportScrollLayer)->layer()
 681                                : NULL);
 682 }
 683
 684 void RenderWidgetCompositor::clearViewportLayers() {
 685   layer_tree_host_->RegisterViewportLayers(scoped_refptr<cc::Layer>(),
 686                                            scoped_refptr<cc::Layer>(),
 687                                            scoped_refptr<cc::Layer>());
 688 }
 689
 690 void RenderWidgetCompositor::registerSelection(
 691     const blink::WebSelectionBound& start,
 692     const blink::WebSelectionBound& end) {
 693   layer_tree_host_->RegisterSelection(ConvertWebSelectionBound(start),
 694                                       ConvertWebSelectionBound(end));
 695 }
 696
 697 void RenderWidgetCompositor::clearSelection() {
 698   cc::LayerSelectionBound empty_selection;
 699   layer_tree_host_->RegisterSelection(empty_selection, empty_selection);
 700 }
 701
 702 void CompositeAndReadbackAsyncCallback(
 703     blink::WebCompositeAndReadbackAsyncCallback* callback,
 704     scoped_ptr<cc::CopyOutputResult> result) {
 705   if (result->HasBitmap()) {
 706     scoped_ptr<SkBitmap> result_bitmap = result->TakeBitmap();
 707     callback->didCompositeAndReadback(*result_bitmap);
 708   } else {
 709     callback->didCompositeAndReadback(SkBitmap());
 710   }
 711 }
 712
 713 void RenderWidgetCompositor::compositeAndReadbackAsync(
 714     blink::WebCompositeAndReadbackAsyncCallback* callback) {
 715   DCHECK(!temporary_copy_output_request_);
 716   temporary_copy_output_request_ =
 717       cc::CopyOutputRequest::CreateBitmapRequest(
 718           base::Bind(&CompositeAndReadbackAsyncCallback, callback));
 719   // Force a commit to happen. The temporary copy output request will
 720   // be installed after layout which will happen as a part of the commit, when
 721   // there is guaranteed to be a root layer.
 722   if (!threaded_ &&
 723       !layer_tree_host_->settings().single_thread_proxy_scheduler) {
 724     layer_tree_host_->Composite(gfx::FrameTime::Now());
 725   } else {
 726     layer_tree_host_->SetNeedsCommit();
 727   }
 728 }
 729
 730 void RenderWidgetCompositor::finishAllRendering() {
 731   layer_tree_host_->FinishAllRendering();
 732 }
 733
 734 void RenderWidgetCompositor::setDeferCommits(bool defer_commits) {
 735   layer_tree_host_->SetDeferCommits(defer_commits);
 736 }
 737
 738 void RenderWidgetCompositor::setShowFPSCounter(bool show) {
 739   cc::LayerTreeDebugState debug_state = layer_tree_host_->debug_state();
 740   debug_state.show_fps_counter = show;
 741   layer_tree_host_->SetDebugState(debug_state);
 742 }
 743
 744 void RenderWidgetCompositor::setShowPaintRects(bool show) {
 745   cc::LayerTreeDebugState debug_state = layer_tree_host_->debug_state();
 746   debug_state.show_paint_rects = show;
 747   layer_tree_host_->SetDebugState(debug_state);
 748 }
 749
 750 void RenderWidgetCompositor::setShowDebugBorders(bool show) {
 751   cc::LayerTreeDebugState debug_state = layer_tree_host_->debug_state();
 752   debug_state.show_debug_borders = show;
 753   layer_tree_host_->SetDebugState(debug_state);
 754 }
 755
 756 void RenderWidgetCompositor::setContinuousPaintingEnabled(bool enabled) {
 757   cc::LayerTreeDebugState debug_state = layer_tree_host_->debug_state();
 758   debug_state.continuous_painting = enabled;
 759   layer_tree_host_->SetDebugState(debug_state);
 760 }
 761
 762 void RenderWidgetCompositor::setShowScrollBottleneckRects(bool show) {
 763   cc::LayerTreeDebugState debug_state = layer_tree_host_->debug_state();
 764   debug_state.show_touch_event_handler_rects = show;
 765   debug_state.show_wheel_event_handler_rects = show;
 766   debug_state.show_non_fast_scrollable_rects = show;
 767   layer_tree_host_->SetDebugState(debug_state);
 768 }
 769
 770 void RenderWidgetCompositor::setTopControlsContentOffset(float offset) {
 771   layer_tree_host_->SetTopControlsContentOffset(offset);
 772 }
 773
 774 void RenderWidgetCompositor::WillBeginMainFrame(int frame_id) {
 775   widget_->InstrumentWillBeginFrame(frame_id);
 776   widget_->willBeginCompositorFrame();
 777 }
 778
 779 void RenderWidgetCompositor::DidBeginMainFrame() {
 780   widget_->InstrumentDidBeginFrame();
 781 }
 782
 783 void RenderWidgetCompositor::BeginMainFrame(const cc::BeginFrameArgs& args) {
 784   begin_main_frame_time_ = args.frame_time;
 785   begin_main_frame_interval_ = args.interval;
 786   double frame_time_sec = (args.frame_time - base::TimeTicks()).InSecondsF();
 787   double deadline_sec = (args.deadline - base::TimeTicks()).InSecondsF();
 788   double interval_sec = args.interval.InSecondsF();
 789   WebBeginFrameArgs web_begin_frame_args =
 790       WebBeginFrameArgs(frame_time_sec, deadline_sec, interval_sec);
 791   widget_->webwidget()->beginFrame(web_begin_frame_args);
 792 }
 793
 794 void RenderWidgetCompositor::Layout() {
 795   widget_->webwidget()->layout();
 796
 797   if (temporary_copy_output_request_) {
 798     DCHECK(layer_tree_host_->root_layer());
 799     layer_tree_host_->root_layer()->RequestCopyOfOutput(
 800         temporary_copy_output_request_.Pass());
 801   }
 802 }
 803
 804 void RenderWidgetCompositor::ApplyViewportDeltas(
 805     const gfx::Vector2d& inner_delta,
 806     const gfx::Vector2d& outer_delta,
 807     float page_scale,
 808     float top_controls_delta) {
 809   widget_->webwidget()->applyViewportDeltas(
 810       inner_delta,
 811       outer_delta,
 812       page_scale,
 813       top_controls_delta);
 814 }
 815
 816 void RenderWidgetCompositor::ApplyViewportDeltas(
 817     const gfx::Vector2d& scroll_delta,
 818     float page_scale,
 819     float top_controls_delta) {
 820   widget_->webwidget()->applyViewportDeltas(
 821       scroll_delta,
 822       page_scale,
 823       top_controls_delta);
 824 }
 825
 826 void RenderWidgetCompositor::RequestNewOutputSurface(bool fallback) {
 827   layer_tree_host_->SetOutputSurface(widget_->CreateOutputSurface(fallback));
 828 }
 829
 830 void RenderWidgetCompositor::DidInitializeOutputSurface() {
 831 }
 832
 833 void RenderWidgetCompositor::WillCommit() {
 834   widget_->InstrumentWillComposite();
 835 }
 836
 837 void RenderWidgetCompositor::DidCommit() {
 838   DCHECK(!temporary_copy_output_request_);
 839   if (send_v8_idle_notification_after_commit_) {
 840     base::TimeDelta idle_time = begin_main_frame_time_ +
 841                                 begin_main_frame_interval_ -
 842                                 gfx::FrameTime::Now();
 843     if (idle_time > base::TimeDelta()) {
 844       // Convert to 32-bit microseconds first to avoid costly 64-bit division.
 845       int32 idle_time_in_us = idle_time.InMicroseconds();
 846       int32 idle_time_in_ms = idle_time_in_us / 1000;
 847       if (idle_time_in_ms)
 848         blink::mainThreadIsolate()->IdleNotification(idle_time_in_ms);
 849     }
 850   }
 851
 852   widget_->DidCommitCompositorFrame();
 853   widget_->didBecomeReadyForAdditionalInput();
 854   widget_->webwidget()->didCommitFrameToCompositor();
 855 }
 856
 857 void RenderWidgetCompositor::DidCommitAndDrawFrame() {
 858   widget_->didCommitAndDrawCompositorFrame();
 859 }
 860
 861 void RenderWidgetCompositor::DidCompleteSwapBuffers() {
 862   widget_->didCompleteSwapBuffers();
 863   if (!threaded_)
 864     widget_->OnSwapBuffersComplete();
 865 }
 866
 867 void RenderWidgetCompositor::ScheduleAnimation() {
 868   widget_->scheduleAnimation();
 869 }
 870
 871 void RenderWidgetCompositor::DidPostSwapBuffers() {
 872   widget_->OnSwapBuffersPosted();
 873 }
 874
 875 void RenderWidgetCompositor::DidAbortSwapBuffers() {
 876   widget_->OnSwapBuffersAborted();
 877 }
 878
 879 void RenderWidgetCompositor::RateLimitSharedMainThreadContext() {
 880   cc::ContextProvider* provider =
 881       RenderThreadImpl::current()->SharedMainThreadContextProvider().get();
 882   provider->ContextGL()->RateLimitOffscreenContextCHROMIUM();
 883 }
 884
 885 }  // namespace content