#include "content/renderer/render_widget.h"
+#include "base/auto_reset.h"
#include "base/bind.h"
#include "base/command_line.h"
#include "base/debug/trace_event.h"
#include "base/metrics/histogram.h"
#include "base/stl_util.h"
#include "base/strings/utf_string_conversions.h"
+#include "base/sys_info.h"
#include "build/build_config.h"
#include "cc/base/switches.h"
#include "cc/debug/benchmark_instrumentation.h"
#include "content/renderer/gpu/compositor_output_surface.h"
#include "content/renderer/gpu/compositor_software_output_device.h"
#include "content/renderer/gpu/delegated_compositor_output_surface.h"
+#include "content/renderer/gpu/frame_swap_message_queue.h"
#include "content/renderer/gpu/mailbox_output_surface.h"
+#include "content/renderer/gpu/queue_message_swap_promise.h"
#include "content/renderer/gpu/render_widget_compositor.h"
#include "content/renderer/ime_event_guard.h"
#include "content/renderer/input/input_handler_manager.h"
#include "content/renderer/pepper/pepper_plugin_instance_impl.h"
#include "content/renderer/render_frame_impl.h"
+#include "content/renderer/render_frame_proxy.h"
#include "content/renderer/render_process.h"
#include "content/renderer/render_thread_impl.h"
#include "content/renderer/renderer_webkitplatformsupport_impl.h"
#include "third_party/WebKit/public/platform/WebScreenInfo.h"
#include "third_party/WebKit/public/platform/WebSize.h"
#include "third_party/WebKit/public/platform/WebString.h"
-#include "third_party/WebKit/public/web/WebHelperPlugin.h"
+#include "third_party/WebKit/public/web/WebDeviceEmulationParams.h"
#include "third_party/WebKit/public/web/WebPagePopup.h"
#include "third_party/WebKit/public/web/WebPopupMenu.h"
#include "third_party/WebKit/public/web/WebPopupMenuInfo.h"
#include "third_party/skia/include/core/SkShader.h"
#include "ui/base/ui_base_switches.h"
#include "ui/gfx/frame_time.h"
+#include "ui/gfx/point_conversions.h"
#include "ui/gfx/rect_conversions.h"
#include "ui/gfx/size_conversions.h"
#include "ui/gfx/skia_util.h"
#include "ui/surface/transport_dib.h"
#if defined(OS_ANDROID)
-#include "base/android/sys_utils.h"
+#include <android/keycodes.h>
#include "content/renderer/android/synchronous_compositor_factory.h"
#endif
using blink::WebCompositionUnderline;
using blink::WebCursorInfo;
+using blink::WebDeviceEmulationParams;
using blink::WebGestureEvent;
using blink::WebInputEvent;
using blink::WebKeyboardEvent;
return it->second;
}
+bool IsThreadedCompositingEnabled() {
+ content::RenderThreadImpl* impl = content::RenderThreadImpl::current();
+ return impl && !!impl->compositor_message_loop_proxy().get();
+}
+
// TODO(brianderson): Replace the hard-coded threshold with a fraction of
// the BeginMainFrame interval.
// 4166us will allow 1/4 of a 60Hz interval or 1/2 of a 120Hz interval to
public:
ScreenMetricsEmulator(
RenderWidget* widget,
- const gfx::Rect& device_rect,
- const gfx::Rect& widget_rect,
- float device_scale_factor,
- bool fit_to_view);
+ const WebDeviceEmulationParams& params);
virtual ~ScreenMetricsEmulator();
+ // Scale and offset used to convert between host coordinates
+ // and webwidget coordinates.
float scale() { return scale_; }
gfx::Point offset() { return offset_; }
- gfx::Rect widget_rect() const { return widget_rect_; }
+ gfx::Rect applied_widget_rect() const { return applied_widget_rect_; }
gfx::Rect original_screen_rect() const { return original_view_screen_rect_; }
+ const WebScreenInfo& original_screen_info() { return original_screen_info_; }
void ChangeEmulationParams(
- const gfx::Rect& device_rect,
- const gfx::Rect& widget_rect,
- float device_scale_factor,
- bool fit_to_view);
+ const WebDeviceEmulationParams& params);
// The following methods alter handlers' behavior for messages related to
// widget size and position.
void OnUpdateScreenRectsMessage(const gfx::Rect& view_screen_rect,
const gfx::Rect& window_screen_rect);
void OnShowContextMenu(ContextMenuParams* params);
+ gfx::Rect AdjustValidationMessageAnchor(const gfx::Rect& anchor);
private:
+ void Reapply();
void Apply(float overdraw_bottom_height,
- gfx::Rect resizer_rect, bool is_fullscreen);
+ gfx::Rect resizer_rect,
+ bool is_fullscreen);
RenderWidget* widget_;
// Parameters as passed by RenderWidget::EnableScreenMetricsEmulation.
- gfx::Rect device_rect_;
- gfx::Rect widget_rect_;
- float device_scale_factor_;
- bool fit_to_view_;
+ WebDeviceEmulationParams params_;
// The computed scale and offset used to fit widget into browser window.
float scale_;
gfx::Point offset_;
+ // Widget rect as passed to webwidget.
+ gfx::Rect applied_widget_rect_;
+
// Original values to restore back after emulation ends.
gfx::Size original_size_;
gfx::Size original_physical_backing_size_;
+ gfx::Size original_visible_viewport_size_;
blink::WebScreenInfo original_screen_info_;
gfx::Rect original_view_screen_rect_;
gfx::Rect original_window_screen_rect_;
RenderWidget::ScreenMetricsEmulator::ScreenMetricsEmulator(
RenderWidget* widget,
- const gfx::Rect& device_rect,
- const gfx::Rect& widget_rect,
- float device_scale_factor,
- bool fit_to_view)
+ const WebDeviceEmulationParams& params)
: widget_(widget),
- device_rect_(device_rect),
- widget_rect_(widget_rect),
- device_scale_factor_(device_scale_factor),
- fit_to_view_(fit_to_view),
+ params_(params),
scale_(1.f) {
original_size_ = widget_->size_;
original_physical_backing_size_ = widget_->physical_backing_size_;
+ original_visible_viewport_size_ = widget_->visible_viewport_size_;
original_screen_info_ = widget_->screen_info_;
original_view_screen_rect_ = widget_->view_screen_rect_;
original_window_screen_rect_ = widget_->window_screen_rect_;
- Apply(widget_->overdraw_bottom_height_,
- widget_->resizer_rect_, widget_->is_fullscreen_);
+ Apply(widget_->overdraw_bottom_height_, widget_->resizer_rect_,
+ widget_->is_fullscreen_);
}
RenderWidget::ScreenMetricsEmulator::~ScreenMetricsEmulator() {
widget_->view_screen_rect_ = original_view_screen_rect_;
widget_->window_screen_rect_ = original_window_screen_rect_;
widget_->Resize(original_size_, original_physical_backing_size_,
- widget_->overdraw_bottom_height_, widget_->resizer_rect_,
- widget_->is_fullscreen_, NO_RESIZE_ACK);
+ widget_->overdraw_bottom_height_, original_visible_viewport_size_,
+ widget_->resizer_rect_, widget_->is_fullscreen_, NO_RESIZE_ACK);
}
void RenderWidget::ScreenMetricsEmulator::ChangeEmulationParams(
- const gfx::Rect& device_rect,
- const gfx::Rect& widget_rect,
- float device_scale_factor,
- bool fit_to_view) {
- device_rect_ = device_rect;
- widget_rect_ = widget_rect;
- device_scale_factor_ = device_scale_factor;
- fit_to_view_ = fit_to_view;
- Apply(widget_->overdraw_bottom_height_,
- widget_->resizer_rect_, widget_->is_fullscreen_);
+ const WebDeviceEmulationParams& params) {
+ params_ = params;
+ Reapply();
+}
+
+void RenderWidget::ScreenMetricsEmulator::Reapply() {
+ Apply(widget_->overdraw_bottom_height_, widget_->resizer_rect_,
+ widget_->is_fullscreen_);
}
void RenderWidget::ScreenMetricsEmulator::Apply(
- float overdraw_bottom_height, gfx::Rect resizer_rect, bool is_fullscreen) {
- if (fit_to_view_) {
- DCHECK(!original_size_.IsEmpty());
-
- int width_with_gutter =
- std::max(original_size_.width() - 2 * device_rect_.x(), 1);
- int height_with_gutter =
- std::max(original_size_.height() - 2 * device_rect_.y(), 1);
+ float overdraw_bottom_height,
+ gfx::Rect resizer_rect,
+ bool is_fullscreen) {
+ applied_widget_rect_.set_size(gfx::Size(params_.viewSize));
+ if (!applied_widget_rect_.width())
+ applied_widget_rect_.set_width(original_size_.width());
+ if (!applied_widget_rect_.height())
+ applied_widget_rect_.set_height(original_size_.height());
+
+ if (params_.fitToView && !original_size_.IsEmpty()) {
+ int original_width = std::max(original_size_.width(), 1);
+ int original_height = std::max(original_size_.height(), 1);
float width_ratio =
- static_cast<float>(widget_rect_.width()) / width_with_gutter;
+ static_cast<float>(applied_widget_rect_.width()) / original_width;
float height_ratio =
- static_cast<float>(widget_rect_.height()) / height_with_gutter;
+ static_cast<float>(applied_widget_rect_.height()) / original_height;
float ratio = std::max(1.0f, std::max(width_ratio, height_ratio));
scale_ = 1.f / ratio;
+
+ // Center emulated view inside available view space.
+ offset_.set_x(
+ (original_size_.width() - scale_ * applied_widget_rect_.width()) / 2);
+ offset_.set_y(
+ (original_size_.height() - scale_ * applied_widget_rect_.height()) / 2);
} else {
- scale_ = 1.f;
+ scale_ = params_.scale;
+ offset_.SetPoint(params_.offset.x, params_.offset.y);
}
- // Center emulated view inside available view space.
- offset_.set_x((original_size_.width() - scale_ * widget_rect_.width()) / 2);
- offset_.set_y((original_size_.height() - scale_ * widget_rect_.height()) / 2);
+ if (params_.screenPosition == WebDeviceEmulationParams::Desktop) {
+ applied_widget_rect_.set_origin(original_view_screen_rect_.origin());
+ widget_->screen_info_.rect = original_screen_info_.rect;
+ widget_->screen_info_.availableRect = original_screen_info_.availableRect;
+ widget_->window_screen_rect_ = original_window_screen_rect_;
+ } else {
+ applied_widget_rect_.set_origin(gfx::Point(0, 0));
+ widget_->screen_info_.rect = applied_widget_rect_;
+ widget_->screen_info_.availableRect = applied_widget_rect_;
+ widget_->window_screen_rect_ = applied_widget_rect_;
+ }
- widget_->screen_info_.rect = gfx::Rect(device_rect_.size());
- widget_->screen_info_.availableRect = gfx::Rect(device_rect_.size());
- widget_->screen_info_.deviceScaleFactor = device_scale_factor_;
+ float applied_device_scale_factor = params_.deviceScaleFactor ?
+ params_.deviceScaleFactor : original_screen_info_.deviceScaleFactor;
+ widget_->screen_info_.deviceScaleFactor = applied_device_scale_factor;
// Pass three emulation parameters to the blink side:
// - we keep the real device scale factor in compositor to produce sharp image
widget_->SetScreenMetricsEmulationParameters(
original_screen_info_.deviceScaleFactor, offset_, scale_);
- widget_->SetDeviceScaleFactor(device_scale_factor_);
- widget_->view_screen_rect_ = widget_rect_;
- widget_->window_screen_rect_ = widget_->screen_info_.availableRect;
+ widget_->SetDeviceScaleFactor(applied_device_scale_factor);
+ widget_->view_screen_rect_ = applied_widget_rect_;
gfx::Size physical_backing_size = gfx::ToCeiledSize(gfx::ScaleSize(
original_size_, original_screen_info_.deviceScaleFactor));
- widget_->Resize(widget_rect_.size(), physical_backing_size,
- overdraw_bottom_height, resizer_rect, is_fullscreen, NO_RESIZE_ACK);
+ widget_->Resize(applied_widget_rect_.size(), physical_backing_size,
+ overdraw_bottom_height, applied_widget_rect_.size(), resizer_rect,
+ is_fullscreen, NO_RESIZE_ACK);
}
void RenderWidget::ScreenMetricsEmulator::OnResizeMessage(
original_size_ = params.new_size;
original_physical_backing_size_ = params.physical_backing_size;
original_screen_info_ = params.screen_info;
+ original_visible_viewport_size_ = params.visible_viewport_size;
Apply(params.overdraw_bottom_height, params.resizer_rect,
- params.is_fullscreen);
+ params.is_fullscreen);
if (need_ack) {
widget_->set_next_paint_is_resize_ack();
const gfx::Rect& window_screen_rect) {
original_view_screen_rect_ = view_screen_rect;
original_window_screen_rect_ = window_screen_rect;
+ if (params_.screenPosition == WebDeviceEmulationParams::Desktop)
+ Reapply();
}
void RenderWidget::ScreenMetricsEmulator::OnShowContextMenu(
params->y += offset_.y();
}
+gfx::Rect RenderWidget::ScreenMetricsEmulator::AdjustValidationMessageAnchor(
+ const gfx::Rect& anchor) {
+ gfx::Rect scaled = gfx::ToEnclosedRect(gfx::ScaleRect(anchor, scale_));
+ scaled.set_x(scaled.x() + offset_.x());
+ scaled.set_y(scaled.y() + offset_.y());
+ return scaled;
+}
+
// RenderWidget ---------------------------------------------------------------
RenderWidget::RenderWidget(blink::WebPopupType popup_type,
const blink::WebScreenInfo& screen_info,
bool swapped_out,
- bool hidden)
+ bool hidden,
+ bool never_visible)
: routing_id_(MSG_ROUTING_NONE),
surface_id_(0),
webwidget_(NULL),
opener_id_(MSG_ROUTING_NONE),
init_complete_(false),
- current_paint_buf_(NULL),
overdraw_bottom_height_(0.f),
next_paint_flags_(0),
- filtered_time_per_frame_(0.0f),
- update_reply_pending_(false),
auto_resize_mode_(false),
need_update_rect_for_auto_resize_(false),
- using_asynchronous_swapbuffers_(false),
- num_swapbuffers_complete_pending_(0),
did_show_(false),
is_hidden_(hidden),
+ never_visible_(never_visible),
is_fullscreen_(false),
- needs_repainting_on_restore_(false),
has_focus_(false),
handling_input_event_(false),
handling_ime_event_(false),
- handling_touchstart_event_(false),
+ handling_event_type_(WebInputEvent::Undefined),
+ ignore_ack_for_mouse_move_from_debugger_(false),
closing_(false),
is_swapped_out_(swapped_out),
input_method_is_active_(false),
popup_type_(popup_type),
pending_window_rect_count_(0),
suppress_next_char_events_(false),
- is_accelerated_compositing_active_(false),
- was_accelerated_compositing_ever_active_(false),
- animation_update_pending_(false),
- invalidation_task_posted_(false),
screen_info_(screen_info),
device_scale_factor_(screen_info_.deviceScaleFactor),
- is_threaded_compositing_enabled_(false),
+ current_event_latency_info_(NULL),
next_output_surface_id_(0),
#if defined(OS_ANDROID)
+ text_field_is_dirty_(false),
outstanding_ime_acks_(0),
+ body_background_color_(SK_ColorWHITE),
#endif
popup_origin_scale_for_emulation_(0.f),
+ frame_swap_message_queue_(new FrameSwapMessageQueue()),
resizing_mode_selector_(new ResizingModeSelector()),
- context_menu_source_type_(ui::MENU_SOURCE_MOUSE) {
+ context_menu_source_type_(ui::MENU_SOURCE_MOUSE),
+ has_host_context_menu_location_(false) {
if (!swapped_out)
RenderProcess::current()->AddRefProcess();
DCHECK(RenderThread::Get());
- has_disable_gpu_vsync_switch_ = CommandLine::ForCurrentProcess()->HasSwitch(
- switches::kDisableGpuVsync);
- is_threaded_compositing_enabled_ =
- CommandLine::ForCurrentProcess()->HasSwitch(
- switches::kEnableThreadedCompositing);
-
- legacy_software_mode_stats_ = cc::RenderingStatsInstrumentation::Create();
- if (CommandLine::ForCurrentProcess()->HasSwitch(
- cc::switches::kEnableGpuBenchmarking))
- legacy_software_mode_stats_->set_record_rendering_stats(true);
+ device_color_profile_.push_back('0');
}
RenderWidget::~RenderWidget() {
DCHECK(!webwidget_) << "Leaking our WebWidget!";
- STLDeleteElements(&updates_pending_swap_);
- if (current_paint_buf_) {
- if (RenderProcess::current()) {
- // If the RenderProcess is already gone, it will have released all DIBs
- // in its destructor anyway.
- RenderProcess::current()->ReleaseTransportDIB(current_paint_buf_);
- }
- current_paint_buf_ = NULL;
- }
// If we are swapped out, we have released already.
if (!is_swapped_out_ && RenderProcess::current())
const blink::WebScreenInfo& screen_info) {
DCHECK(opener_id != MSG_ROUTING_NONE);
scoped_refptr<RenderWidget> widget(
- new RenderWidget(popup_type, screen_info, false, false));
+ new RenderWidget(popup_type, screen_info, false, false, false));
if (widget->Init(opener_id)) { // adds reference on success.
return widget.get();
}
return WebPopupMenu::create(render_widget);
case blink::WebPopupTypePage:
return WebPagePopup::create(render_widget);
- case blink::WebPopupTypeHelperPlugin:
- return blink::WebHelperPlugin::create(render_widget);
default:
NOTREACHED();
}
init_complete_ = true;
- if (webwidget_ && is_threaded_compositing_enabled_) {
- webwidget_->enterForceCompositingMode(true);
- }
- if (compositor_) {
- compositor_->setSurfaceReady();
- }
- DoDeferredUpdate();
+ if (compositor_)
+ StartCompositor();
Send(new ViewHostMsg_RenderViewReady(routing_id_));
}
RenderProcess::current()->AddRefProcess();
}
-bool RenderWidget::AllowPartialSwap() const {
- return true;
-}
-
-bool RenderWidget::UsingSynchronousRendererCompositor() const {
-#if defined(OS_ANDROID)
- return SynchronousCompositorFactory::GetInstance() != NULL;
-#else
- return false;
-#endif
-}
-
void RenderWidget::EnableScreenMetricsEmulation(
- const gfx::Rect& device_rect,
- const gfx::Rect& widget_rect,
- float device_scale_factor,
- bool fit_to_view) {
- if (!screen_metrics_emulator_) {
- screen_metrics_emulator_.reset(new ScreenMetricsEmulator(this,
- device_rect, widget_rect, device_scale_factor, fit_to_view));
- } else {
- screen_metrics_emulator_->ChangeEmulationParams(device_rect,
- widget_rect, device_scale_factor, fit_to_view);
- }
+ const WebDeviceEmulationParams& params) {
+ if (!screen_metrics_emulator_)
+ screen_metrics_emulator_.reset(new ScreenMetricsEmulator(this, params));
+ else
+ screen_metrics_emulator_->ChangeEmulationParams(params);
}
void RenderWidget::DisableScreenMetricsEmulation() {
void RenderWidget::SetPopupOriginAdjustmentsForEmulation(
ScreenMetricsEmulator* emulator) {
popup_origin_scale_for_emulation_ = emulator->scale();
- popup_view_origin_for_emulation_ = emulator->widget_rect().origin();
+ popup_view_origin_for_emulation_ = emulator->applied_widget_rect().origin();
popup_screen_origin_for_emulation_ = gfx::Point(
emulator->original_screen_rect().origin().x() + emulator->offset().x(),
emulator->original_screen_rect().origin().y() + emulator->offset().y());
+ screen_info_ = emulator->original_screen_info();
+ device_scale_factor_ = screen_info_.deviceScaleFactor;
+}
+
+gfx::Rect RenderWidget::AdjustValidationMessageAnchor(const gfx::Rect& anchor) {
+ if (screen_metrics_emulator_)
+ return screen_metrics_emulator_->AdjustValidationMessageAnchor(anchor);
+ return anchor;
}
void RenderWidget::SetScreenMetricsEmulationParameters(
NOTREACHED();
}
+#if defined(OS_MACOSX) || defined(OS_ANDROID)
void RenderWidget::SetExternalPopupOriginAdjustmentsForEmulation(
ExternalPopupMenu* popup, ScreenMetricsEmulator* emulator) {
popup->SetOriginScaleAndOffsetForEmulation(
emulator->scale(), emulator->offset());
}
+#endif
void RenderWidget::OnShowHostContextMenu(ContextMenuParams* params) {
if (screen_metrics_emulator_)
IPC_MESSAGE_HANDLER(InputMsg_HandleInputEvent, OnHandleInputEvent)
IPC_MESSAGE_HANDLER(InputMsg_CursorVisibilityChange,
OnCursorVisibilityChange)
+ IPC_MESSAGE_HANDLER(InputMsg_ImeSetComposition, OnImeSetComposition)
+ IPC_MESSAGE_HANDLER(InputMsg_ImeConfirmComposition, OnImeConfirmComposition)
IPC_MESSAGE_HANDLER(InputMsg_MouseCaptureLost, OnMouseCaptureLost)
IPC_MESSAGE_HANDLER(InputMsg_SetFocus, OnSetFocus)
IPC_MESSAGE_HANDLER(InputMsg_SyntheticGestureCompleted,
IPC_MESSAGE_HANDLER(ViewMsg_WasHidden, OnWasHidden)
IPC_MESSAGE_HANDLER(ViewMsg_WasShown, OnWasShown)
IPC_MESSAGE_HANDLER(ViewMsg_WasSwappedOut, OnWasSwappedOut)
- IPC_MESSAGE_HANDLER(ViewMsg_UpdateRect_ACK, OnUpdateRectAck)
- IPC_MESSAGE_HANDLER(ViewMsg_SwapBuffers_ACK, OnSwapBuffersComplete)
IPC_MESSAGE_HANDLER(ViewMsg_SetInputMethodActive, OnSetInputMethodActive)
IPC_MESSAGE_HANDLER(ViewMsg_CandidateWindowShown, OnCandidateWindowShown)
IPC_MESSAGE_HANDLER(ViewMsg_CandidateWindowUpdated,
OnCandidateWindowUpdated)
IPC_MESSAGE_HANDLER(ViewMsg_CandidateWindowHidden, OnCandidateWindowHidden)
- IPC_MESSAGE_HANDLER(ViewMsg_ImeSetComposition, OnImeSetComposition)
- IPC_MESSAGE_HANDLER(ViewMsg_ImeConfirmComposition, OnImeConfirmComposition)
IPC_MESSAGE_HANDLER(ViewMsg_Repaint, OnRepaint)
IPC_MESSAGE_HANDLER(ViewMsg_SetTextDirection, OnSetTextDirection)
IPC_MESSAGE_HANDLER(ViewMsg_Move_ACK, OnRequestMoveAck)
IPC_MESSAGE_HANDLER(ViewMsg_ShowImeIfNeeded, OnShowImeIfNeeded)
IPC_MESSAGE_HANDLER(ViewMsg_ImeEventAck, OnImeEventAck)
#endif
- IPC_MESSAGE_HANDLER(ViewMsg_Snapshot, OnSnapshot)
IPC_MESSAGE_UNHANDLED(handled = false)
IPC_END_MESSAGE_MAP()
return handled;
void RenderWidget::Resize(const gfx::Size& new_size,
const gfx::Size& physical_backing_size,
float overdraw_bottom_height,
+ const gfx::Size& visible_viewport_size,
const gfx::Rect& resizer_rect,
bool is_fullscreen,
ResizeAck resize_ack) {
physical_backing_size_ = physical_backing_size;
overdraw_bottom_height_ = overdraw_bottom_height;
+ visible_viewport_size_ = visible_viewport_size;
resizer_rect_ = resizer_rect;
// NOTE: We may have entered fullscreen mode without changing our size.
is_fullscreen_ = is_fullscreen;
if (size_ != new_size) {
- // TODO(darin): We should not need to reset this here.
- needs_repainting_on_restore_ = false;
-
size_ = new_size;
- paint_aggregator_.ClearPendingUpdate();
-
// When resizing, we want to wait to paint before ACK'ing the resize. This
// ensures that we only resize as fast as we can paint. We only need to
// send an ACK if we are resized to a non-empty rect.
webwidget_->resize(new_size);
-
- if (resizing_mode_selector_->NeverUsesSynchronousResize()) {
- // Resize should have caused an invalidation of the entire view.
- DCHECK(new_size.IsEmpty() || is_accelerated_compositing_active_ ||
- paint_aggregator_.HasPendingUpdate());
- }
} else if (!resizing_mode_selector_->is_synchronous_mode()) {
resize_ack = NO_RESIZE_ACK;
}
+ webwidget()->resizePinchViewport(gfx::Size(
+ visible_viewport_size.width(),
+ visible_viewport_size.height()));
+
if (new_size.IsEmpty() || physical_backing_size.IsEmpty()) {
// For empty size or empty physical_backing_size, there is no next paint
// (along with which to send the ack) until they are set to non-empty.
void RenderWidget::ResizeSynchronously(const gfx::Rect& new_position) {
Resize(new_position.size(), new_position.size(), overdraw_bottom_height_,
- gfx::Rect(), is_fullscreen_, NO_RESIZE_ACK);
+ visible_viewport_size_, gfx::Rect(), is_fullscreen_, NO_RESIZE_ACK);
view_screen_rect_ = new_position;
window_screen_rect_ = new_position;
if (!did_show_)
return;
}
+ bool orientation_changed =
+ screen_info_.orientationAngle != params.screen_info.orientationAngle;
+
screen_info_ = params.screen_info;
SetDeviceScaleFactor(screen_info_.deviceScaleFactor);
Resize(params.new_size, params.physical_backing_size,
- params.overdraw_bottom_height, params.resizer_rect,
- params.is_fullscreen, SEND_RESIZE_ACK);
+ params.overdraw_bottom_height, params.visible_viewport_size,
+ params.resizer_rect, params.is_fullscreen, SEND_RESIZE_ACK);
+
+ if (orientation_changed)
+ OnOrientationChange();
}
void RenderWidget::OnChangeResizeRect(const gfx::Rect& resizer_rect) {
- if (resizer_rect_ != resizer_rect) {
- gfx::Rect view_rect(size_);
-
- gfx::Rect old_damage_rect = gfx::IntersectRects(view_rect, resizer_rect_);
- if (!old_damage_rect.IsEmpty())
- paint_aggregator_.InvalidateRect(old_damage_rect);
-
- gfx::Rect new_damage_rect = gfx::IntersectRects(view_rect, resizer_rect);
- if (!new_damage_rect.IsEmpty())
- paint_aggregator_.InvalidateRect(new_damage_rect);
-
- resizer_rect_ = resizer_rect;
-
- if (webwidget_)
- webwidget_->didChangeWindowResizerRect();
- }
+ if (resizer_rect_ == resizer_rect)
+ return;
+ resizer_rect_ = resizer_rect;
+ if (webwidget_)
+ webwidget_->didChangeWindowResizerRect();
}
void RenderWidget::OnWasHidden() {
TRACE_EVENT0("renderer", "RenderWidget::OnWasHidden");
// Go into a mode where we stop generating paint and scrolling events.
SetHidden(true);
+ FOR_EACH_OBSERVER(RenderFrameImpl, render_frames_,
+ WasHidden());
}
-void RenderWidget::OnWasShown(bool needs_repainting) {
+void RenderWidget::OnWasShown(bool needs_repainting,
+ const ui::LatencyInfo& latency_info) {
TRACE_EVENT0("renderer", "RenderWidget::OnWasShown");
// During shutdown we can just ignore this message.
if (!webwidget_)
// See OnWasHidden
SetHidden(false);
+ FOR_EACH_OBSERVER(RenderFrameImpl, render_frames_,
+ WasShown());
- if (!needs_repainting && !needs_repainting_on_restore_)
+ if (!needs_repainting)
return;
- needs_repainting_on_restore_ = false;
-
- // Tag the next paint as a restore ack, which is picked up by
- // DoDeferredUpdate when it sends out the next PaintRect message.
- set_next_paint_is_restore_ack();
// Generate a full repaint.
- if (!is_accelerated_compositing_active_) {
- didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
- } else {
- if (compositor_)
- compositor_->SetNeedsForcedRedraw();
- scheduleComposite();
+ if (compositor_) {
+ ui::LatencyInfo swap_latency_info(latency_info);
+ scoped_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor(
+ compositor_->CreateLatencyInfoSwapPromiseMonitor(&swap_latency_info));
+ compositor_->SetNeedsForcedRedraw();
}
+ scheduleComposite();
}
void RenderWidget::OnWasSwappedOut() {
pending_window_rect_count_--;
}
-void RenderWidget::OnUpdateRectAck() {
- TRACE_EVENT0("renderer", "RenderWidget::OnUpdateRectAck");
- DCHECK(update_reply_pending_);
- update_reply_pending_ = false;
-
- // If we sent an UpdateRect message with a zero-sized bitmap, then we should
- // have no current paint buffer.
- if (current_paint_buf_) {
- RenderProcess::current()->ReleaseTransportDIB(current_paint_buf_);
- current_paint_buf_ = NULL;
- }
-
- // If swapbuffers is still pending, then defer the update until the
- // swapbuffers occurs.
- if (num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending) {
- TRACE_EVENT0("renderer", "EarlyOut_SwapStillPending");
- return;
- }
-
- // Notify subclasses that software rendering was flushed to the screen.
- if (!is_accelerated_compositing_active_) {
- DidFlushPaint();
- }
-
- // Continue painting if necessary...
- DoDeferredUpdateAndSendInputAck();
-}
-
-bool RenderWidget::SupportsAsynchronousSwapBuffers() {
- // Contexts using the command buffer support asynchronous swapbuffers.
- // See RenderWidget::CreateOutputSurface().
- if (RenderThreadImpl::current()->compositor_message_loop_proxy().get())
- return false;
-
- return true;
-}
-
GURL RenderWidget::GetURLForGraphicsContext3D() {
return GURL();
}
-bool RenderWidget::ForceCompositingModeEnabled() {
- return false;
-}
-
scoped_ptr<cc::OutputSurface> RenderWidget::CreateOutputSurface(bool fallback) {
+ // For widgets that are never visible, we don't start the compositor, so we
+ // never get a request for a cc::OutputSurface.
+ DCHECK(!never_visible_);
#if defined(OS_ANDROID)
if (SynchronousCompositorFactory* factory =
SynchronousCompositorFactory::GetInstance()) {
- return factory->CreateOutputSurface(routing_id());
+ return factory->CreateOutputSurface(routing_id(),
+ frame_swap_message_queue_);
}
#endif
- // Explicitly disable antialiasing for the compositor. As of the time of
- // this writing, the only platform that supported antialiasing for the
- // compositor was Mac OS X, because the on-screen OpenGL context creation
- // code paths on Windows and Linux didn't yet have multisampling support.
- // Mac OS X essentially always behaves as though it's rendering offscreen.
- // Multisampling has a heavy cost especially on devices with relatively low
- // fill rate like most notebooks, and the Mac implementation would need to
- // be optimized to resolve directly into the IOSurface shared between the
- // GPU and browser processes. For these reasons and to avoid platform
- // disparities we explicitly disable antialiasing.
- blink::WebGraphicsContext3D::Attributes attributes;
- attributes.antialias = false;
- attributes.shareResources = true;
- attributes.noAutomaticFlushes = true;
- attributes.depth = false;
- attributes.stencil = false;
-
const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+ bool use_software = fallback;
+ if (command_line.HasSwitch(switches::kDisableGpuCompositing))
+ use_software = true;
+
scoped_refptr<ContextProviderCommandBuffer> context_provider;
- if (!fallback) {
+ if (!use_software) {
context_provider = ContextProviderCommandBuffer::Create(
- CreateGraphicsContext3D(attributes),
- "RenderCompositor");
+ CreateGraphicsContext3D(), "RenderCompositor");
+ if (!context_provider.get()) {
+ // Cause the compositor to wait and try again.
+ return scoped_ptr<cc::OutputSurface>();
+ }
}
uint32 output_surface_id = next_output_surface_id_++;
+ if (command_line.HasSwitch(switches::kEnableDelegatedRenderer)) {
+ DCHECK(IsThreadedCompositingEnabled());
+ return scoped_ptr<cc::OutputSurface>(
+ new DelegatedCompositorOutputSurface(routing_id(),
+ output_surface_id,
+ context_provider,
+ frame_swap_message_queue_));
+ }
if (!context_provider.get()) {
- if (!command_line.HasSwitch(switches::kEnableSoftwareCompositing))
- return scoped_ptr<cc::OutputSurface>();
-
scoped_ptr<cc::SoftwareOutputDevice> software_device(
new CompositorSoftwareOutputDevice());
- return scoped_ptr<cc::OutputSurface>(new CompositorOutputSurface(
- routing_id(),
- output_surface_id,
- NULL,
- software_device.Pass(),
- true));
- }
-
- if (command_line.HasSwitch(switches::kEnableDelegatedRenderer) &&
- !command_line.HasSwitch(switches::kDisableDelegatedRenderer)) {
- DCHECK(is_threaded_compositing_enabled_);
return scoped_ptr<cc::OutputSurface>(
- new DelegatedCompositorOutputSurface(
- routing_id(),
- output_surface_id,
- context_provider,
- scoped_ptr<cc::SoftwareOutputDevice>()));
+ new CompositorOutputSurface(routing_id(),
+ output_surface_id,
+ NULL,
+ software_device.Pass(),
+ frame_swap_message_queue_,
+ true));
}
+
if (command_line.HasSwitch(cc::switches::kCompositeToMailbox)) {
- DCHECK(is_threaded_compositing_enabled_);
+ // Composite-to-mailbox is currently used for layout tests in order to cause
+ // them to draw inside in the renderer to do the readback there. This should
+ // no longer be the case when crbug.com/311404 is fixed.
+ DCHECK(IsThreadedCompositingEnabled() ||
+ RenderThreadImpl::current()->layout_test_mode());
cc::ResourceFormat format = cc::RGBA_8888;
-#if defined(OS_ANDROID)
- if (base::android::SysUtils::IsLowEndDevice())
+ if (base::SysInfo::IsLowEndDevice())
format = cc::RGB_565;
-#endif
return scoped_ptr<cc::OutputSurface>(
- new MailboxOutputSurface(
- routing_id(),
- output_surface_id,
- context_provider,
- scoped_ptr<cc::SoftwareOutputDevice>(),
- format));
+ new MailboxOutputSurface(routing_id(),
+ output_surface_id,
+ context_provider,
+ scoped_ptr<cc::SoftwareOutputDevice>(),
+ frame_swap_message_queue_,
+ format));
}
bool use_swap_compositor_frame_message = false;
return scoped_ptr<cc::OutputSurface>(
- new CompositorOutputSurface(
- routing_id(),
- output_surface_id,
- context_provider,
- scoped_ptr<cc::SoftwareOutputDevice>(),
- use_swap_compositor_frame_message));
+ new CompositorOutputSurface(routing_id(),
+ output_surface_id,
+ context_provider,
+ scoped_ptr<cc::SoftwareOutputDevice>(),
+ frame_swap_message_queue_,
+ use_swap_compositor_frame_message));
}
void RenderWidget::OnSwapBuffersAborted() {
TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersAborted");
- while (!updates_pending_swap_.empty()) {
- ViewHostMsg_UpdateRect* msg = updates_pending_swap_.front();
- updates_pending_swap_.pop_front();
- // msg can be NULL if the swap doesn't correspond to an DoDeferredUpdate
- // compositing pass, hence doesn't require an UpdateRect message.
- if (msg)
- Send(msg);
- }
- num_swapbuffers_complete_pending_ = 0;
- using_asynchronous_swapbuffers_ = false;
// Schedule another frame so the compositor learns about it.
scheduleComposite();
}
void RenderWidget::OnSwapBuffersPosted() {
TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersPosted");
-
- if (using_asynchronous_swapbuffers_) {
- ViewHostMsg_UpdateRect* msg = NULL;
- // pending_update_params_ can be NULL if the swap doesn't correspond to an
- // DoDeferredUpdate compositing pass, hence doesn't require an UpdateRect
- // message.
- if (pending_update_params_) {
- msg = new ViewHostMsg_UpdateRect(routing_id_, *pending_update_params_);
- pending_update_params_.reset();
- }
- updates_pending_swap_.push_back(msg);
- num_swapbuffers_complete_pending_++;
- }
}
void RenderWidget::OnSwapBuffersComplete() {
// Notify subclasses that composited rendering was flushed to the screen.
DidFlushPaint();
-
- // When compositing deactivates, we reset the swapbuffers pending count. The
- // swapbuffers acks may still arrive, however.
- if (num_swapbuffers_complete_pending_ == 0) {
- TRACE_EVENT0("renderer", "EarlyOut_ZeroSwapbuffersPending");
- return;
- }
- DCHECK(!updates_pending_swap_.empty());
- ViewHostMsg_UpdateRect* msg = updates_pending_swap_.front();
- updates_pending_swap_.pop_front();
- // msg can be NULL if the swap doesn't correspond to an DoDeferredUpdate
- // compositing pass, hence doesn't require an UpdateRect message.
- if (msg)
- Send(msg);
- num_swapbuffers_complete_pending_--;
-
- // If update reply is still pending, then defer the update until that reply
- // occurs.
- if (update_reply_pending_) {
- TRACE_EVENT0("renderer", "EarlyOut_UpdateReplyPending");
- return;
- }
-
- // If we are not accelerated rendering, then this is a stale swapbuffers from
- // when we were previously rendering. However, if an invalidation task is not
- // posted, there may be software rendering work pending. In that case, don't
- // early out.
- if (!is_accelerated_compositing_active_ && invalidation_task_posted_) {
- TRACE_EVENT0("renderer", "EarlyOut_AcceleratedCompositingOff");
- return;
- }
-
- // Do not call DoDeferredUpdate unless there's animation work to be done or
- // a real invalidation. This prevents rendering in response to a swapbuffers
- // callback coming back after we've navigated away from the page that
- // generated it.
- if (!animation_update_pending_ && !paint_aggregator_.HasPendingUpdate()) {
- TRACE_EVENT0("renderer", "EarlyOut_NoPendingUpdate");
- return;
- }
-
- // Continue painting if necessary...
- DoDeferredUpdateAndSendInputAck();
}
void RenderWidget::OnHandleInputEvent(const blink::WebInputEvent* input_event,
- ui::LatencyInfo latency_info,
+ const ui::LatencyInfo& latency_info,
bool is_keyboard_shortcut) {
- handling_input_event_ = true;
- if (!input_event) {
- handling_input_event_ = false;
+ base::AutoReset<bool> handling_input_event_resetter(
+ &handling_input_event_, true);
+ if (!input_event)
return;
+ base::AutoReset<WebInputEvent::Type> handling_event_type_resetter(
+ &handling_event_type_, input_event->type);
+#if defined(OS_ANDROID)
+ // On Android, when a key is pressed or sent from the Keyboard using IME,
+ // |AdapterInputConnection| generates input key events to make sure all JS
+ // listeners that monitor KeyUp and KeyDown events receive the proper key
+ // code. Since this input key event comes from IME, we need to set the
+ // IME event guard here to make sure it does not interfere with other IME
+ // events.
+ scoped_ptr<ImeEventGuard> ime_event_guard_maybe;
+ if (WebInputEvent::isKeyboardEventType(input_event->type)) {
+ const WebKeyboardEvent& key_event =
+ *static_cast<const WebKeyboardEvent*>(input_event);
+ // Some keys are special and it's essential that no events get blocked.
+ if (key_event.nativeKeyCode != AKEYCODE_TAB)
+ ime_event_guard_maybe.reset(new ImeEventGuard(this));
}
+#endif
+
+ base::AutoReset<const ui::LatencyInfo*> resetter(¤t_event_latency_info_,
+ &latency_info);
base::TimeTicks start_time;
if (base::TimeTicks::IsHighResNowFastAndReliable())
TRACE_EVENT1("renderer", "RenderWidget::OnHandleInputEvent",
"event", event_name);
TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("blink.HandleInputEvent");
+ TRACE_EVENT_FLOW_STEP0(
+ "input",
+ "LatencyInfo.Flow",
+ TRACE_ID_DONT_MANGLE(latency_info.trace_id),
+ "HanldeInputEventMain");
scoped_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor;
-
+ ui::LatencyInfo swap_latency_info(latency_info);
if (compositor_) {
latency_info_swap_promise_monitor =
- compositor_->CreateLatencyInfoSwapPromiseMonitor(&latency_info).Pass();
- } else {
- latency_info_.push_back(latency_info);
+ compositor_->CreateLatencyInfoSwapPromiseMonitor(&swap_latency_info)
+ .Pass();
}
- base::TimeDelta now = base::TimeDelta::FromInternalValue(
- base::TimeTicks::Now().ToInternalValue());
-
- int64 delta = static_cast<int64>(
- (now.InSecondsF() - input_event->timeStampSeconds) *
- base::Time::kMicrosecondsPerSecond);
- UMA_HISTOGRAM_CUSTOM_COUNTS("Event.AggregatedLatency.Renderer2",
- delta, 1, 10000000, 100);
- base::HistogramBase* counter_for_type =
- base::Histogram::FactoryGet(
- base::StringPrintf("Event.Latency.Renderer2.%s", event_name),
- 1,
- 10000000,
- 100,
- base::HistogramBase::kUmaTargetedHistogramFlag);
- counter_for_type->Add(delta);
+ if (base::TimeTicks::IsHighResNowFastAndReliable()) {
+ // If we don't have a high res timer, these metrics won't be accurate enough
+ // to be worth collecting. Note that this does introduce some sampling bias.
+
+ base::TimeDelta now = base::TimeDelta::FromInternalValue(
+ base::TimeTicks::HighResNow().ToInternalValue());
+
+ int64 delta =
+ static_cast<int64>((now.InSecondsF() - input_event->timeStampSeconds) *
+ base::Time::kMicrosecondsPerSecond);
+
+ UMA_HISTOGRAM_CUSTOM_COUNTS(
+ "Event.AggregatedLatency.Renderer2", delta, 1, 10000000, 100);
+ base::HistogramBase* counter_for_type = base::Histogram::FactoryGet(
+ base::StringPrintf("Event.Latency.Renderer2.%s", event_name),
+ 1,
+ 10000000,
+ 100,
+ base::HistogramBase::kUmaTargetedHistogramFlag);
+ counter_for_type->Add(delta);
+ }
bool prevent_default = false;
if (WebInputEvent::isMouseEventType(input_event->type)) {
prevent_default = WillHandleMouseEvent(mouse_event);
}
- if (WebInputEvent::isKeyboardEventType(input_event->type))
+ if (WebInputEvent::isKeyboardEventType(input_event->type)) {
context_menu_source_type_ = ui::MENU_SOURCE_KEYBOARD;
+#if defined(OS_ANDROID)
+ // The DPAD_CENTER key on Android has a dual semantic: (1) in the general
+ // case it should behave like a select key (i.e. causing a click if a button
+ // is focused). However, if a text field is focused (2), its intended
+ // behavior is to just show the IME and don't propagate the key.
+ // A typical use case is a web form: the DPAD_CENTER should bring up the IME
+ // when clicked on an input text field and cause the form submit if clicked
+ // when the submit button is focused, but not vice-versa.
+ // The UI layer takes care of translating DPAD_CENTER into a RETURN key,
+ // but at this point we have to swallow the event for the scenario (2).
+ const WebKeyboardEvent& key_event =
+ *static_cast<const WebKeyboardEvent*>(input_event);
+ if (key_event.nativeKeyCode == AKEYCODE_DPAD_CENTER &&
+ GetTextInputType() != ui::TEXT_INPUT_TYPE_NONE) {
+ OnShowImeIfNeeded();
+ prevent_default = true;
+ }
+#endif
+ }
if (WebInputEvent::isGestureEventType(input_event->type)) {
const WebGestureEvent& gesture_event =
prevent_default = prevent_default || WillHandleGestureEvent(gesture_event);
}
- if (input_event->type == WebInputEvent::TouchStart)
- handling_touchstart_event_ = true;
-
bool processed = prevent_default;
if (input_event->type != WebInputEvent::Char || !suppress_next_char_events_) {
suppress_next_char_events_ = false;
processed = webwidget_->handleInputEvent(*input_event);
}
- handling_touchstart_event_ = false;
-
// If this RawKeyDown event corresponds to a browser keyboard shortcut and
// it's not processed by webkit, then we need to suppress the upcoming Char
// events.
for (size_t i = 0; i < touch_event.touchesLength; ++i) {
if (touch_event.touches[i].state == WebTouchPoint::StatePressed &&
HasTouchEventHandlersAt(
- blink::WebPoint(touch_event.touches[i].position.x,
- touch_event.touches[i].position.y))) {
+ gfx::ToFlooredPoint(touch_event.touches[i].position))) {
ack_result = INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
break;
}
}
}
+ // Unconsumed touchmove acks should never be throttled as they're required to
+ // dispatch compositor-handled scroll gestures.
bool event_type_can_be_rate_limited =
input_event->type == WebInputEvent::MouseMove ||
input_event->type == WebInputEvent::MouseWheel ||
- input_event->type == WebInputEvent::TouchMove;
+ (input_event->type == WebInputEvent::TouchMove &&
+ ack_result == INPUT_EVENT_ACK_STATE_CONSUMED);
- bool frame_pending = paint_aggregator_.HasPendingUpdate();
- if (is_accelerated_compositing_active_) {
- frame_pending = compositor_ &&
- compositor_->BeginMainFrameRequested();
- }
+ bool frame_pending = compositor_ && compositor_->BeginMainFrameRequested();
// If we don't have a fast and accurate HighResNow, we assume the input
// handlers are heavy and rate limit them.
kInputHandlingTimeThrottlingThresholdMicroseconds;
}
- if (!WebInputEventTraits::IgnoresAckDisposition(input_event->type)) {
+ TRACE_EVENT_SYNTHETIC_DELAY_END("blink.HandleInputEvent");
+
+ // Note that we can't use handling_event_type_ here since it will be overriden
+ // by reentrant calls for events after the paused one.
+ bool no_ack = ignore_ack_for_mouse_move_from_debugger_ &&
+ input_event->type == WebInputEvent::MouseMove;
+ if (!WebInputEventTraits::IgnoresAckDisposition(*input_event) && !no_ack) {
+ InputHostMsg_HandleInputEvent_ACK_Params ack;
+ ack.type = input_event->type;
+ ack.state = ack_result;
+ ack.latency = swap_latency_info;
scoped_ptr<IPC::Message> response(
- new InputHostMsg_HandleInputEvent_ACK(routing_id_,
- input_event->type,
- ack_result,
- latency_info));
+ new InputHostMsg_HandleInputEvent_ACK(routing_id_, ack));
if (rate_limiting_wanted && event_type_can_be_rate_limited &&
frame_pending && !is_hidden_) {
// We want to rate limit the input events in this case, so we'll wait for
Send(response.release());
}
}
+ if (input_event->type == WebInputEvent::MouseMove)
+ ignore_ack_for_mouse_move_from_debugger_ = false;
#if defined(OS_ANDROID)
// Allow the IME to be shown when the focus changes as a consequence
// of a processed touch end event.
if (input_event->type == WebInputEvent::TouchEnd && processed)
- UpdateTextInputState(true, true);
+ UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_NON_IME);
#elif defined(USE_AURA)
// Show the virtual keyboard if enabled and a user gesture triggers a focus
// change.
if (processed && (input_event->type == WebInputEvent::TouchEnd ||
input_event->type == WebInputEvent::MouseUp))
- UpdateTextInputState(true, false);
+ UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_IME);
#endif
- TRACE_EVENT_SYNTHETIC_DELAY_END("blink.HandleInputEvent");
- handling_input_event_ = false;
-
if (!prevent_default) {
if (WebInputEvent::isKeyboardEventType(input_event->type))
DidHandleKeyEvent();
webwidget_->setFocus(false);
}
-void RenderWidget::PaintRect(const gfx::Rect& rect,
- const gfx::Point& canvas_origin,
- skia::PlatformCanvas* canvas) {
- TRACE_EVENT2("renderer", "PaintRect",
- "width", rect.width(), "height", rect.height());
-
- canvas->save();
-
- // Bring the canvas into the coordinate system of the paint rect.
- canvas->translate(static_cast<SkScalar>(-canvas_origin.x()),
- static_cast<SkScalar>(-canvas_origin.y()));
-
- // If there is a custom background, tile it.
- if (!background_.empty()) {
- SkPaint paint;
- skia::RefPtr<SkShader> shader = skia::AdoptRef(
- SkShader::CreateBitmapShader(background_,
- SkShader::kRepeat_TileMode,
- SkShader::kRepeat_TileMode));
- paint.setShader(shader.get());
-
- // Use kSrc_Mode to handle background_ transparency properly.
- paint.setXfermodeMode(SkXfermode::kSrc_Mode);
-
- // Canvas could contain multiple update rects. Clip to given rect so that
- // we don't accidentally clear other update rects.
- canvas->save();
- canvas->scale(device_scale_factor_, device_scale_factor_);
- canvas->clipRect(gfx::RectToSkRect(rect));
- canvas->drawPaint(paint);
- canvas->restore();
- }
-
- // First see if this rect is a plugin that can paint itself faster.
- TransportDIB* optimized_dib = NULL;
- gfx::Rect optimized_copy_rect, optimized_copy_location;
- float dib_scale_factor;
- PepperPluginInstanceImpl* optimized_instance =
- GetBitmapForOptimizedPluginPaint(rect, &optimized_dib,
- &optimized_copy_location,
- &optimized_copy_rect,
- &dib_scale_factor);
- if (optimized_instance) {
-#if defined(ENABLE_PLUGINS)
- // This plugin can be optimize-painted and we can just ask it to paint
- // itself. We don't actually need the TransportDIB in this case.
- //
- // This is an optimization for PPAPI plugins that know they're on top of
- // the page content. If this rect is inside such a plugin, we can save some
- // time and avoid re-rendering the page content which we know will be
- // covered by the plugin later (this time can be significant, especially
- // for a playing movie that is invalidating a lot).
- //
- // In the plugin movie case, hopefully the similar call to
- // GetBitmapForOptimizedPluginPaint in DoDeferredUpdate handles the
- // painting, because that avoids copying the plugin image to a different
- // paint rect. Unfortunately, if anything on the page is animating other
- // than the movie, it break this optimization since the union of the
- // invalid regions will be larger than the plugin.
- //
- // This code optimizes that case, where we can still avoid painting in
- // WebKit and filling the background (which can be slow) and just painting
- // the plugin. Unlike the DoDeferredUpdate case, an extra copy is still
- // required.
- SkAutoCanvasRestore auto_restore(canvas, true);
- canvas->scale(device_scale_factor_, device_scale_factor_);
- optimized_instance->Paint(canvas, optimized_copy_location, rect);
- canvas->restore();
-#endif
- } else {
- // Normal painting case.
- base::TimeTicks start_time;
- if (!is_accelerated_compositing_active_)
- start_time = legacy_software_mode_stats_->StartRecording();
-
- webwidget_->paint(canvas, rect);
-
- if (!is_accelerated_compositing_active_) {
- base::TimeDelta paint_time =
- legacy_software_mode_stats_->EndRecording(start_time);
- int64 painted_pixel_count = rect.width() * rect.height();
- legacy_software_mode_stats_->AddPaint(paint_time, painted_pixel_count);
- }
-
- // Flush to underlying bitmap. TODO(darin): is this needed?
- skia::GetTopDevice(*canvas)->accessBitmap(false);
- }
-
- PaintDebugBorder(rect, canvas);
- canvas->restore();
-}
-
-void RenderWidget::PaintDebugBorder(const gfx::Rect& rect,
- skia::PlatformCanvas* canvas) {
- static bool kPaintBorder =
- CommandLine::ForCurrentProcess()->HasSwitch(switches::kShowPaintRects);
- if (!kPaintBorder)
- return;
-
- // Cycle through these colors to help distinguish new paint rects.
- const SkColor colors[] = {
- SkColorSetARGB(0x3F, 0xFF, 0, 0),
- SkColorSetARGB(0x3F, 0xFF, 0, 0xFF),
- SkColorSetARGB(0x3F, 0, 0, 0xFF),
- };
- static int color_selector = 0;
-
- SkPaint paint;
- paint.setStyle(SkPaint::kStroke_Style);
- paint.setColor(colors[color_selector++ % arraysize(colors)]);
- paint.setStrokeWidth(1);
-
- SkIRect irect;
- irect.set(rect.x(), rect.y(), rect.right() - 1, rect.bottom() - 1);
- canvas->drawIRect(irect, paint);
-}
-
-void RenderWidget::AnimationCallback() {
- TRACE_EVENT0("renderer", "RenderWidget::AnimationCallback");
- if (!animation_update_pending_) {
- TRACE_EVENT0("renderer", "EarlyOut_NoAnimationUpdatePending");
- return;
- }
- if (!animation_floor_time_.is_null() && IsRenderingVSynced()) {
- // Record when we fired (according to base::Time::Now()) relative to when
- // we posted the task to quantify how much the base::Time/base::TimeTicks
- // skew is affecting animations.
- base::TimeDelta animation_callback_delay = base::Time::Now() -
- (animation_floor_time_ - base::TimeDelta::FromMilliseconds(16));
- UMA_HISTOGRAM_CUSTOM_TIMES("Renderer4.AnimationCallbackDelayTime",
- animation_callback_delay,
- base::TimeDelta::FromMilliseconds(0),
- base::TimeDelta::FromMilliseconds(30),
- 25);
- }
- DoDeferredUpdateAndSendInputAck();
-}
-
-void RenderWidget::AnimateIfNeeded() {
- if (!animation_update_pending_)
- return;
-
- // Target 60FPS if vsync is on. Go as fast as we can if vsync is off.
- base::TimeDelta animationInterval = IsRenderingVSynced() ?
- base::TimeDelta::FromMilliseconds(16) : base::TimeDelta();
-
- base::Time now = base::Time::Now();
-
- // animation_floor_time_ is the earliest time that we should animate when
- // using the dead reckoning software scheduler. If we're using swapbuffers
- // complete callbacks to rate limit, we can ignore this floor.
- if (now >= animation_floor_time_ || num_swapbuffers_complete_pending_ > 0) {
- TRACE_EVENT0("renderer", "RenderWidget::AnimateIfNeeded")
- animation_floor_time_ = now + animationInterval;
- // Set a timer to call us back after animationInterval before
- // running animation callbacks so that if a callback requests another
- // we'll be sure to run it at the proper time.
- animation_timer_.Stop();
- animation_timer_.Start(FROM_HERE, animationInterval, this,
- &RenderWidget::AnimationCallback);
- animation_update_pending_ = false;
- if (is_accelerated_compositing_active_ && compositor_) {
- compositor_->UpdateAnimations(base::TimeTicks::Now());
- } else {
- double frame_begin_time =
- (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
- webwidget_->animate(frame_begin_time);
- }
- return;
- }
- TRACE_EVENT0("renderer", "EarlyOut_AnimatedTooRecently");
- if (!animation_timer_.IsRunning()) {
- // This code uses base::Time::Now() to calculate the floor and next fire
- // time because javascript's Date object uses base::Time::Now(). The
- // message loop uses base::TimeTicks, which on windows can have a
- // different granularity than base::Time.
- // The upshot of all this is that this function might be called before
- // base::Time::Now() has advanced past the animation_floor_time_. To
- // avoid exposing this delay to javascript, we keep posting delayed
- // tasks until base::Time::Now() has advanced far enough.
- base::TimeDelta delay = animation_floor_time_ - now;
- animation_timer_.Start(FROM_HERE, delay, this,
- &RenderWidget::AnimationCallback);
- }
-}
-
-bool RenderWidget::IsRenderingVSynced() {
- // TODO(nduca): Forcing a driver to disable vsync (e.g. in a control panel) is
- // not caught by this check. This will lead to artificially low frame rates
- // for people who force vsync off at a driver level and expect Chrome to speed
- // up.
- return !has_disable_gpu_vsync_switch_;
-}
-
-void RenderWidget::InvalidationCallback() {
- TRACE_EVENT0("renderer", "RenderWidget::InvalidationCallback");
- invalidation_task_posted_ = false;
- DoDeferredUpdateAndSendInputAck();
-}
-
void RenderWidget::FlushPendingInputEventAck() {
if (pending_input_event_ack_)
Send(pending_input_event_ack_.release());
total_input_handling_time_this_frame_ = base::TimeDelta();
}
-void RenderWidget::DoDeferredUpdateAndSendInputAck() {
- DoDeferredUpdate();
- FlushPendingInputEventAck();
-}
-
-void RenderWidget::DoDeferredUpdate() {
- TRACE_EVENT0("renderer", "RenderWidget::DoDeferredUpdate");
- TRACE_EVENT_SCOPED_SAMPLING_STATE("Chrome", "Paint");
-
- if (!webwidget_)
- return;
-
- if (!init_complete_) {
- TRACE_EVENT0("renderer", "EarlyOut_InitNotComplete");
- return;
- }
- if (update_reply_pending_) {
- TRACE_EVENT0("renderer", "EarlyOut_UpdateReplyPending");
- return;
- }
- if (is_accelerated_compositing_active_ &&
- num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending) {
- TRACE_EVENT0("renderer", "EarlyOut_MaxSwapBuffersPending");
- return;
- }
-
- // Suppress updating when we are hidden.
- if (is_hidden_ || size_.IsEmpty() || is_swapped_out_) {
- paint_aggregator_.ClearPendingUpdate();
- needs_repainting_on_restore_ = true;
- TRACE_EVENT0("renderer", "EarlyOut_NotVisible");
- return;
- }
-
- // Tracking of frame rate jitter
- base::TimeTicks frame_begin_ticks = gfx::FrameTime::Now();
- InstrumentWillBeginFrame(0);
- AnimateIfNeeded();
-
- // Layout may generate more invalidation. It may also enable the
- // GPU acceleration, so make sure to run layout before we send the
- // GpuRenderingActivated message.
- webwidget_->layout();
-
- // Check for whether we need to track swap buffers. We need to do that after
- // layout() because it may have switched us to accelerated compositing.
- if (is_accelerated_compositing_active_)
- using_asynchronous_swapbuffers_ = SupportsAsynchronousSwapBuffers();
-
- // The following two can result in further layout and possibly
- // enable GPU acceleration so they need to be called before any painting
- // is done.
- UpdateTextInputType();
- UpdateSelectionBounds();
-
- // Suppress painting if nothing is dirty. This has to be done after updating
- // animations running layout as these may generate further invalidations.
- if (!paint_aggregator_.HasPendingUpdate()) {
- TRACE_EVENT0("renderer", "EarlyOut_NoPendingUpdate");
- InstrumentDidCancelFrame();
- return;
- }
-
- if (!is_accelerated_compositing_active_ &&
- !is_threaded_compositing_enabled_ &&
- (ForceCompositingModeEnabled() ||
- was_accelerated_compositing_ever_active_)) {
- webwidget_->enterForceCompositingMode(true);
- }
-
- if (!last_do_deferred_update_time_.is_null()) {
- base::TimeDelta delay = frame_begin_ticks - last_do_deferred_update_time_;
- if (is_accelerated_compositing_active_) {
- UMA_HISTOGRAM_CUSTOM_TIMES("Renderer4.AccelDoDeferredUpdateDelay",
- delay,
- base::TimeDelta::FromMilliseconds(1),
- base::TimeDelta::FromMilliseconds(120),
- 60);
- } else {
- UMA_HISTOGRAM_CUSTOM_TIMES("Renderer4.SoftwareDoDeferredUpdateDelay",
- delay,
- base::TimeDelta::FromMilliseconds(1),
- base::TimeDelta::FromMilliseconds(120),
- 60);
- }
-
- // Calculate filtered time per frame:
- float frame_time_elapsed = static_cast<float>(delay.InSecondsF());
- filtered_time_per_frame_ =
- 0.9f * filtered_time_per_frame_ + 0.1f * frame_time_elapsed;
- }
- last_do_deferred_update_time_ = frame_begin_ticks;
-
- if (!is_accelerated_compositing_active_) {
- legacy_software_mode_stats_->IncrementFrameCount(1, true);
- cc::BenchmarkInstrumentation::IssueMainThreadRenderingStatsEvent(
- legacy_software_mode_stats_->main_thread_rendering_stats());
- legacy_software_mode_stats_->AccumulateAndClearMainThreadStats();
- }
-
- // OK, save the pending update to a local since painting may cause more
- // invalidation. Some WebCore rendering objects only layout when painted.
- PaintAggregator::PendingUpdate update;
- paint_aggregator_.PopPendingUpdate(&update);
-
- gfx::Rect scroll_damage = update.GetScrollDamage();
- gfx::Rect bounds = gfx::UnionRects(update.GetPaintBounds(), scroll_damage);
-
- // A plugin may be able to do an optimized paint. First check this, in which
- // case we can skip all of the bitmap generation and regular paint code.
- // This optimization allows PPAPI plugins that declare themselves on top of
- // the page (like a traditional windowed plugin) to be able to animate (think
- // movie playing) without repeatedly re-painting the page underneath, or
- // copying the plugin backing store (since we can send the plugin's backing
- // store directly to the browser).
- //
- // This optimization only works when the entire invalid region is contained
- // within the plugin. There is a related optimization in PaintRect for the
- // case where there may be multiple invalid regions.
- TransportDIB* dib = NULL;
- gfx::Rect optimized_copy_rect, optimized_copy_location;
- float dib_scale_factor = 1;
- DCHECK(!pending_update_params_.get());
- pending_update_params_.reset(new ViewHostMsg_UpdateRect_Params);
- pending_update_params_->scroll_delta = update.scroll_delta;
- pending_update_params_->scroll_rect = update.scroll_rect;
- pending_update_params_->view_size = size_;
- pending_update_params_->plugin_window_moves.swap(plugin_window_moves_);
- pending_update_params_->flags = next_paint_flags_;
- pending_update_params_->scroll_offset = GetScrollOffset();
- pending_update_params_->needs_ack = true;
- pending_update_params_->scale_factor = device_scale_factor_;
- next_paint_flags_ = 0;
- need_update_rect_for_auto_resize_ = false;
-
- if (!is_accelerated_compositing_active_)
- pending_update_params_->latency_info.swap(latency_info_);
-
- latency_info_.clear();
-
- if (update.scroll_rect.IsEmpty() &&
- !is_accelerated_compositing_active_ &&
- GetBitmapForOptimizedPluginPaint(bounds, &dib, &optimized_copy_location,
- &optimized_copy_rect,
- &dib_scale_factor)) {
- // Only update the part of the plugin that actually changed.
- optimized_copy_rect.Intersect(bounds);
- pending_update_params_->bitmap = dib->id();
- pending_update_params_->bitmap_rect = optimized_copy_location;
- pending_update_params_->copy_rects.push_back(optimized_copy_rect);
- pending_update_params_->scale_factor = dib_scale_factor;
- } else if (!is_accelerated_compositing_active_) {
- // Compute a buffer for painting and cache it.
-
- bool fractional_scale = device_scale_factor_ -
- static_cast<int>(device_scale_factor_) != 0;
- if (fractional_scale) {
- // Damage might not be DIP aligned. Inflate damage to compensate.
- bounds.Inset(-1, -1);
- bounds.Intersect(gfx::Rect(size_));
- }
-
- gfx::Rect pixel_bounds = gfx::ToEnclosingRect(
- gfx::ScaleRect(bounds, device_scale_factor_));
-
- scoped_ptr<skia::PlatformCanvas> canvas(
- RenderProcess::current()->GetDrawingCanvas(¤t_paint_buf_,
- pixel_bounds));
- if (!canvas) {
- NOTREACHED();
- return;
- }
-
- // We may get back a smaller canvas than we asked for.
- // TODO(darin): This seems like it could cause painting problems!
- DCHECK_EQ(pixel_bounds.width(), canvas->getDevice()->width());
- DCHECK_EQ(pixel_bounds.height(), canvas->getDevice()->height());
- pixel_bounds.set_width(canvas->getDevice()->width());
- pixel_bounds.set_height(canvas->getDevice()->height());
- bounds.set_width(pixel_bounds.width() / device_scale_factor_);
- bounds.set_height(pixel_bounds.height() / device_scale_factor_);
-
- HISTOGRAM_COUNTS_100("MPArch.RW_PaintRectCount", update.paint_rects.size());
-
- pending_update_params_->bitmap = current_paint_buf_->id();
- pending_update_params_->bitmap_rect = bounds;
-
- std::vector<gfx::Rect>& copy_rects = pending_update_params_->copy_rects;
- // The scroll damage is just another rectangle to paint and copy.
- copy_rects.swap(update.paint_rects);
- if (!scroll_damage.IsEmpty())
- copy_rects.push_back(scroll_damage);
-
- for (size_t i = 0; i < copy_rects.size(); ++i) {
- gfx::Rect rect = copy_rects[i];
- if (fractional_scale) {
- // Damage might not be DPI aligned. Inflate rect to compensate.
- rect.Inset(-1, -1);
- }
- PaintRect(rect, pixel_bounds.origin(), canvas.get());
- }
-
- // Software FPS tick for performance tests. The accelerated path traces the
- // frame events in didCommitAndDrawCompositorFrame. See
- // tab_capture_performancetest.cc.
- // NOTE: Tests may break if this event is renamed or moved.
- UNSHIPPED_TRACE_EVENT_INSTANT0("test_fps", "TestFrameTickSW",
- TRACE_EVENT_SCOPE_THREAD);
- } else { // Accelerated compositing path
- // Begin painting.
- // If painting is done via the gpu process then we don't set any damage
- // rects to save the browser process from doing unecessary work.
- pending_update_params_->bitmap_rect = bounds;
- pending_update_params_->scroll_rect = gfx::Rect();
- // We don't need an ack, because we're not sharing a DIB with the browser.
- // If it needs to (e.g. composited UI), the GPU process does its own ACK
- // with the browser for the GPU surface.
- pending_update_params_->needs_ack = false;
- Composite(frame_begin_ticks);
- }
-
- // If we're holding a pending input event ACK, send the ACK before sending the
- // UpdateReply message so we can receive another input event before the
- // UpdateRect_ACK on platforms where the UpdateRect_ACK is sent from within
- // the UpdateRect IPC message handler.
- FlushPendingInputEventAck();
-
- // If Composite() called SwapBuffers, pending_update_params_ will be reset (in
- // OnSwapBuffersPosted), meaning a message has been added to the
- // updates_pending_swap_ queue, that will be sent later. Otherwise, we send
- // the message now.
- if (pending_update_params_) {
- // sending an ack to browser process that the paint is complete...
- update_reply_pending_ = pending_update_params_->needs_ack;
- Send(new ViewHostMsg_UpdateRect(routing_id_, *pending_update_params_));
- pending_update_params_.reset();
- }
-
- // If we're software rendering then we're done initiating the paint.
- if (!is_accelerated_compositing_active_)
- DidInitiatePaint();
-}
-
-void RenderWidget::Composite(base::TimeTicks frame_begin_time) {
- DCHECK(is_accelerated_compositing_active_);
- if (compositor_) // TODO(jamesr): Figure out how this can be null.
- compositor_->Composite(frame_begin_time);
-}
-
///////////////////////////////////////////////////////////////////////////////
// WebWidgetClient
-void RenderWidget::didInvalidateRect(const WebRect& rect) {
- // The invalidated rect might be outside the bounds of the view.
- gfx::Rect view_rect(size_);
- gfx::Rect damaged_rect = gfx::IntersectRects(view_rect, rect);
- if (damaged_rect.IsEmpty())
- return;
-
- paint_aggregator_.InvalidateRect(damaged_rect);
-
- // We may not need to schedule another call to DoDeferredUpdate.
- if (invalidation_task_posted_)
- return;
- if (!paint_aggregator_.HasPendingUpdate())
- return;
- if (update_reply_pending_ ||
- num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending)
- return;
-
- // When GPU rendering, combine pending animations and invalidations into
- // a single update.
- if (is_accelerated_compositing_active_ &&
- animation_update_pending_ &&
- animation_timer_.IsRunning())
- return;
-
- // Perform updating asynchronously. This serves two purposes:
- // 1) Ensures that we call WebView::Paint without a bunch of other junk
- // on the call stack.
- // 2) Allows us to collect more damage rects before painting to help coalesce
- // the work that we will need to do.
- invalidation_task_posted_ = true;
- base::MessageLoop::current()->PostTask(
- FROM_HERE, base::Bind(&RenderWidget::InvalidationCallback, this));
-}
-
-void RenderWidget::didScrollRect(int dx, int dy,
- const WebRect& clip_rect) {
- // Drop scrolls on the floor when we are in compositing mode.
- // TODO(nduca): stop WebViewImpl from sending scrolls in the first place.
- if (is_accelerated_compositing_active_)
- return;
-
- // The scrolled rect might be outside the bounds of the view.
- gfx::Rect view_rect(size_);
- gfx::Rect damaged_rect = gfx::IntersectRects(view_rect, clip_rect);
- if (damaged_rect.IsEmpty())
- return;
-
- paint_aggregator_.ScrollRect(gfx::Vector2d(dx, dy), damaged_rect);
-
- // We may not need to schedule another call to DoDeferredUpdate.
- if (invalidation_task_posted_)
- return;
- if (!paint_aggregator_.HasPendingUpdate())
- return;
- if (update_reply_pending_ ||
- num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending)
- return;
-
- // When GPU rendering, combine pending animations and invalidations into
- // a single update.
- if (is_accelerated_compositing_active_ &&
- animation_update_pending_ &&
- animation_timer_.IsRunning())
- return;
-
- // Perform updating asynchronously. This serves two purposes:
- // 1) Ensures that we call WebView::Paint without a bunch of other junk
- // on the call stack.
- // 2) Allows us to collect more damage rects before painting to help coalesce
- // the work that we will need to do.
- invalidation_task_posted_ = true;
- base::MessageLoop::current()->PostTask(
- FROM_HERE, base::Bind(&RenderWidget::InvalidationCallback, this));
-}
-
void RenderWidget::didAutoResize(const WebSize& new_size) {
if (size_.width() != new_size.width || size_.height() != new_size.height) {
size_ = new_size;
- // If we don't clear PaintAggregator after changing autoResize state, then
- // we might end up in a situation where bitmap_rect is larger than the
- // view_size. By clearing PaintAggregator, we ensure that we don't end up
- // with invalid damage rects.
- paint_aggregator_.ClearPendingUpdate();
-
if (resizing_mode_selector_->is_synchronous_mode()) {
WebRect new_pos(rootWindowRect().x,
rootWindowRect().y,
compositor_->setViewportSize(size_, physical_backing_size_);
}
-void RenderWidget::didActivateCompositor(int input_handler_identifier) {
- TRACE_EVENT0("gpu", "RenderWidget::didActivateCompositor");
-
-#if !defined(OS_MACOSX)
- if (!is_accelerated_compositing_active_) {
- // When not in accelerated compositing mode, in certain cases (e.g. waiting
- // for a resize or if no backing store) the RenderWidgetHost is blocking the
- // browser's UI thread for some time, waiting for an UpdateRect. If we are
- // going to switch to accelerated compositing, the GPU process may need
- // round-trips to the browser's UI thread before finishing the frame,
- // causing deadlocks if we delay the UpdateRect until we receive the
- // OnSwapBuffersComplete. So send a dummy message that will unblock the
- // browser's UI thread. This is not necessary on Mac, because SwapBuffers
- // now unblocks GetBackingStore on Mac.
- Send(new ViewHostMsg_UpdateIsDelayed(routing_id_));
- }
-#endif
-
- is_accelerated_compositing_active_ = true;
- Send(new ViewHostMsg_DidActivateAcceleratedCompositing(
- routing_id_, is_accelerated_compositing_active_));
-
- if (!was_accelerated_compositing_ever_active_) {
- was_accelerated_compositing_ever_active_ = true;
- webwidget_->enterForceCompositingMode(true);
- }
-}
-
-void RenderWidget::didDeactivateCompositor() {
- TRACE_EVENT0("gpu", "RenderWidget::didDeactivateCompositor");
-
- is_accelerated_compositing_active_ = false;
- Send(new ViewHostMsg_DidActivateAcceleratedCompositing(
- routing_id_, is_accelerated_compositing_active_));
-
- if (using_asynchronous_swapbuffers_)
- using_asynchronous_swapbuffers_ = false;
-
- // In single-threaded mode, we exit force compositing mode and re-enter in
- // DoDeferredUpdate() if appropriate. In threaded compositing mode,
- // DoDeferredUpdate() is bypassed and WebKit is responsible for exiting and
- // entering force compositing mode at the appropriate times.
- if (!is_threaded_compositing_enabled_)
- webwidget_->enterForceCompositingMode(false);
-}
-
void RenderWidget::initializeLayerTreeView() {
- compositor_ = RenderWidgetCompositor::Create(
- this, is_threaded_compositing_enabled_);
- if (!compositor_)
- return;
-
+ compositor_ =
+ RenderWidgetCompositor::Create(this, IsThreadedCompositingEnabled());
compositor_->setViewportSize(size_, physical_backing_size_);
if (init_complete_)
- compositor_->setSurfaceReady();
+ StartCompositor();
}
blink::WebLayerTreeView* RenderWidget::layerTreeView() {
// The following two can result in further layout and possibly
// enable GPU acceleration so they need to be called before any painting
// is done.
- UpdateTextInputType();
-#if defined(OS_ANDROID)
- UpdateTextInputState(false, true);
-#endif
+ UpdateTextInputState(NO_SHOW_IME, FROM_NON_IME);
UpdateSelectionBounds();
}
}
void RenderWidget::DidCommitCompositorFrame() {
- FOR_EACH_OBSERVER(RenderFrameImpl, swapped_out_frames_,
+ FOR_EACH_OBSERVER(RenderFrameProxy, render_frame_proxies_,
+ DidCommitCompositorFrame());
+#if defined(VIDEO_HOLE)
+ FOR_EACH_OBSERVER(RenderFrameImpl, video_hole_frames_,
DidCommitCompositorFrame());
+#endif // defined(VIDEO_HOLE)
+}
+
+// static
+scoped_ptr<cc::SwapPromise> RenderWidget::QueueMessageImpl(
+ IPC::Message* msg,
+ MessageDeliveryPolicy policy,
+ FrameSwapMessageQueue* frame_swap_message_queue,
+ scoped_refptr<IPC::SyncMessageFilter> sync_message_filter,
+ bool commit_requested,
+ int source_frame_number) {
+ if (policy == MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE &&
+ // No need for lock: this gets changed only on this thread.
+ !commit_requested &&
+ // No need for lock: Messages are only enqueued from this thread, if we
+ // don't have any now, no other thread will add any.
+ frame_swap_message_queue->Empty()) {
+ sync_message_filter->Send(msg);
+ return scoped_ptr<cc::SwapPromise>();
+ }
+
+ bool first_message_for_frame = false;
+ frame_swap_message_queue->QueueMessageForFrame(policy,
+ source_frame_number,
+ make_scoped_ptr(msg),
+ &first_message_for_frame);
+ if (first_message_for_frame) {
+ scoped_ptr<cc::SwapPromise> promise(new QueueMessageSwapPromise(
+ sync_message_filter, frame_swap_message_queue, source_frame_number));
+ return promise.PassAs<cc::SwapPromise>();
+ }
+ return scoped_ptr<cc::SwapPromise>();
+}
+
+void RenderWidget::QueueMessage(IPC::Message* msg,
+ MessageDeliveryPolicy policy) {
+ // RenderThreadImpl::current() is NULL in some tests.
+ if (!compositor_ || !RenderThreadImpl::current()) {
+ Send(msg);
+ return;
+ }
+
+ scoped_ptr<cc::SwapPromise> swap_promise =
+ QueueMessageImpl(msg,
+ policy,
+ frame_swap_message_queue_,
+ RenderThreadImpl::current()->sync_message_filter(),
+ compositor_->commitRequested(),
+ compositor_->GetSourceFrameNumber());
+
+ if (swap_promise) {
+ compositor_->QueueSwapPromise(swap_promise.Pass());
+ compositor_->SetNeedsCommit();
+ }
}
void RenderWidget::didCommitAndDrawCompositorFrame() {
+ // NOTE: Tests may break if this event is renamed or moved. See
+ // tab_capture_performancetest.cc.
TRACE_EVENT0("gpu", "RenderWidget::didCommitAndDrawCompositorFrame");
- // Accelerated FPS tick for performance tests. See
- // tab_capture_performancetest.cc. NOTE: Tests may break if this event is
- // renamed or moved.
- UNSHIPPED_TRACE_EVENT_INSTANT0("test_fps", "TestFrameTickGPU",
- TRACE_EVENT_SCOPE_THREAD);
// Notify subclasses that we initiated the paint operation.
DidInitiatePaint();
}
// Notify subclasses threaded composited rendering was flushed to the screen.
DidFlushPaint();
- if (update_reply_pending_)
- return;
-
if (!next_paint_flags_ &&
!need_update_rect_for_auto_resize_ &&
!plugin_window_moves_.size()) {
params.plugin_window_moves.swap(plugin_window_moves_);
params.flags = next_paint_flags_;
params.scroll_offset = GetScrollOffset();
- params.needs_ack = false;
params.scale_factor = device_scale_factor_;
Send(new ViewHostMsg_UpdateRect(routing_id_, params));
}
void RenderWidget::scheduleComposite() {
- if (RenderThreadImpl::current()->compositor_message_loop_proxy().get() &&
+ RenderThreadImpl* render_thread = RenderThreadImpl::current();
+ // render_thread may be NULL in tests.
+ if (render_thread && render_thread->compositor_message_loop_proxy().get() &&
compositor_) {
- compositor_->setNeedsAnimate();
- } else {
- // TODO(nduca): replace with something a little less hacky. The reason this
- // hack is still used is because the Invalidate-DoDeferredUpdate loop
- // contains a lot of host-renderer synchronization logic that is still
- // important for the accelerated compositing case. The option of simply
- // duplicating all that code is less desirable than "faking out" the
- // invalidation path using a magical damage rect.
- didInvalidateRect(WebRect(0, 0, 1, 1));
- }
-}
-
-void RenderWidget::scheduleAnimation() {
- if (animation_update_pending_)
- return;
-
- TRACE_EVENT0("gpu", "RenderWidget::scheduleAnimation");
- animation_update_pending_ = true;
- if (!animation_timer_.IsRunning()) {
- animation_timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(0), this,
- &RenderWidget::AnimationCallback);
+ compositor_->setNeedsAnimate();
}
}
}
void RenderWidget::Close() {
+ screen_metrics_emulator_.reset();
if (webwidget_) {
webwidget_->willCloseLayerTreeView();
compositor_.reset();
// If we failed to set the composition text, then we need to let the browser
// process to cancel the input method's ongoing composition session, to make
// sure we are in a consistent state.
- Send(new ViewHostMsg_ImeCancelComposition(routing_id()));
+ Send(new InputHostMsg_ImeCancelComposition(routing_id()));
}
-#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
+#if defined(OS_MACOSX) || defined(USE_AURA)
UpdateCompositionInfo(true);
#endif
}
else
webwidget_->confirmComposition(WebWidget::DoNotKeepSelection);
handling_input_event_ = false;
-#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
+#if defined(OS_MACOSX) || defined(USE_AURA)
UpdateCompositionInfo(true);
#endif
}
-void RenderWidget::OnSnapshot(const gfx::Rect& src_subrect) {
- SkBitmap snapshot;
-
- if (OnSnapshotHelper(src_subrect, &snapshot)) {
- Send(new ViewHostMsg_Snapshot(routing_id(), true, snapshot));
- } else {
- Send(new ViewHostMsg_Snapshot(routing_id(), false, SkBitmap()));
- }
-}
-
-bool RenderWidget::OnSnapshotHelper(const gfx::Rect& src_subrect,
- SkBitmap* snapshot) {
- base::TimeTicks beginning_time = base::TimeTicks::Now();
-
- if (!webwidget_ || src_subrect.IsEmpty())
- return false;
-
- gfx::Rect viewport_size = gfx::IntersectRects(
- src_subrect, gfx::Rect(physical_backing_size_));
-
- skia::RefPtr<SkCanvas> canvas = skia::AdoptRef(
- skia::CreatePlatformCanvas(viewport_size.width(),
- viewport_size.height(),
- true,
- NULL,
- skia::RETURN_NULL_ON_FAILURE));
- if (!canvas)
- return false;
-
- canvas->save();
- webwidget_->layout();
-
- PaintRect(viewport_size, viewport_size.origin(), canvas.get());
- canvas->restore();
-
- const SkBitmap& bitmap = skia::GetTopDevice(*canvas)->accessBitmap(false);
- if (!bitmap.copyTo(snapshot, SkBitmap::kARGB_8888_Config))
- return false;
-
- UMA_HISTOGRAM_TIMES("Renderer4.Snapshot",
- base::TimeTicks::Now() - beginning_time);
- return true;
-}
-
void RenderWidget::OnRepaint(gfx::Size size_to_paint) {
// During shutdown we can just ignore this message.
if (!webwidget_)
}
set_next_paint_is_repaint_ack();
- if (is_accelerated_compositing_active_ && compositor_) {
+ if (compositor_)
compositor_->SetNeedsRedrawRect(gfx::Rect(size_to_paint));
- } else {
- gfx::Rect repaint_rect(size_to_paint.width(), size_to_paint.height());
- didInvalidateRect(repaint_rect);
- }
}
void RenderWidget::OnSyntheticGestureCompleted() {
Send(new ViewHostMsg_UpdateScreenRects_ACK(routing_id()));
}
-#if defined(OS_ANDROID)
+void RenderWidget::showImeIfNeeded() {
+ OnShowImeIfNeeded();
+}
+
void RenderWidget::OnShowImeIfNeeded() {
- UpdateTextInputState(true, true);
+#if defined(OS_ANDROID) || defined(USE_AURA)
+ UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_NON_IME);
+#endif
}
+#if defined(OS_ANDROID)
void RenderWidget::IncrementOutstandingImeEventAcks() {
++outstanding_ime_acks_;
}
#endif
}
+bool RenderWidget::SendAckForMouseMoveFromDebugger() {
+ if (handling_event_type_ == WebInputEvent::MouseMove) {
+ // If we pause multiple times during a single mouse move event, we should
+ // only send ACK once.
+ if (!ignore_ack_for_mouse_move_from_debugger_) {
+ InputHostMsg_HandleInputEvent_ACK_Params ack;
+ ack.type = handling_event_type_;
+ ack.state = INPUT_EVENT_ACK_STATE_CONSUMED;
+ Send(new InputHostMsg_HandleInputEvent_ACK(routing_id_, ack));
+ }
+ return true;
+ }
+ return false;
+}
+
+void RenderWidget::IgnoreAckForMouseMoveFromDebugger() {
+ ignore_ack_for_mouse_move_from_debugger_ = true;
+}
+
void RenderWidget::SetDeviceScaleFactor(float device_scale_factor) {
if (device_scale_factor_ == device_scale_factor)
return;
device_scale_factor_ = device_scale_factor;
+ scheduleComposite();
+}
- if (!is_accelerated_compositing_active_) {
- didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
- } else {
- scheduleComposite();
- }
+bool RenderWidget::SetDeviceColorProfile(
+ const std::vector<char>& color_profile) {
+ if (device_color_profile_ == color_profile)
+ return false;
+
+ device_color_profile_ = color_profile;
+ return true;
}
-PepperPluginInstanceImpl* RenderWidget::GetBitmapForOptimizedPluginPaint(
- const gfx::Rect& paint_bounds,
- TransportDIB** dib,
- gfx::Rect* location,
- gfx::Rect* clip,
- float* scale_factor) {
- // Bare RenderWidgets don't support optimized plugin painting.
- return NULL;
+void RenderWidget::OnOrientationChange() {
}
gfx::Vector2d RenderWidget::GetScrollOffset() {
}
}
-void RenderWidget::SetBackground(const SkBitmap& background) {
- background_ = background;
-
- // Generate a full repaint.
- didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
-}
-
bool RenderWidget::next_paint_is_resize_ack() const {
return ViewHostMsg_UpdateRect_Flags::is_resize_ack(next_paint_flags_);
}
-bool RenderWidget::next_paint_is_restore_ack() const {
- return ViewHostMsg_UpdateRect_Flags::is_restore_ack(next_paint_flags_);
-}
-
void RenderWidget::set_next_paint_is_resize_ack() {
next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_RESIZE_ACK;
}
-void RenderWidget::set_next_paint_is_restore_ack() {
- next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_RESTORE_ACK;
-}
-
void RenderWidget::set_next_paint_is_repaint_ack() {
next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_REPAINT_ACK;
}
// ime event.
UpdateSelectionBounds();
#if defined(OS_ANDROID)
- UpdateTextInputState(false, false);
+ UpdateTextInputState(NO_SHOW_IME, FROM_IME);
#endif
}
-void RenderWidget::UpdateTextInputType() {
- // On Windows, not only an IME but also an on-screen keyboard relies on the
- // latest TextInputType to optimize its layout and functionality. Thus
- // |input_method_is_active_| is no longer an appropriate condition to suppress
- // TextInputTypeChanged IPC on Windows.
- // TODO(yukawa, yoichio): Consider to stop checking |input_method_is_active_|
- // on other platforms as well as Windows if the overhead is acceptable.
-#if !defined(OS_WIN)
- if (!input_method_is_active_)
- return;
-#endif
-
- ui::TextInputType new_type = GetTextInputType();
- if (IsDateTimeInput(new_type))
- return; // Not considered as a text input field in WebKit/Chromium.
-
- bool new_can_compose_inline = CanComposeInline();
-
- blink::WebTextInputInfo new_info;
- if (webwidget_)
- new_info = webwidget_->textInputInfo();
- const ui::TextInputMode new_mode = ConvertInputMode(new_info.inputMode);
-
- if (text_input_type_ != new_type
- || can_compose_inline_ != new_can_compose_inline
- || text_input_mode_ != new_mode) {
- Send(new ViewHostMsg_TextInputTypeChanged(routing_id(),
- new_type,
- new_mode,
- new_can_compose_inline));
- text_input_type_ = new_type;
- can_compose_inline_ = new_can_compose_inline;
- text_input_mode_ = new_mode;
- }
-}
-
-#if defined(OS_ANDROID) || defined(USE_AURA)
-void RenderWidget::UpdateTextInputState(bool show_ime_if_needed,
- bool send_ime_ack) {
+void RenderWidget::UpdateTextInputState(ShowIme show_ime,
+ ChangeSource change_source) {
if (handling_ime_event_)
return;
- if (!show_ime_if_needed && !input_method_is_active_)
+ if (show_ime == NO_SHOW_IME && !input_method_is_active_)
return;
ui::TextInputType new_type = GetTextInputType();
if (IsDateTimeInput(new_type))
blink::WebTextInputInfo new_info;
if (webwidget_)
new_info = webwidget_->textInputInfo();
+ const ui::TextInputMode new_mode = ConvertInputMode(new_info.inputMode);
bool new_can_compose_inline = CanComposeInline();
// Only sends text input params if they are changed or if the ime should be
// shown.
- if (show_ime_if_needed || (text_input_type_ != new_type
- || text_input_info_ != new_info
- || can_compose_inline_ != new_can_compose_inline)) {
- ViewHostMsg_TextInputState_Params p;
-#if defined(USE_AURA)
- p.require_ack = false;
+ if (show_ime == SHOW_IME_IF_NEEDED ||
+ (text_input_type_ != new_type ||
+ text_input_mode_ != new_mode ||
+ text_input_info_ != new_info ||
+ can_compose_inline_ != new_can_compose_inline)
+#if defined(OS_ANDROID)
+ || text_field_is_dirty_
#endif
+ ) {
+ ViewHostMsg_TextInputState_Params p;
p.type = new_type;
+ p.flags = new_info.flags;
+ p.mode = new_mode;
p.value = new_info.value.utf8();
p.selection_start = new_info.selectionStart;
p.selection_end = new_info.selectionEnd;
p.composition_start = new_info.compositionStart;
p.composition_end = new_info.compositionEnd;
p.can_compose_inline = new_can_compose_inline;
- p.show_ime_if_needed = show_ime_if_needed;
+ p.show_ime_if_needed = (show_ime == SHOW_IME_IF_NEEDED);
+#if defined(USE_AURA)
+ p.is_non_ime_change = true;
+#endif
#if defined(OS_ANDROID)
- p.require_ack = send_ime_ack;
- if (p.require_ack)
+ p.is_non_ime_change = (change_source == FROM_NON_IME) ||
+ text_field_is_dirty_;
+ if (p.is_non_ime_change)
IncrementOutstandingImeEventAcks();
+ text_field_is_dirty_ = false;
#endif
Send(new ViewHostMsg_TextInputStateChanged(routing_id(), p));
text_input_info_ = new_info;
text_input_type_ = new_type;
+ text_input_mode_ = new_mode;
can_compose_inline_ = new_can_compose_inline;
}
}
-#endif
void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) {
WebRect focus_webrect;
params.is_anchor_first = webwidget_->isSelectionAnchorFirst();
Send(new ViewHostMsg_SelectionBoundsChanged(routing_id_, params));
}
-#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
+#if defined(OS_MACOSX) || defined(USE_AURA)
UpdateCompositionInfo(false);
#endif
}
return ui::TEXT_INPUT_TYPE_NONE;
}
-#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
+#if defined(OS_MACOSX) || defined(USE_AURA)
void RenderWidget::UpdateCompositionInfo(bool should_update_range) {
gfx::Range range = gfx::Range();
if (should_update_range) {
return;
composition_character_bounds_ = character_bounds;
composition_range_ = range;
- Send(new ViewHostMsg_ImeCompositionRangeChanged(
+ Send(new InputHostMsg_ImeCompositionRangeChanged(
routing_id(), composition_range_, composition_character_bounds_));
}
}
#endif
+#if defined(OS_ANDROID)
+void RenderWidget::DidChangeBodyBackgroundColor(SkColor bg_color) {
+ // If not initialized, default to white. Note that 0 is different from black
+ // as black still has alpha 0xFF.
+ if (!bg_color)
+ bg_color = SK_ColorWHITE;
+
+ if (bg_color != body_background_color_) {
+ body_background_color_ = bg_color;
+ Send(new ViewHostMsg_DidChangeBodyBackgroundColor(routing_id(), bg_color));
+ }
+}
+#endif
+
bool RenderWidget::CanComposeInline() {
return true;
}
// If a composition text exists, then we need to let the browser process
// to cancel the input method's ongoing composition session.
if (webwidget_->confirmComposition())
- Send(new ViewHostMsg_ImeCancelComposition(routing_id()));
+ Send(new InputHostMsg_ImeCancelComposition(routing_id()));
}
-#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
+#if defined(OS_MACOSX) || defined(USE_AURA)
UpdateCompositionInfo(true);
#endif
}
return;
if (event.type == WebInputEvent::GestureTap ||
event.type == WebInputEvent::GestureLongPress) {
- UpdateTextInputState(true, true);
+ UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_NON_IME);
}
#endif
}
+void RenderWidget::StartCompositor() {
+ // For widgets that are never visible, we don't need the compositor to run
+ // at all.
+ if (never_visible_)
+ return;
+ compositor_->setSurfaceReady();
+}
+
void RenderWidget::SchedulePluginMove(const WebPluginGeometry& move) {
size_t i = 0;
for (; i < plugin_window_moves_.size(); ++i) {
// Ignore setTouchAction calls that result from synthetic touch events (eg.
// when blink is emulating touch with mouse).
- if (!handling_touchstart_event_)
+ if (handling_event_type_ != WebInputEvent::TouchStart)
return;
// Verify the same values are used by the types so we can cast between them.
COMPILE_ASSERT(static_cast<blink::WebTouchAction>(TOUCH_ACTION_PAN_Y) ==
blink::WebTouchActionPanY,
enum_values_must_match_for_touch_action);
+ COMPILE_ASSERT(
+ static_cast<blink::WebTouchAction>(TOUCH_ACTION_PINCH_ZOOM) ==
+ blink::WebTouchActionPinchZoom,
+ enum_values_must_match_for_touch_action);
content::TouchAction content_touch_action =
static_cast<content::TouchAction>(web_touch_action);
Send(new InputHostMsg_SetTouchAction(routing_id_, content_touch_action));
}
+void RenderWidget::didUpdateTextOfFocusedElementByNonUserInput() {
+#if defined(OS_ANDROID)
+ text_field_is_dirty_ = true;
+#endif
+}
+
bool RenderWidget::HasTouchEventHandlersAt(const gfx::Point& point) const {
return true;
}
scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
-RenderWidget::CreateGraphicsContext3D(
- const blink::WebGraphicsContext3D::Attributes& attributes) {
+RenderWidget::CreateGraphicsContext3D() {
if (!webwidget_)
return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
if (CommandLine::ForCurrentProcess()->HasSwitch(
if (!gpu_channel_host)
return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
+ // Explicitly disable antialiasing for the compositor. As of the time of
+ // this writing, the only platform that supported antialiasing for the
+ // compositor was Mac OS X, because the on-screen OpenGL context creation
+ // code paths on Windows and Linux didn't yet have multisampling support.
+ // Mac OS X essentially always behaves as though it's rendering offscreen.
+ // Multisampling has a heavy cost especially on devices with relatively low
+ // fill rate like most notebooks, and the Mac implementation would need to
+ // be optimized to resolve directly into the IOSurface shared between the
+ // GPU and browser processes. For these reasons and to avoid platform
+ // disparities we explicitly disable antialiasing.
+ blink::WebGraphicsContext3D::Attributes attributes;
+ attributes.antialias = false;
+ attributes.shareResources = true;
+ attributes.noAutomaticFlushes = true;
+ attributes.depth = false;
+ attributes.stencil = false;
+ bool lose_context_when_out_of_memory = true;
WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits limits;
#if defined(OS_ANDROID)
// If we raster too fast we become upload bound, and pending
// uploads, after which we are just wasting memory. Since we don't
// know our upload throughput yet, this just caps our memory usage.
size_t divider = 1;
- if (base::android::SysUtils::IsLowEndDevice())
+ if (base::SysInfo::IsLowEndDevice())
divider = 6;
// For reference Nexus10 can upload 1MB in about 2.5ms.
const double max_mb_uploaded_per_ms = 2.0 / (5 * divider);
#endif
scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context(
- new WebGraphicsContext3DCommandBufferImpl(
- surface_id(),
- GetURLForGraphicsContext3D(),
- gpu_channel_host.get(),
- attributes,
- false /* bind generates resources */,
- limits));
+ new WebGraphicsContext3DCommandBufferImpl(surface_id(),
+ GetURLForGraphicsContext3D(),
+ gpu_channel_host.get(),
+ attributes,
+ lose_context_when_out_of_memory,
+ limits,
+ NULL));
return context.Pass();
}
-void RenderWidget::RegisterSwappedOutChildFrame(RenderFrameImpl* frame) {
- swapped_out_frames_.AddObserver(frame);
+void RenderWidget::RegisterRenderFrameProxy(RenderFrameProxy* proxy) {
+ render_frame_proxies_.AddObserver(proxy);
+}
+
+void RenderWidget::UnregisterRenderFrameProxy(RenderFrameProxy* proxy) {
+ render_frame_proxies_.RemoveObserver(proxy);
+}
+
+void RenderWidget::RegisterRenderFrame(RenderFrameImpl* frame) {
+ render_frames_.AddObserver(frame);
+}
+
+void RenderWidget::UnregisterRenderFrame(RenderFrameImpl* frame) {
+ render_frames_.RemoveObserver(frame);
+}
+
+#if defined(VIDEO_HOLE)
+void RenderWidget::RegisterVideoHoleFrame(RenderFrameImpl* frame) {
+ video_hole_frames_.AddObserver(frame);
}
-void RenderWidget::UnregisterSwappedOutChildFrame(RenderFrameImpl* frame) {
- swapped_out_frames_.RemoveObserver(frame);
+void RenderWidget::UnregisterVideoHoleFrame(RenderFrameImpl* frame) {
+ video_hole_frames_.RemoveObserver(frame);
}
+#endif // defined(VIDEO_HOLE)
} // namespace content
projects / platform / framework / web / crosswalk.git / blobdiff