#include <limits>
#include <string>
-#if defined(OS_ANDROID)
-#include "base/android/sys_utils.h"
-#endif
-
#include "base/command_line.h"
#include "base/logging.h"
#include "base/strings/string_number_conversions.h"
#include "base/synchronization/lock.h"
+#include "base/sys_info.h"
#include "base/time/time.h"
#include "base/values.h"
#include "cc/base/latency_info_swap_promise.h"
#include "cc/base/latency_info_swap_promise_monitor.h"
+#include "cc/base/swap_promise.h"
#include "cc/base/switches.h"
+#include "cc/blink/web_layer_impl.h"
#include "cc/debug/layer_tree_debug_state.h"
#include "cc/debug/micro_benchmark.h"
+#include "cc/input/layer_selection_bound.h"
#include "cc/layers/layer.h"
+#include "cc/output/begin_frame_args.h"
#include "cc/output/copy_output_request.h"
#include "cc/output/copy_output_result.h"
#include "cc/resources/single_release_callback.h"
#include "content/renderer/render_thread_impl.h"
#include "gpu/command_buffer/client/gles2_interface.h"
#include "third_party/WebKit/public/platform/WebCompositeAndReadbackAsyncCallback.h"
+#include "third_party/WebKit/public/platform/WebSelectionBound.h"
#include "third_party/WebKit/public/platform/WebSize.h"
+#include "third_party/WebKit/public/web/WebKit.h"
#include "third_party/WebKit/public/web/WebWidget.h"
#include "ui/gfx/frame_time.h"
#include "ui/gl/gl_switches.h"
#include "ui/native_theme/native_theme_switches.h"
-#include "webkit/renderer/compositor_bindings/web_layer_impl.h"
+
+#if defined(OS_ANDROID)
+#include "content/renderer/android/synchronous_compositor_factory.h"
+#include "ui/gfx/android/device_display_info.h"
+#endif
namespace base {
class Value;
class Layer;
}
+using blink::WebBeginFrameArgs;
using blink::WebFloatPoint;
-using blink::WebSize;
using blink::WebRect;
+using blink::WebSelectionBound;
+using blink::WebSize;
namespace content {
namespace {
}
}
+cc::LayerSelectionBound ConvertWebSelectionBound(
+ const WebSelectionBound& web_bound) {
+ DCHECK(web_bound.layerId);
+
+ cc::LayerSelectionBound cc_bound;
+ switch (web_bound.type) {
+ case blink::WebSelectionBound::Caret:
+ cc_bound.type = cc::SELECTION_BOUND_CENTER;
+ break;
+ case blink::WebSelectionBound::SelectionLeft:
+ cc_bound.type = cc::SELECTION_BOUND_LEFT;
+ break;
+ case blink::WebSelectionBound::SelectionRight:
+ cc_bound.type = cc::SELECTION_BOUND_RIGHT;
+ break;
+ }
+ cc_bound.layer_id = web_bound.layerId;
+ cc_bound.edge_top = gfx::Point(web_bound.edgeTopInLayer);
+ cc_bound.edge_bottom = gfx::Point(web_bound.edgeBottomInLayer);
+ return cc_bound;
+}
+
+gfx::Size CalculateDefaultTileSize() {
+ int default_tile_size = 256;
+#if defined(OS_ANDROID)
+ // TODO(epenner): unify this for all platforms if it
+ // makes sense (http://crbug.com/159524)
+
+ gfx::DeviceDisplayInfo info;
+ bool real_size_supported = true;
+ int display_width = info.GetPhysicalDisplayWidth();
+ int display_height = info.GetPhysicalDisplayHeight();
+ if (display_width == 0 || display_height == 0) {
+ real_size_supported = false;
+ display_width = info.GetDisplayWidth();
+ display_height = info.GetDisplayHeight();
+ }
+
+ int portrait_width = std::min(display_width, display_height);
+ int landscape_width = std::max(display_width, display_height);
+
+ if (real_size_supported) {
+ // Maximum HD dimensions should be 768x1280
+ // Maximum FHD dimensions should be 1200x1920
+ if (portrait_width > 768 || landscape_width > 1280)
+ default_tile_size = 384;
+ if (portrait_width > 1200 || landscape_width > 1920)
+ default_tile_size = 512;
+
+ // Adjust for some resolutions that barely straddle an extra
+ // tile when in portrait mode. This helps worst case scroll/raster
+ // by not needing a full extra tile for each row.
+ if (default_tile_size == 256 && portrait_width == 768)
+ default_tile_size += 32;
+ if (default_tile_size == 384 && portrait_width == 1200)
+ default_tile_size += 32;
+ } else {
+ // We don't know the exact resolution due to screen controls etc.
+ // So this just estimates the values above using tile counts.
+ int numTiles = (display_width * display_height) / (256 * 256);
+ if (numTiles > 16)
+ default_tile_size = 384;
+ if (numTiles >= 40)
+ default_tile_size = 512;
+ }
+#endif
+ return gfx::Size(default_tile_size, default_tile_size);
+}
+
} // namespace
// static
!cmd->HasSwitch(cc::switches::kDisableMainFrameBeforeActivation);
settings.main_frame_before_draw_enabled =
!cmd->HasSwitch(cc::switches::kDisableMainFrameBeforeDraw);
- settings.using_synchronous_renderer_compositor =
- widget->UsingSynchronousRendererCompositor();
- settings.report_overscroll_only_for_scrollable_axes =
- !widget->UsingSynchronousRendererCompositor();
+ settings.report_overscroll_only_for_scrollable_axes = true;
settings.accelerated_animation_enabled =
!cmd->HasSwitch(cc::switches::kDisableThreadedAnimation);
- settings.touch_hit_testing =
- !cmd->HasSwitch(cc::switches::kDisableCompositorTouchHitTesting);
- int default_tile_width = settings.default_tile_size.width();
+ settings.default_tile_size = CalculateDefaultTileSize();
if (cmd->HasSwitch(switches::kDefaultTileWidth)) {
- GetSwitchValueAsInt(*cmd, switches::kDefaultTileWidth, 1,
- std::numeric_limits<int>::max(), &default_tile_width);
+ int tile_width = 0;
+ GetSwitchValueAsInt(*cmd,
+ switches::kDefaultTileWidth,
+ 1,
+ std::numeric_limits<int>::max(),
+ &tile_width);
+ settings.default_tile_size.set_width(tile_width);
}
- int default_tile_height = settings.default_tile_size.height();
if (cmd->HasSwitch(switches::kDefaultTileHeight)) {
- GetSwitchValueAsInt(*cmd, switches::kDefaultTileHeight, 1,
- std::numeric_limits<int>::max(), &default_tile_height);
+ int tile_height = 0;
+ GetSwitchValueAsInt(*cmd,
+ switches::kDefaultTileHeight,
+ 1,
+ std::numeric_limits<int>::max(),
+ &tile_height);
+ settings.default_tile_size.set_height(tile_height);
}
- settings.default_tile_size = gfx::Size(default_tile_width,
- default_tile_height);
int max_untiled_layer_width = settings.max_untiled_layer_size.width();
if (cmd->HasSwitch(switches::kMaxUntiledLayerWidth)) {
render_thread->is_gpu_rasterization_forced();
settings.gpu_rasterization_enabled =
render_thread->is_gpu_rasterization_enabled();
- settings.create_low_res_tiling = render_thread->is_low_res_tiling_enabled();
settings.can_use_lcd_text = render_thread->is_lcd_text_enabled();
settings.use_distance_field_text =
render_thread->is_distance_field_text_enabled();
cmd->HasSwitch(cc::switches::kEnablePinchVirtualViewport);
settings.allow_antialiasing &=
!cmd->HasSwitch(cc::switches::kDisableCompositedAntialiasing);
+ settings.single_thread_proxy_scheduler =
+ !cmd->HasSwitch(switches::kDisableSingleThreadProxyScheduler);
// These flags should be mirrored by UI versions in ui/compositor/.
settings.initial_debug_state.show_debug_borders =
cmd->HasSwitch(cc::switches::kStrictLayerPropertyChangeChecking);
#if defined(OS_ANDROID)
+ SynchronousCompositorFactory* synchronous_compositor_factory =
+ SynchronousCompositorFactory::GetInstance();
+
+ settings.using_synchronous_renderer_compositor =
+ synchronous_compositor_factory;
+ settings.record_full_layer =
+ synchronous_compositor_factory &&
+ synchronous_compositor_factory->RecordFullLayer();
+ settings.report_overscroll_only_for_scrollable_axes =
+ !synchronous_compositor_factory;
settings.max_partial_texture_updates = 0;
- if (widget->UsingSynchronousRendererCompositor()) {
+ if (synchronous_compositor_factory) {
// Android WebView uses system scrollbars, so make ours invisible.
settings.scrollbar_animator = cc::LayerTreeSettings::NoAnimator;
settings.solid_color_scrollbar_color = SK_ColorTRANSPARENT;
settings.highp_threshold_min = 2048;
// Android WebView handles root layer flings itself.
settings.ignore_root_layer_flings =
- widget->UsingSynchronousRendererCompositor();
+ synchronous_compositor_factory;
+ // Memory policy on Android WebView does not depend on whether device is
+ // low end, so always use default policy.
+ bool is_low_end_device =
+ base::SysInfo::IsLowEndDevice() && !synchronous_compositor_factory;
// RGBA_4444 textures are only enabled for low end devices
// and are disabled for Android WebView as it doesn't support the format.
- settings.use_rgba_4444_textures =
- base::android::SysUtils::IsLowEndDevice() &&
- !widget->UsingSynchronousRendererCompositor();
- if (widget->UsingSynchronousRendererCompositor()) {
- // TODO(boliu): Set this ratio for Webview.
- } else if (base::android::SysUtils::IsLowEndDevice()) {
+ settings.use_rgba_4444_textures = is_low_end_device;
+ if (is_low_end_device) {
// On low-end we want to be very carefull about killing other
// apps. So initially we use 50% more memory to avoid flickering
// or raster-on-demand.
}
// Webview does not own the surface so should not clear it.
settings.should_clear_root_render_pass =
- !widget->UsingSynchronousRendererCompositor();
+ !synchronous_compositor_factory;
+
+ // TODO(danakj): Only do this on low end devices.
+ settings.create_low_res_tiling = true;
#elif !defined(OS_MACOSX)
if (ui::IsOverlayScrollbarEnabled()) {
settings.scrollbar_fade_duration_ms = 300;
#endif
+ if (cmd->HasSwitch(switches::kEnableLowResTiling))
+ settings.create_low_res_tiling = true;
+ if (cmd->HasSwitch(switches::kDisableLowResTiling))
+ settings.create_low_res_tiling = false;
+
compositor->Initialize(settings);
return compositor.Pass();
RenderWidgetCompositor::RenderWidgetCompositor(RenderWidget* widget,
bool threaded)
: threaded_(threaded),
- suppress_schedule_composite_(false),
- widget_(widget) {
+ widget_(widget),
+ send_v8_idle_notification_after_commit_(true) {
+ CommandLine* cmd = CommandLine::ForCurrentProcess();
+
+ if (cmd->HasSwitch(switches::kEnableV8IdleNotificationAfterCommit))
+ send_v8_idle_notification_after_commit_ = true;
+ if (cmd->HasSwitch(switches::kDisableV8IdleNotificationAfterCommit))
+ send_v8_idle_notification_after_commit_ = false;
}
RenderWidgetCompositor::~RenderWidgetCompositor() {}
return layer_tree_host_->GetInputHandler();
}
-void RenderWidgetCompositor::SetSuppressScheduleComposite(bool suppress) {
- if (suppress_schedule_composite_ == suppress)
- return;
-
- if (suppress)
- TRACE_EVENT_ASYNC_BEGIN0("gpu",
- "RenderWidgetCompositor::SetSuppressScheduleComposite", this);
- else
- TRACE_EVENT_ASYNC_END0("gpu",
- "RenderWidgetCompositor::SetSuppressScheduleComposite", this);
- suppress_schedule_composite_ = suppress;
-}
-
bool RenderWidgetCompositor::BeginMainFrameRequested() const {
return layer_tree_host_->BeginMainFrameRequested();
}
-void RenderWidgetCompositor::UpdateAnimations(base::TimeTicks time) {
- layer_tree_host_->UpdateClientAnimations(time);
-}
-
-void RenderWidgetCompositor::Composite(base::TimeTicks frame_begin_time) {
- layer_tree_host_->Composite(frame_begin_time);
-}
-
void RenderWidgetCompositor::SetNeedsDisplayOnAllLayers() {
layer_tree_host_->SetNeedsDisplayOnAllLayers();
}
animate);
}
-void RenderWidgetCompositor::SetOverdrawBottomHeight(
- float overdraw_bottom_height) {
- layer_tree_host_->SetOverdrawBottomHeight(overdraw_bottom_height);
+void RenderWidgetCompositor::SetTopControlsLayoutHeight(float height) {
+ layer_tree_host_->SetTopControlsLayoutHeight(height);
}
void RenderWidgetCompositor::SetNeedsRedrawRect(gfx::Rect damage_rect) {
latency, layer_tree_host_.get(), NULL));
}
+void RenderWidgetCompositor::QueueSwapPromise(
+ scoped_ptr<cc::SwapPromise> swap_promise) {
+ layer_tree_host_->QueueSwapPromise(swap_promise.Pass());
+}
+
int RenderWidgetCompositor::GetLayerTreeId() const {
return layer_tree_host_->id();
}
+int RenderWidgetCompositor::GetSourceFrameNumber() const {
+ return layer_tree_host_->source_frame_number();
+}
+
+void RenderWidgetCompositor::SetNeedsCommit() {
+ layer_tree_host_->SetNeedsCommit();
+}
+
void RenderWidgetCompositor::NotifyInputThrottledUntilCommit() {
layer_tree_host_->NotifyInputThrottledUntilCommit();
}
return layer_tree_host_->root_layer();
}
-bool RenderWidgetCompositor::ScheduleMicroBenchmark(
+int RenderWidgetCompositor::ScheduleMicroBenchmark(
const std::string& name,
scoped_ptr<base::Value> value,
const base::Callback<void(scoped_ptr<base::Value>)>& callback) {
return layer_tree_host_->ScheduleMicroBenchmark(name, value.Pass(), callback);
}
+bool RenderWidgetCompositor::SendMessageToMicroBenchmark(
+ int id,
+ scoped_ptr<base::Value> value) {
+ return layer_tree_host_->SendMessageToMicroBenchmark(id, value.Pass());
+}
+
void RenderWidgetCompositor::Initialize(cc::LayerTreeSettings settings) {
scoped_refptr<base::MessageLoopProxy> compositor_message_loop_proxy;
+ scoped_refptr<base::SingleThreadTaskRunner>
+ main_thread_compositor_task_runner(base::MessageLoopProxy::current());
RenderThreadImpl* render_thread = RenderThreadImpl::current();
cc::SharedBitmapManager* shared_bitmap_manager = NULL;
// render_thread may be NULL in tests.
compositor_message_loop_proxy =
render_thread->compositor_message_loop_proxy();
shared_bitmap_manager = render_thread->shared_bitmap_manager();
+ main_thread_compositor_task_runner =
+ render_thread->main_thread_compositor_task_runner();
}
if (compositor_message_loop_proxy.get()) {
- layer_tree_host_ = cc::LayerTreeHost::CreateThreaded(
- this, shared_bitmap_manager, settings, compositor_message_loop_proxy);
+ layer_tree_host_ =
+ cc::LayerTreeHost::CreateThreaded(this,
+ shared_bitmap_manager,
+ settings,
+ main_thread_compositor_task_runner,
+ compositor_message_loop_proxy);
} else {
layer_tree_host_ = cc::LayerTreeHost::CreateSingleThreaded(
- this, this, shared_bitmap_manager, settings);
+ this,
+ this,
+ shared_bitmap_manager,
+ settings,
+ main_thread_compositor_task_runner);
}
DCHECK(layer_tree_host_);
}
void RenderWidgetCompositor::setSurfaceReady() {
- layer_tree_host_->SetLayerTreeHostClientReady();
+ // In tests without a RenderThreadImpl, don't set ready as this kicks
+ // off creating output surfaces that the test can't create.
+ if (RenderThreadImpl::current())
+ layer_tree_host_->SetLayerTreeHostClientReady();
}
void RenderWidgetCompositor::setRootLayer(const blink::WebLayer& layer) {
layer_tree_host_->SetRootLayer(
- static_cast<const webkit::WebLayerImpl*>(&layer)->layer());
+ static_cast<const cc_blink::WebLayerImpl*>(&layer)->layer());
}
void RenderWidgetCompositor::clearRootLayer() {
layer_tree_host_->SetViewportSize(device_viewport_size);
}
+void RenderWidgetCompositor::setViewportSize(
+ const WebSize& device_viewport_size) {
+ layer_tree_host_->SetViewportSize(device_viewport_size);
+}
+
WebSize RenderWidgetCompositor::layoutViewportSize() const {
return layer_tree_host_->device_viewport_size();
}
void RenderWidgetCompositor::heuristicsForGpuRasterizationUpdated(
bool matches_heuristics) {
- layer_tree_host_->set_has_gpu_rasterization_trigger(matches_heuristics);
+ layer_tree_host_->SetHasGpuRasterizationTrigger(matches_heuristics);
}
void RenderWidgetCompositor::setNeedsAnimate() {
}
void RenderWidgetCompositor::registerForAnimations(blink::WebLayer* layer) {
- cc::Layer* cc_layer = static_cast<webkit::WebLayerImpl*>(layer)->layer();
+ cc::Layer* cc_layer = static_cast<cc_blink::WebLayerImpl*>(layer)->layer();
cc_layer->layer_animation_controller()->SetAnimationRegistrar(
layer_tree_host_->animation_registrar());
}
const blink::WebLayer* innerViewportScrollLayer,
const blink::WebLayer* outerViewportScrollLayer) {
layer_tree_host_->RegisterViewportLayers(
- static_cast<const webkit::WebLayerImpl*>(pageScaleLayer)->layer(),
- static_cast<const webkit::WebLayerImpl*>(innerViewportScrollLayer)
+ static_cast<const cc_blink::WebLayerImpl*>(pageScaleLayer)->layer(),
+ static_cast<const cc_blink::WebLayerImpl*>(innerViewportScrollLayer)
->layer(),
// The outer viewport layer will only exist when using pinch virtual
// viewports.
- outerViewportScrollLayer ? static_cast<const webkit::WebLayerImpl*>(
+ outerViewportScrollLayer ? static_cast<const cc_blink::WebLayerImpl*>(
outerViewportScrollLayer)->layer()
: NULL);
}
scoped_refptr<cc::Layer>());
}
-bool RenderWidgetCompositor::compositeAndReadback(
- void *pixels, const WebRect& rect_in_device_viewport) {
- return layer_tree_host_->CompositeAndReadback(pixels,
- rect_in_device_viewport);
+void RenderWidgetCompositor::registerSelection(
+ const blink::WebSelectionBound& start,
+ const blink::WebSelectionBound& end) {
+ layer_tree_host_->RegisterSelection(ConvertWebSelectionBound(start),
+ ConvertWebSelectionBound(end));
+}
+
+void RenderWidgetCompositor::clearSelection() {
+ cc::LayerSelectionBound empty_selection;
+ layer_tree_host_->RegisterSelection(empty_selection, empty_selection);
}
void CompositeAndReadbackAsyncCallback(
cc::CopyOutputRequest::CreateBitmapRequest(
base::Bind(&CompositeAndReadbackAsyncCallback, callback));
layer_tree_host_->root_layer()->RequestCopyOfOutput(request.Pass());
- if (!threaded_) {
- widget_->webwidget()->animate(0.0);
- widget_->webwidget()->layout();
+
+ if (!threaded_ &&
+ !layer_tree_host_->settings().single_thread_proxy_scheduler) {
layer_tree_host_->Composite(gfx::FrameTime::Now());
}
}
layer_tree_host_->SetDebugState(debug_state);
}
+void RenderWidgetCompositor::setTopControlsContentOffset(float offset) {
+ layer_tree_host_->SetTopControlsContentOffset(offset);
+}
+
void RenderWidgetCompositor::WillBeginMainFrame(int frame_id) {
widget_->InstrumentWillBeginFrame(frame_id);
widget_->willBeginCompositorFrame();
widget_->InstrumentDidBeginFrame();
}
-void RenderWidgetCompositor::Animate(base::TimeTicks frame_begin_time) {
- widget_->webwidget()->animate(
- (frame_begin_time - base::TimeTicks()).InSecondsF());
+void RenderWidgetCompositor::BeginMainFrame(const cc::BeginFrameArgs& args) {
+ begin_main_frame_time_ = args.frame_time;
+ begin_main_frame_interval_ = args.interval;
+ double frame_time_sec = (args.frame_time - base::TimeTicks()).InSecondsF();
+ double deadline_sec = (args.deadline - base::TimeTicks()).InSecondsF();
+ double interval_sec = args.interval.InSecondsF();
+ WebBeginFrameArgs web_begin_frame_args =
+ WebBeginFrameArgs(frame_time_sec, deadline_sec, interval_sec);
+ widget_->webwidget()->beginFrame(web_begin_frame_args);
}
void RenderWidgetCompositor::Layout() {
widget_->webwidget()->layout();
}
-void RenderWidgetCompositor::ApplyScrollAndScale(
+void RenderWidgetCompositor::ApplyViewportDeltas(
const gfx::Vector2d& scroll_delta,
- float page_scale) {
- widget_->webwidget()->applyScrollAndScale(scroll_delta, page_scale);
+ float page_scale,
+ float top_controls_delta) {
+ widget_->webwidget()->applyViewportDeltas(
+ scroll_delta,
+ page_scale,
+ top_controls_delta);
}
-scoped_ptr<cc::OutputSurface> RenderWidgetCompositor::CreateOutputSurface(
- bool fallback) {
- return widget_->CreateOutputSurface(fallback);
+void RenderWidgetCompositor::RequestNewOutputSurface(bool fallback) {
+ layer_tree_host_->SetOutputSurface(widget_->CreateOutputSurface(fallback));
}
void RenderWidgetCompositor::DidInitializeOutputSurface() {
}
void RenderWidgetCompositor::DidCommit() {
+ if (send_v8_idle_notification_after_commit_) {
+ base::TimeDelta idle_time = begin_main_frame_time_ +
+ begin_main_frame_interval_ -
+ gfx::FrameTime::Now();
+ if (idle_time > base::TimeDelta()) {
+ // Convert to 32-bit microseconds first to avoid costly 64-bit division.
+ int32 idle_time_in_us = idle_time.InMicroseconds();
+ int32 idle_time_in_ms = idle_time_in_us / 1000;
+ if (idle_time_in_ms)
+ blink::mainThreadIsolate()->IdleNotification(idle_time_in_ms);
+ }
+ }
+
widget_->DidCommitCompositorFrame();
widget_->didBecomeReadyForAdditionalInput();
+ widget_->webwidget()->didCommitFrameToCompositor();
}
void RenderWidgetCompositor::DidCommitAndDrawFrame() {
widget_->OnSwapBuffersComplete();
}
-void RenderWidgetCompositor::ScheduleComposite() {
- if (!suppress_schedule_composite_)
- widget_->scheduleComposite();
-}
-
void RenderWidgetCompositor::ScheduleAnimation() {
widget_->scheduleAnimation();
}
projects / platform / framework / web / crosswalk.git / blobdiff