diff options
Diffstat (limited to 'chromium/content/browser/renderer_host')
11 files changed, 163 insertions, 49 deletions
diff --git a/chromium/content/browser/renderer_host/compositor_impl_android.cc b/chromium/content/browser/renderer_host/compositor_impl_android.cc index 6cbf42626e1..8738af74a88 100644 --- a/chromium/content/browser/renderer_host/compositor_impl_android.cc +++ b/chromium/content/browser/renderer_host/compositor_impl_android.cc @@ -544,6 +544,11 @@ void CompositorImpl::SetRootWindow(gfx::NativeWindow root_window) { root_window_ = root_window; root_window_->SetLayer(root_layer ? root_layer : cc::Layer::Create()); root_window_->GetLayer()->SetBounds(size_); + if (!readback_layer_tree_) { + readback_layer_tree_ = cc::Layer::Create(); + readback_layer_tree_->SetHideLayerAndSubtree(true); + } + root_window->GetLayer()->AddChild(readback_layer_tree_); root_window->AttachCompositor(this); if (!host_) { CreateLayerTreeHost(); @@ -923,17 +928,8 @@ void CompositorImpl::DidCommit() { root_window_->OnCompositingDidCommit(); } -base::WeakPtr<ui::WindowAndroidCompositor> CompositorImpl::GetWeakPtr() { - return weak_factory_.GetWeakPtr(); -} - -void CompositorImpl::IncrementReadbackRequestCount() { - pending_readback_request_count_++; -} - -void CompositorImpl::DecrementReadbackRequestCount() { - DCHECK_GT(pending_readback_request_count_, 0u); - pending_readback_request_count_--; +void CompositorImpl::AttachLayerForReadback(scoped_refptr<cc::Layer> layer) { + readback_layer_tree_->AddChild(layer); } void CompositorImpl::RequestCopyOfOutputOnRootLayer( @@ -995,7 +991,7 @@ void CompositorImpl::OnDisplayMetricsChanged(const display::Display& display, } bool CompositorImpl::HavePendingReadbacks() { - return pending_readback_request_count_ > 0u; + return !readback_layer_tree_->children().empty(); } std::unique_ptr<ui::CompositorLock> CompositorImpl::GetCompositorLock( diff --git a/chromium/content/browser/renderer_host/compositor_impl_android.h b/chromium/content/browser/renderer_host/compositor_impl_android.h index a037726c11d..6b59f095804 100644 --- a/chromium/content/browser/renderer_host/compositor_impl_android.h +++ b/chromium/content/browser/renderer_host/compositor_impl_android.h @@ -122,9 +122,7 @@ class CONTENT_EXPORT CompositorImpl void DidLoseLayerTreeFrameSink() override; // WindowAndroidCompositor implementation. - base::WeakPtr<ui::WindowAndroidCompositor> GetWeakPtr() override; - void IncrementReadbackRequestCount() override; - void DecrementReadbackRequestCount() override; + void AttachLayerForReadback(scoped_refptr<cc::Layer> layer) override; void RequestCopyOfOutputOnRootLayer( std::unique_ptr<viz::CopyOutputRequest> request) override; void SetNeedsAnimate() override; @@ -177,6 +175,9 @@ class CONTENT_EXPORT CompositorImpl // is the one attached by the compositor client. scoped_refptr<cc::Layer> subroot_layer_; + // Subtree for hidden layers with CopyOutputRequests on them. + scoped_refptr<cc::Layer> readback_layer_tree_; + // Destruction order matters here: std::unique_ptr<cc::AnimationHost> animation_host_; std::unique_ptr<cc::LayerTreeHost> host_; @@ -215,8 +216,6 @@ class CONTENT_EXPORT CompositorImpl ui::CompositorLockManager lock_manager_; bool has_submitted_frame_since_became_visible_ = false; - unsigned int pending_readback_request_count_ = 0u; - // A task which runs cleanup tasks on low-end Android after a delay. Enqueued // when we hide, canceled when we're shown. base::CancelableOnceClosure low_end_background_cleanup_task_; diff --git a/chromium/content/browser/renderer_host/input/mouse_wheel_phase_handler.cc b/chromium/content/browser/renderer_host/input/mouse_wheel_phase_handler.cc index acf8f012a83..85864f594da 100644 --- a/chromium/content/browser/renderer_host/input/mouse_wheel_phase_handler.cc +++ b/chromium/content/browser/renderer_host/input/mouse_wheel_phase_handler.cc @@ -14,7 +14,7 @@ MouseWheelPhaseHandler::MouseWheelPhaseHandler( RenderWidgetHostViewBase* const host_view) : host_view_(host_view), mouse_wheel_end_dispatch_timeout_(kDefaultMouseWheelLatchingTransaction), - scroll_phase_state_(SCROLL_STATE_UNKNOWN) {} + touchpad_scroll_phase_state_(TOUCHPAD_SCROLL_STATE_UNKNOWN) {} void MouseWheelPhaseHandler::AddPhaseIfNeededAndScheduleEndEvent( blink::WebMouseWheelEvent& mouse_wheel_event, @@ -43,8 +43,8 @@ void MouseWheelPhaseHandler::AddPhaseIfNeededAndScheduleEndEvent( IgnorePendingWheelEndEvent(); } } else { // !has_phase - switch (scroll_phase_state_) { - case SCROLL_STATE_UNKNOWN: { + switch (touchpad_scroll_phase_state_) { + case TOUCHPAD_SCROLL_STATE_UNKNOWN: { mouse_wheel_event.has_synthetic_phase = true; // Break the latching when the location difference between the current // and the initial wheel event positions exceeds the maximum allowed @@ -75,11 +75,11 @@ void MouseWheelPhaseHandler::AddPhaseIfNeededAndScheduleEndEvent( } break; } - case SCROLL_MAY_BEGIN: + case TOUCHPAD_SCROLL_MAY_BEGIN: mouse_wheel_event.phase = blink::WebMouseWheelEvent::kPhaseBegan; - scroll_phase_state_ = SCROLL_IN_PROGRESS; + touchpad_scroll_phase_state_ = TOUCHPAD_SCROLL_IN_PROGRESS; break; - case SCROLL_IN_PROGRESS: + case TOUCHPAD_SCROLL_IN_PROGRESS: mouse_wheel_event.phase = blink::WebMouseWheelEvent::kPhaseChanged; break; default: @@ -103,15 +103,15 @@ void MouseWheelPhaseHandler::IgnorePendingWheelEndEvent() { mouse_wheel_end_dispatch_timer_.Stop(); } -void MouseWheelPhaseHandler::ResetScrollSequence() { - scroll_phase_state_ = SCROLL_STATE_UNKNOWN; +void MouseWheelPhaseHandler::ResetTouchpadScrollSequence() { + touchpad_scroll_phase_state_ = TOUCHPAD_SCROLL_STATE_UNKNOWN; } -void MouseWheelPhaseHandler::SendWheelEndIfNeeded() { - if (scroll_phase_state_ == SCROLL_IN_PROGRESS) { +void MouseWheelPhaseHandler::SendWheelEndForTouchpadScrollingIfNeeded() { + if (touchpad_scroll_phase_state_ == TOUCHPAD_SCROLL_IN_PROGRESS) { RenderWidgetHostImpl* widget_host = host_view_->host(); if (!widget_host) { - ResetScrollSequence(); + ResetTouchpadScrollSequence(); return; } @@ -120,11 +120,18 @@ void MouseWheelPhaseHandler::SendWheelEndIfNeeded() { SendSyntheticWheelEventWithPhaseEnded(should_route_event); } - ResetScrollSequence(); + ResetTouchpadScrollSequence(); } -void MouseWheelPhaseHandler::ScrollingMayBegin() { - scroll_phase_state_ = SCROLL_MAY_BEGIN; +void MouseWheelPhaseHandler::TouchpadScrollingMayBegin() { + // End the timer-based wheel scroll sequence before starting a touchpad scroll + // sequence. + if (mouse_wheel_end_dispatch_timer_.IsRunning()) { + DCHECK_EQ(TOUCHPAD_SCROLL_STATE_UNKNOWN, touchpad_scroll_phase_state_); + DispatchPendingWheelEndEvent(); + } + + touchpad_scroll_phase_state_ = TOUCHPAD_SCROLL_MAY_BEGIN; } void MouseWheelPhaseHandler::SendSyntheticWheelEventWithPhaseEnded( @@ -169,7 +176,7 @@ bool MouseWheelPhaseHandler::IsWithinSlopRegion( // This function is called to check if breaking timer-based wheel scroll // latching sequence is needed or not, and timer-based wheel scroll latching // happens only when scroll state is unknown. - DCHECK(scroll_phase_state_ == SCROLL_STATE_UNKNOWN); + DCHECK(touchpad_scroll_phase_state_ == TOUCHPAD_SCROLL_STATE_UNKNOWN); gfx::Vector2dF current_wheel_location(wheel_event.PositionInWidget().x, wheel_event.PositionInWidget().y); return (current_wheel_location - first_wheel_location_).LengthSquared() < @@ -181,7 +188,7 @@ bool MouseWheelPhaseHandler::HasDifferentModifiers( // This function is called to check if breaking timer-based wheel scroll // latching sequence is needed or not, and timer-based wheel scroll latching // happens only when scroll state is unknown. - DCHECK(scroll_phase_state_ == SCROLL_STATE_UNKNOWN); + DCHECK(touchpad_scroll_phase_state_ == TOUCHPAD_SCROLL_STATE_UNKNOWN); return wheel_event.GetModifiers() != initial_wheel_event_.GetModifiers(); } @@ -190,7 +197,7 @@ bool MouseWheelPhaseHandler::ShouldBreakLatchingDueToDirectionChange( // This function is called to check if breaking timer-based wheel scroll // latching sequence is needed or not, and timer-based wheel scroll latching // happens only when scroll state is unknown. - DCHECK(scroll_phase_state_ == SCROLL_STATE_UNKNOWN); + DCHECK(touchpad_scroll_phase_state_ == TOUCHPAD_SCROLL_STATE_UNKNOWN); if (first_scroll_update_ack_state_ != FirstScrollUpdateAckState::kNotConsumed) return false; diff --git a/chromium/content/browser/renderer_host/input/mouse_wheel_phase_handler.h b/chromium/content/browser/renderer_host/input/mouse_wheel_phase_handler.h index 343f8172d85..4f7c03d6293 100644 --- a/chromium/content/browser/renderer_host/input/mouse_wheel_phase_handler.h +++ b/chromium/content/browser/renderer_host/input/mouse_wheel_phase_handler.h @@ -29,15 +29,18 @@ constexpr base::TimeDelta kMaximumTimeBetweenPhaseEndedAndMomentumPhaseBegan = const double kWheelLatchingSlopRegion = 10.0; // On ChromeOS wheel events don't have phase information; However, whenever the -// user puts down or lifts their fingers a GFC or GFS is received. -enum ScrollPhaseState { +// user puts down their fingers on touchpad a GFC is received and at the end of +// touchpad scrolling when the user lifts their fingers a GFS is received. This +// enum tracks the current state of the touchpad scrolling by listening to GFC +// and GFS events. +enum TouchpadScrollPhaseState { // Scrolling with normal mouse wheels doesn't give any information about the // state of scrolling. - SCROLL_STATE_UNKNOWN = 0, + TOUCHPAD_SCROLL_STATE_UNKNOWN = 0, // Shows that the user has put their fingers down and a scroll may start. - SCROLL_MAY_BEGIN, + TOUCHPAD_SCROLL_MAY_BEGIN, // Scrolling has started and the user hasn't lift their fingers, yet. - SCROLL_IN_PROGRESS, + TOUCHPAD_SCROLL_IN_PROGRESS, }; enum class FirstScrollUpdateAckState { @@ -49,6 +52,9 @@ enum class FirstScrollUpdateAckState { kNotConsumed, }; +// The MouseWheelPhaseHandler is responsible for adding the proper phase to +// wheel events. Phase information is necessary for wheel scrolling since it +// shows the start and end of a scrolling sequence. class MouseWheelPhaseHandler { public: MouseWheelPhaseHandler(RenderWidgetHostViewBase* const host_view); @@ -59,9 +65,9 @@ class MouseWheelPhaseHandler { bool should_route_event); void DispatchPendingWheelEndEvent(); void IgnorePendingWheelEndEvent(); - void ResetScrollSequence(); - void SendWheelEndIfNeeded(); - void ScrollingMayBegin(); + void ResetTouchpadScrollSequence(); + void SendWheelEndForTouchpadScrollingIfNeeded(); + void TouchpadScrollingMayBegin(); // Used to set the timer timeout for testing. void set_mouse_wheel_end_dispatch_timeout(base::TimeDelta timeout) { @@ -89,7 +95,7 @@ class MouseWheelPhaseHandler { base::OneShotTimer mouse_wheel_end_dispatch_timer_; base::TimeDelta mouse_wheel_end_dispatch_timeout_; blink::WebMouseWheelEvent last_mouse_wheel_event_; - ScrollPhaseState scroll_phase_state_; + TouchpadScrollPhaseState touchpad_scroll_phase_state_; // This is used to break the timer based latching when the difference between // the locations of the first wheel event and the current wheel event is // larger than some threshold. The variable value is only valid while the diff --git a/chromium/content/browser/renderer_host/render_process_host_impl.cc b/chromium/content/browser/renderer_host/render_process_host_impl.cc index e49d8d0eaa2..6175e84b718 100644 --- a/chromium/content/browser/renderer_host/render_process_host_impl.cc +++ b/chromium/content/browser/renderer_host/render_process_host_impl.cc @@ -2586,6 +2586,11 @@ bool RenderProcessHostImpl::IsSpareProcessKeptAtAllTimes() { if (!base::FeatureList::IsEnabled(features::kSpareRendererForSitePerProcess)) return false; + // Spare renderer actually hurts performance on low-memory devices. See + // https://crbug.com/843775 for more details. + if (base::SysInfo::AmountOfPhysicalMemoryMB() <= 1077) + return false; + return true; } diff --git a/chromium/content/browser/renderer_host/render_widget_host_view_android.cc b/chromium/content/browser/renderer_host/render_widget_host_view_android.cc index 71c81ed240a..18be0d64dcf 100644 --- a/chromium/content/browser/renderer_host/render_widget_host_view_android.cc +++ b/chromium/content/browser/renderer_host/render_widget_host_view_android.cc @@ -847,6 +847,10 @@ void RenderWidgetHostViewAndroid::ShowDisambiguationPopup( tap_disambiguator_->ShowPopup(rect_pixels, zoomed_bitmap); } +void RenderWidgetHostViewAndroid::OnInterstitialPageGoingAway() { + sync_compositor_.reset(); +} + std::unique_ptr<SyntheticGestureTarget> RenderWidgetHostViewAndroid::CreateSyntheticGestureTarget() { return std::unique_ptr<SyntheticGestureTarget>( diff --git a/chromium/content/browser/renderer_host/render_widget_host_view_android.h b/chromium/content/browser/renderer_host/render_widget_host_view_android.h index 4e9fef8bc8f..472e6316b7a 100644 --- a/chromium/content/browser/renderer_host/render_widget_host_view_android.h +++ b/chromium/content/browser/renderer_host/render_widget_host_view_android.h @@ -163,6 +163,7 @@ class CONTENT_EXPORT RenderWidgetHostViewAndroid void DidStopFlinging() override; void ShowDisambiguationPopup(const gfx::Rect& rect_pixels, const SkBitmap& zoomed_bitmap) override; + void OnInterstitialPageGoingAway() override; std::unique_ptr<SyntheticGestureTarget> CreateSyntheticGestureTarget() override; void OnDidNavigateMainFrameToNewPage() override; diff --git a/chromium/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc b/chromium/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc index c099868cabc..ba3facd9161 100644 --- a/chromium/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc +++ b/chromium/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc @@ -696,6 +696,10 @@ class RenderWidgetHostViewAuraTest : public testing::Test { return delegates_.back().get(); } + MouseWheelPhaseHandler* GetMouseWheelPhaseHandler() const { + return &(view_->event_handler()->mouse_wheel_phase_handler()); + } + // Sets the |view| active in TextInputManager with the given |type|. |type| // cannot be ui::TEXT_INPUT_TYPE_NONE. // Must not be called in the destruction path of |view|. @@ -2492,6 +2496,81 @@ TEST_F(RenderWidgetHostViewAuraAsyncWheelEventsEnabledTest, TouchpadFlingStartResetsWheelPhaseState(); } +TEST_F(RenderWidgetHostViewAuraAsyncWheelEventsEnabledTest, + ScrollingWithExternalMouseBreaksTouchpadScrollLatching) { + // The test is valid only when wheel scroll latching is enabled. + if (wheel_scrolling_mode_ == kWheelScrollingModeNone) + return; + + // Set the mouse_wheel_phase_handler_ timer timeout to a large value to make + // sure that the timer is still running when we are checking for the pending + // wheel end event after sending ui::MouseWheelEvent. + view_->event_handler()->set_mouse_wheel_wheel_phase_handler_timeout( + TestTimeouts::action_max_timeout()); + + view_->InitAsChild(nullptr); + view_->Show(); + sink_->ClearMessages(); + + // When the user puts their fingers down a GFC is receieved. + ui::ScrollEvent fling_cancel(ui::ET_SCROLL_FLING_CANCEL, gfx::Point(2, 2), + ui::EventTimeForNow(), 0, 0, 0, 0, 0, 2); + view_->OnScrollEvent(&fling_cancel); + + // Start touchpad scrolling by sending a ui::ET_SCROLL event. + ui::ScrollEvent scroll0(ui::ET_SCROLL, gfx::Point(2, 2), + ui::EventTimeForNow(), 0, 0, 5, 0, 5, 2); + view_->OnScrollEvent(&scroll0); + base::RunLoop().RunUntilIdle(); + MockWidgetInputHandler::MessageVector events = + GetAndResetDispatchedMessages(); + + const WebMouseWheelEvent* wheel_event = + static_cast<const WebMouseWheelEvent*>( + events[0]->ToEvent()->Event()->web_event.get()); + EXPECT_EQ("MouseWheel", GetMessageNames(events)); + EXPECT_EQ(WebMouseWheelEvent::kPhaseBegan, wheel_event->phase); + events[0]->ToEvent()->CallCallback(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); + + // The mouse_wheel_phase_handler's timer won't be running during touchpad + // scroll. + EXPECT_FALSE(GetMouseWheelPhaseHandler()->HasPendingWheelEndEvent()); + + // ACK the GSB and GSU events generated from the first touchpad wheel event. + events = GetAndResetDispatchedMessages(); + EXPECT_EQ("GestureScrollBegin GestureScrollUpdate", GetMessageNames(events)); + const WebGestureEvent* gesture_event = static_cast<const WebGestureEvent*>( + events[0]->ToEvent()->Event()->web_event.get()); + EXPECT_EQ(WebInputEvent::kGestureScrollBegin, gesture_event->GetType()); + events[0]->ToEvent()->CallCallback(INPUT_EVENT_ACK_STATE_CONSUMED); + gesture_event = static_cast<const WebGestureEvent*>( + events[1]->ToEvent()->Event()->web_event.get()); + EXPECT_EQ(WebInputEvent::kGestureScrollUpdate, gesture_event->GetType()); + events[1]->ToEvent()->CallCallback(INPUT_EVENT_ACK_STATE_CONSUMED); + + // Start mouse wheel scrolling by sending a ui::ET_MOUSEWHEEL event. This + // should end the touchpad scrolling sequence and start a new timer-based + // wheel scrolling sequence. + ui::MouseWheelEvent wheel(gfx::Vector2d(0, 5), gfx::Point(2, 2), + gfx::Point(2, 2), ui::EventTimeForNow(), 0, 0); + view_->OnMouseEvent(&wheel); + base::RunLoop().RunUntilIdle(); + events = GetAndResetDispatchedMessages(); + EXPECT_EQ("MouseWheel GestureScrollEnd MouseWheel", GetMessageNames(events)); + EXPECT_TRUE(events[0]->ToEvent()); + wheel_event = static_cast<const WebMouseWheelEvent*>( + events[0]->ToEvent()->Event()->web_event.get()); + EXPECT_EQ(WebMouseWheelEvent::kPhaseEnded, wheel_event->phase); + EXPECT_TRUE(events[2]->ToEvent()); + wheel_event = static_cast<const WebMouseWheelEvent*>( + events[2]->ToEvent()->Event()->web_event.get()); + EXPECT_EQ(WebMouseWheelEvent::kPhaseBegan, wheel_event->phase); + + // The mouse_wheel_phase_handler's timer will be running during mouse wheel + // scroll. + EXPECT_TRUE(GetMouseWheelPhaseHandler()->HasPendingWheelEndEvent()); +} + void RenderWidgetHostViewAuraTest:: GSBWithTouchSourceStopsWheelScrollSequence() { // The test is valid only when wheel scroll latching is enabled. diff --git a/chromium/content/browser/renderer_host/render_widget_host_view_base.h b/chromium/content/browser/renderer_host/render_widget_host_view_base.h index 9982522d4be..0a12a6666ff 100644 --- a/chromium/content/browser/renderer_host/render_widget_host_view_base.h +++ b/chromium/content/browser/renderer_host/render_widget_host_view_base.h @@ -383,6 +383,12 @@ class CONTENT_EXPORT RenderWidgetHostViewBase // Returns true if this view's size have been initialized. virtual bool HasSize() const; + // Tells the view that the assocaited InterstitialPage will going away (but is + // not yet destroyed, as InterstitialPage destruction is asynchronous). The + // view may use this notification to clean up associated resources. This + // should be called before the WebContents is fully destroyed. + virtual void OnInterstitialPageGoingAway() {} + //---------------------------------------------------------------------------- // The following methods are related to IME. // TODO(ekaramad): Most of the IME methods should not stay virtual after IME diff --git a/chromium/content/browser/renderer_host/render_widget_host_view_child_frame.cc b/chromium/content/browser/renderer_host/render_widget_host_view_child_frame.cc index 0f78c03f686..c02239a7bc5 100644 --- a/chromium/content/browser/renderer_host/render_widget_host_view_child_frame.cc +++ b/chromium/content/browser/renderer_host/render_widget_host_view_child_frame.cc @@ -433,7 +433,13 @@ void RenderWidgetHostViewChildFrame::SetTooltipText( if (!root_view) return; - root_view->GetCursorManager()->SetTooltipTextForView(this, tooltip_text); + auto* cursor_manager = root_view->GetCursorManager(); + // If there's no CursorManager then we're on Android, and setting tooltips + // is a null-opt there, so it's ok to early out. + if (!cursor_manager) + return; + + cursor_manager->SetTooltipTextForView(this, tooltip_text); } RenderWidgetHostViewBase* RenderWidgetHostViewChildFrame::GetParentView() { diff --git a/chromium/content/browser/renderer_host/render_widget_host_view_event_handler.cc b/chromium/content/browser/renderer_host/render_widget_host_view_event_handler.cc index e046d3a5e23..69c041eed92 100644 --- a/chromium/content/browser/renderer_host/render_widget_host_view_event_handler.cc +++ b/chromium/content/browser/renderer_host/render_widget_host_view_event_handler.cc @@ -368,9 +368,14 @@ void RenderWidgetHostViewEventHandler::OnMouseEvent(ui::MouseEvent* event) { if (mouse_wheel_event.delta_x != 0 || mouse_wheel_event.delta_y != 0) { bool should_route_event = ShouldRouteEvent(event); - if (host_view_->wheel_scroll_latching_enabled()) + if (host_view_->wheel_scroll_latching_enabled()) { + // End the touchpad scrolling sequence (if such exists) before handling + // a ui::ET_MOUSEWHEEL event. + mouse_wheel_phase_handler_.SendWheelEndForTouchpadScrollingIfNeeded(); + mouse_wheel_phase_handler_.AddPhaseIfNeededAndScheduleEndEvent( mouse_wheel_event, should_route_event); + } if (should_route_event) { host_->delegate()->GetInputEventRouter()->RouteMouseWheelEvent( host_view_, &mouse_wheel_event, *event->latency()); @@ -465,11 +470,11 @@ void RenderWidgetHostViewEventHandler::OnScrollEvent(ui::ScrollEvent* event) { if (event->type() == ui::ET_SCROLL_FLING_START) { RecordAction(base::UserMetricsAction("TrackpadScrollFling")); // The user has lifted their fingers. - mouse_wheel_phase_handler_.ResetScrollSequence(); + mouse_wheel_phase_handler_.ResetTouchpadScrollSequence(); } else if (event->type() == ui::ET_SCROLL_FLING_CANCEL) { // The user has put their fingers down. DCHECK_EQ(blink::kWebGestureDeviceTouchpad, gesture_event.SourceDevice()); - mouse_wheel_phase_handler_.ScrollingMayBegin(); + mouse_wheel_phase_handler_.TouchpadScrollingMayBegin(); } } @@ -568,7 +573,7 @@ void RenderWidgetHostViewEventHandler::OnGestureEvent(ui::GestureEvent* event) { // wheel based send a synthetic wheel event with kPhaseEnded to cancel // the current scroll. mouse_wheel_phase_handler_.DispatchPendingWheelEndEvent(); - mouse_wheel_phase_handler_.SendWheelEndIfNeeded(); + mouse_wheel_phase_handler_.SendWheelEndForTouchpadScrollingIfNeeded(); } else if (event->type() == ui::ET_SCROLL_FLING_START) { RecordAction(base::UserMetricsAction("TouchscreenScrollFling")); } @@ -580,7 +585,7 @@ void RenderWidgetHostViewEventHandler::OnGestureEvent(ui::GestureEvent* event) { // correct phase info when some of the wheel events get ignored while a // touchscreen scroll is going on. mouse_wheel_phase_handler_.IgnorePendingWheelEndEvent(); - mouse_wheel_phase_handler_.ResetScrollSequence(); + mouse_wheel_phase_handler_.ResetTouchpadScrollSequence(); } if (ShouldRouteEvent(event)) { |