blob: 824e1e8e715118d66a1234b1801c70f4e6f5d454 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "third_party/blink/renderer/core/input/mouse_wheel_event_manager.h"
#include "build/build_config.h"
#include "third_party/blink/public/platform/web_mouse_wheel_event.h"
#include "third_party/blink/renderer/core/dom/document.h"
#include "third_party/blink/renderer/core/events/wheel_event.h"
#include "third_party/blink/renderer/core/frame/local_dom_window.h"
#include "third_party/blink/renderer/core/frame/local_frame_view.h"
#include "third_party/blink/renderer/core/input/event_handler.h"
#include "third_party/blink/renderer/core/input/event_handling_util.h"
#include "third_party/blink/renderer/core/layout/hit_test_request.h"
#include "third_party/blink/renderer/core/layout/hit_test_result.h"
#include "third_party/blink/renderer/core/layout/layout_view.h"
namespace blink {
MouseWheelEventManager::MouseWheelEventManager(LocalFrame& frame)
: frame_(frame), wheel_target_(nullptr) {}
void MouseWheelEventManager::Trace(blink::Visitor* visitor) {
visitor->Trace(frame_);
visitor->Trace(wheel_target_);
}
void MouseWheelEventManager::Clear() {
wheel_target_ = nullptr;
}
WebInputEventResult MouseWheelEventManager::HandleWheelEvent(
const WebMouseWheelEvent& event) {
Document* doc = frame_->GetDocument();
if (!doc || !doc->GetLayoutView())
return WebInputEventResult::kNotHandled;
LocalFrameView* view = frame_->View();
if (!view)
return WebInputEventResult::kNotHandled;
const int kWheelEventPhaseEndedEventMask =
WebMouseWheelEvent::kPhaseEnded | WebMouseWheelEvent::kPhaseCancelled;
const int kWheelEventPhaseNoEventMask =
kWheelEventPhaseEndedEventMask | WebMouseWheelEvent::kPhaseMayBegin;
if ((event.phase & kWheelEventPhaseEndedEventMask) ||
(event.momentum_phase & kWheelEventPhaseEndedEventMask)) {
wheel_target_ = nullptr;
}
if ((event.phase & kWheelEventPhaseNoEventMask) ||
(event.momentum_phase & kWheelEventPhaseNoEventMask)) {
// Filter wheel events with zero deltas and reset the wheel_target_ node.
DCHECK(!event.delta_x && !event.delta_y);
return WebInputEventResult::kNotHandled;
}
// Synthetic wheel events generated from GestureDoubleTap are phaseless.
// Wheel events generated from plugin and tests may not have phase info.
bool has_phase_info = event.phase != WebMouseWheelEvent::kPhaseNone ||
event.momentum_phase != WebMouseWheelEvent::kPhaseNone;
// Find and save the wheel_target_, this target will be used for the rest
// of the current scrolling sequence. In the absence of phase info, send the
// event to the target under the cursor.
if (event.phase == WebMouseWheelEvent::kPhaseBegan || !wheel_target_ ||
!has_phase_info) {
wheel_target_ = FindTargetNode(event, doc, view);
}
LocalFrame* subframe =
event_handling_util::SubframeForTargetNode(wheel_target_.Get());
if (subframe) {
WebInputEventResult result =
subframe->GetEventHandler().HandleWheelEvent(event);
return result;
}
if (wheel_target_) {
WheelEvent* dom_event =
WheelEvent::Create(event, wheel_target_->GetDocument().domWindow());
// The event handler might remove |wheel_target_| from DOM so we should get
// this value now (see https://crbug.com/857013).
bool should_enforce_vertical_scroll =
wheel_target_->GetDocument().IsVerticalScrollEnforced();
DispatchEventResult dom_event_result =
wheel_target_->DispatchEvent(*dom_event);
if (dom_event_result != DispatchEventResult::kNotCanceled) {
// Reset the target if the dom event is cancelled to make sure that new
// targeting happens for the next wheel event.
wheel_target_ = nullptr;
bool is_vertical = dom_event->NativeEvent().event_action ==
WebMouseWheelEvent::EventAction::kScrollVertical;
// TODO(ekaramad): If the only wheel handlers on the page are from such
// disabled frames we should simply start scrolling on CC and the events
// must get here as passive (https://crbug.com/853059).
// Overwriting the dispatch results ensures that vertical scroll cannot be
// blocked by disabled frames.
return (should_enforce_vertical_scroll && is_vertical)
? WebInputEventResult::kNotHandled
: event_handling_util::ToWebInputEventResult(dom_event_result);
}
}
return WebInputEventResult::kNotHandled;
}
void MouseWheelEventManager::ElementRemoved(Node* target) {
if (wheel_target_ == target)
wheel_target_ = nullptr;
}
Node* MouseWheelEventManager::FindTargetNode(const WebMouseWheelEvent& event,
const Document* doc,
const LocalFrameView* view) {
DCHECK(doc && doc->GetLayoutView() && view);
LayoutPoint v_point =
view->ConvertFromRootFrame(FlooredIntPoint(event.PositionInRootFrame()));
HitTestRequest request(HitTestRequest::kReadOnly);
HitTestLocation location(v_point);
HitTestResult result(request, location);
doc->GetLayoutView()->HitTest(location, result);
Node* node = result.InnerNode();
// Wheel events should not dispatch to text nodes.
if (node && node->IsTextNode())
node = FlatTreeTraversal::Parent(*node);
// If we're over the frame scrollbar, scroll the document.
if (!node && result.GetScrollbar())
node = doc->documentElement();
return node;
}
} // namespace blink
|
