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