⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 176753 in webkit


Ignore:
Timestamp:
Dec 3, 2014, 1:53:36 PM (12 years ago)
Author:
timothy_horton@apple.com
Message:

Keyboard input should be disabled in the preview popover
​https://bugs.webkit.org/show_bug.cgi?id=139219
<rdar://problem/19052381>

Reviewed by Anders Carlsson.

Make sure that keyboard input, Quick Look, etc. are blocked in preview popovers
and WKThumbnailViews. Also block the fake mouseMove events that originate in
the Web process upon scrolling, because we were missing those despite blocking
ordinary mouseMove events.

  • page/ChromeClient.h:

(WebCore::ChromeClient::shouldDispatchFakeMouseMoveEvents):

  • page/EventHandler.cpp:

(WebCore::EventHandler::dispatchFakeMouseMoveEventSoon):
Allow ChromeClient to disable the dispatch of "fake" mouseMove events
that happens during scrolling.

  • UIProcess/API/Cocoa/WKViewPrivate.h:
  • UIProcess/API/mac/WKView.mm:

Rename _ignoresNonWheelMouseEvents to _ignoresNonWheelEvents, because it will
apply not only to mouse events but also key events, Quick Look events, menu
preparation events, swipe events, etc.

Add _ignoresAllEvents, which means the same thing as _ignoresNonWheelEvents
with the addition of ignoring scrollWheel events.

(-[WKView scrollWheel:]):
(-[WKView swipeWithEvent:]):
(-[WKView mouseMoved:]):
(-[WKView mouseDown:]):
(-[WKView mouseUp:]):
(-[WKView mouseDragged:]):
Adjust to the new name.

(-[WKView performKeyEquivalent:]):
(-[WKView keyUp:]):
(-[WKView keyDown:]):
(-[WKView flagsChanged:]):
(-[WKView quickLookWithEvent:]):
(-[WKView prepareForMenu:withEvent:]):
(-[WKView willOpenMenu:withEvent:]):
(-[WKView didCloseMenu:withEvent:]):
Block all of these events as well as those we were previously blocking.

(-[WKView _setIgnoresAllEvents:]):
(-[WKView _setIgnoresNonWheelMouseEvents:]):
(-[WKView _setIgnoresNonWheelEvents:]):
(-[WKView _ignoresNonWheelEvents]):
(-[WKView _ignoresAllEvents]):

  • UIProcess/API/mac/WKViewInternal.h:

Adjust to the new names and the addition of ignoresAllEvents.

  • UIProcess/mac/WKActionMenuController.mm:

(-[WKPagePreviewViewController loadView]):
Adjust to the new name.

(-[WKActionMenuController prepareForMenu:withEvent:]):
Move bailing from prepareForMenu: up to WKView.

  • UIProcess/API/Cocoa/WKWebView.mm:

(-[WKWebView _ignoresNonWheelEvents]):
(-[WKWebView _setIgnoresNonWheelEvents:]):
(-[WKWebView _ignoresNonWheelMouseEvents]): Deleted.
(-[WKWebView _setIgnoresNonWheelMouseEvents:]): Deleted.

  • UIProcess/API/Cocoa/WKWebViewInternal.h:

Adjust to the new name (without "mouse" in it).

  • UIProcess/API/Cocoa/_WKThumbnailView.mm:

(-[_WKThumbnailView _viewWasUnparented]):
(-[_WKThumbnailView _viewWasParented]):
Explicitly tell WKView to disable event handling while thumbnailed,
instead of having WKView special-case thumbnail views internally.

  • UIProcess/WebPageProxy.cpp:

(WebKit::WebPageProxy::setShouldDispatchFakeMouseMoveEvents):

  • UIProcess/WebPageProxy.h:
  • WebProcess/WebCoreSupport/WebChromeClient.cpp:

(WebKit::WebChromeClient::shouldDispatchFakeMouseMoveEvents):

  • WebProcess/WebCoreSupport/WebChromeClient.h:
  • WebProcess/WebPage/WebPage.cpp:

(WebKit::WebPage::WebPage):

  • WebProcess/WebPage/WebPage.h:

(WebKit::WebPage::shouldDispatchFakeMouseMoveEvents):
(WebKit::WebPage::setShouldDispatchFakeMouseMoveEvents):

  • WebProcess/WebPage/WebPage.messages.in:

Plumb shouldDispatchFakeMouseMoveEvents from the UI process to the Web process
and through to WebKit2's ChromeClient implementation.

Location:
trunk/Source
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r176751 r176753  
     12014-12-03  Tim Horton  <timothy_horton@apple.com>
     2
     3        Keyboard input should be disabled in the preview popover
     4        https://bugs.webkit.org/show_bug.cgi?id=139219
     5        <rdar://problem/19052381>
     6
     7        Reviewed by Anders Carlsson.
     8
     9        * page/ChromeClient.h:
     10        (WebCore::ChromeClient::shouldDispatchFakeMouseMoveEvents):
     11        * page/EventHandler.cpp:
     12        (WebCore::EventHandler::dispatchFakeMouseMoveEventSoon):
     13        Allow ChromeClient to disable the dispatch of "fake" mouseMove events
     14        that happens during scrolling.
     15
    1162014-12-03  Antti Koivisto  <antti@apple.com>
    217

  • trunk/Source/WebCore/page/ChromeClient.h

    r176670 r176753  
    447447#endif
    448448
     449    virtual bool shouldDispatchFakeMouseMoveEvents() const { return true; }
     450
    449451protected:
    450452    virtual ~ChromeClient() { }

  • trunk/Source/WebCore/page/EventHandler.cpp

    r176459 r176753  
    29052905        return;
    29062906
     2907    if (Page* page = m_frame.page()) {
     2908        if (!page->chrome().client().shouldDispatchFakeMouseMoveEvents())
     2909            return;
     2910    }
     2911
    29072912    // If the content has ever taken longer than fakeMouseMoveShortInterval we
    29082913    // reschedule the timer and use a longer time. This will cause the content

  • trunk/Source/WebKit2/ChangeLog

    r176739 r176753  
     12014-12-03  Tim Horton  <timothy_horton@apple.com>
     2
     3        Keyboard input should be disabled in the preview popover
     4        https://bugs.webkit.org/show_bug.cgi?id=139219
     5        <rdar://problem/19052381>
     6
     7        Reviewed by Anders Carlsson.
     8
     9        Make sure that keyboard input, Quick Look, etc. are blocked in preview popovers
     10        and WKThumbnailViews. Also block the fake mouseMove events that originate in
     11        the Web process upon scrolling, because we were missing those despite blocking
     12        ordinary mouseMove events.
     13
     14        * UIProcess/API/Cocoa/WKViewPrivate.h:
     15        * UIProcess/API/mac/WKView.mm:
     16        Rename _ignoresNonWheelMouseEvents to _ignoresNonWheelEvents, because it will
     17        apply not only to mouse events but also key events, Quick Look events, menu
     18        preparation events, swipe events, etc.
     19
     20        Add _ignoresAllEvents, which means the same thing as _ignoresNonWheelEvents
     21        with the addition of ignoring scrollWheel events.
     22
     23        (-[WKView scrollWheel:]):
     24        (-[WKView swipeWithEvent:]):
     25        (-[WKView mouseMoved:]):
     26        (-[WKView mouseDown:]):
     27        (-[WKView mouseUp:]):
     28        (-[WKView mouseDragged:]):
     29        Adjust to the new name.
     30
     31        (-[WKView performKeyEquivalent:]):
     32        (-[WKView keyUp:]):
     33        (-[WKView keyDown:]):
     34        (-[WKView flagsChanged:]):
     35        (-[WKView quickLookWithEvent:]):
     36        (-[WKView prepareForMenu:withEvent:]):
     37        (-[WKView willOpenMenu:withEvent:]):
     38        (-[WKView didCloseMenu:withEvent:]):
     39        Block all of these events as well as those we were previously blocking.
     40
     41        (-[WKView _setIgnoresAllEvents:]):
     42        (-[WKView _setIgnoresNonWheelMouseEvents:]):
     43        (-[WKView _setIgnoresNonWheelEvents:]):
     44        (-[WKView _ignoresNonWheelEvents]):
     45        (-[WKView _ignoresAllEvents]):
     46        * UIProcess/API/mac/WKViewInternal.h:
     47        Adjust to the new names and the addition of ignoresAllEvents.
     48
     49        * UIProcess/mac/WKActionMenuController.mm:
     50        (-[WKPagePreviewViewController loadView]):
     51        Adjust to the new name.
     52
     53        (-[WKActionMenuController prepareForMenu:withEvent:]):
     54        Move bailing from prepareForMenu: up to WKView.
     55
     56        * UIProcess/API/Cocoa/WKWebView.mm:
     57        (-[WKWebView _ignoresNonWheelEvents]):
     58        (-[WKWebView _setIgnoresNonWheelEvents:]):
     59        (-[WKWebView _ignoresNonWheelMouseEvents]): Deleted.
     60        (-[WKWebView _setIgnoresNonWheelMouseEvents:]): Deleted.
     61        * UIProcess/API/Cocoa/WKWebViewInternal.h:
     62        Adjust to the new name (without "mouse" in it).
     63
     64        * UIProcess/API/Cocoa/_WKThumbnailView.mm:
     65        (-[_WKThumbnailView _viewWasUnparented]):
     66        (-[_WKThumbnailView _viewWasParented]):
     67        Explicitly tell WKView to disable event handling while thumbnailed,
     68        instead of having WKView special-case thumbnail views internally.
     69
     70        * UIProcess/WebPageProxy.cpp:
     71        (WebKit::WebPageProxy::setShouldDispatchFakeMouseMoveEvents):
     72        * UIProcess/WebPageProxy.h:
     73        * WebProcess/WebCoreSupport/WebChromeClient.cpp:
     74        (WebKit::WebChromeClient::shouldDispatchFakeMouseMoveEvents):
     75        * WebProcess/WebCoreSupport/WebChromeClient.h:
     76        * WebProcess/WebPage/WebPage.cpp:
     77        (WebKit::WebPage::WebPage):
     78        * WebProcess/WebPage/WebPage.h:
     79        (WebKit::WebPage::shouldDispatchFakeMouseMoveEvents):
     80        (WebKit::WebPage::setShouldDispatchFakeMouseMoveEvents):
     81        * WebProcess/WebPage/WebPage.messages.in:
     82        Plumb shouldDispatchFakeMouseMoveEvents from the UI process to the Web process
     83        and through to WebKit2's ChromeClient implementation.
     84
    1852014-12-03  Anders Carlsson  <andersca@apple.com>
    286

  • trunk/Source/WebKit2/UIProcess/API/Cocoa/WKViewPrivate.h

    r176684 r176753  
    8282@property (readwrite) BOOL allowsMagnification;
    8383@property (readwrite) double magnification;
    84 @property (readwrite, setter=_setIgnoresNonWheelMouseEvents:) BOOL _ignoresNonWheelMouseEvents;
     84@property (readwrite, setter=_setIgnoresNonWheelEvents:) BOOL _ignoresNonWheelEvents;
     85@property (readwrite, setter=_setIgnoresAllEvents:) BOOL _ignoresAllEvents;
    8586@property (readwrite) BOOL allowsBackForwardNavigationGestures;
    8687@property (nonatomic, setter=_setTopContentInset:) CGFloat _topContentInset;

  • trunk/Source/WebKit2/UIProcess/API/Cocoa/WKWebView.mm

    r176448 r176753  
    15841584}
    15851585
    1586 - (BOOL)_ignoresNonWheelMouseEvents
    1587 {
    1588     return [_wkView _ignoresNonWheelMouseEvents];
    1589 }
    1590 
    1591 - (void)_setIgnoresNonWheelMouseEvents:(BOOL)ignoresNonWheelMouseEvents
    1592 {
    1593     [_wkView _setIgnoresNonWheelMouseEvents:ignoresNonWheelMouseEvents];
     1586- (BOOL)_ignoresNonWheelEvents
     1587{
     1588    return [_wkView _ignoresNonWheelEvents];
     1589}
     1590
     1591- (void)_setIgnoresNonWheelEvents:(BOOL)ignoresNonWheelEvents
     1592{
     1593    [_wkView _setIgnoresNonWheelEvents:ignoresNonWheelEvents];
    15941594}
    15951595

  • trunk/Source/WebKit2/UIProcess/API/Cocoa/WKWebViewInternal.h

    r176308 r176753  
    100100@property (nonatomic, readonly) UIEdgeInsets _computedContentInset;
    101101#else
    102 @property (nonatomic, setter=_setIgnoresNonWheelMouseEvents:) BOOL _ignoresNonWheelMouseEvents;
     102@property (nonatomic, setter=_setIgnoresNonWheelEvents:) BOOL _ignoresNonWheelEvents;
    103103#endif
    104104

  • trunk/Source/WebKit2/UIProcess/API/Cocoa/_WKThumbnailView.mm

    r172104 r176753  
    8181{
    8282    [_wkView _setThumbnailView:nil];
     83    [_wkView _setIgnoresAllEvents:NO];
    8384
    8485    self.layer.contents = nil;
    … …  
    9899    [self _requestSnapshotIfNeeded];
    99100    [_wkView _setThumbnailView:self];
     101    [_wkView _setIgnoresAllEvents:YES];
    100102}
    101103

  • trunk/Source/WebKit2/UIProcess/API/mac/WKView.mm

    r176684 r176753  
    248248    std::unique_ptr<ViewGestureController> _gestureController;
    249249    BOOL _allowsMagnification;
    250     BOOL _ignoresNonWheelMouseEvents;
     250    BOOL _ignoresNonWheelEvents;
     251    BOOL _ignoresAllEvents;
    251252    BOOL _allowsBackForwardNavigationGestures;
    252253
    … …  
    11051106// Events
    11061107
    1107 - (BOOL)_shouldIgnoreMouseEvents
    1108 {
    1109     // FIXME: This check is surprisingly specific. Are there any other cases where we need to block mouse events?
    1110     // Do we actually need to in thumbnail view? And if we do, what about non-mouse events?
    1111 #if WK_API_ENABLED
    1112     if (_data->_thumbnailView)
    1113         return YES;
    1114 #endif
    1115 
    1116     // -scrollWheel: uses -_shouldIgnoreWheelEvents, so for all other event types it is correct to use this.
    1117     return _data->_ignoresNonWheelMouseEvents;
    1118 }
    1119 
    1120 - (BOOL)_shouldIgnoreWheelEvents
    1121 {
    1122 #if WK_API_ENABLED
    1123     if (_data->_thumbnailView)
    1124         return YES;
    1125 #endif
    1126 
    1127     return NO;
    1128 }
    1129 
    11301108// Override this so that AppKit will send us arrow keys as key down events so we can
    11311109// support them via the key bindings mechanism.
    … …  
    11501128    - (void)Selector:(NSEvent *)theEvent \
    11511129    { \
    1152         if (self._shouldIgnoreMouseEvents) \
     1130        if (_data->_ignoresNonWheelEvents) \
    11531131            return; \
    11541132        if (NSTextInputContext *context = [self inputContext]) { \
    … …  
    11701148    - (void)Selector:(NSEvent *)theEvent \
    11711149    { \
    1172         if (self._shouldIgnoreMouseEvents) \
     1150        if (_data->_ignoresNonWheelEvents) \
    11731151            return; \
    11741152        if ([[self inputContext] handleEvent:theEvent]) { \
    … …  
    12071185- (void)scrollWheel:(NSEvent *)event
    12081186{
    1209     if ([self _shouldIgnoreWheelEvents])
     1187    if (_data->_ignoresAllEvents)
    12101188        return;
    12111189
    … …  
    12251203- (void)swipeWithEvent:(NSEvent *)event
    12261204{
    1227     if (self._shouldIgnoreMouseEvents)
     1205    if (_data->_ignoresNonWheelEvents)
    12281206        return;
    12291207
    … …  
    12431221- (void)mouseMoved:(NSEvent *)event
    12441222{
    1245     if (self._shouldIgnoreMouseEvents)
     1223    if (_data->_ignoresNonWheelEvents)
    12461224        return;
    12471225
    … …  
    12551233- (void)mouseDown:(NSEvent *)event
    12561234{
    1257     if (self._shouldIgnoreMouseEvents)
     1235    if (_data->_ignoresNonWheelEvents)
    12581236        return;
    12591237
    … …  
    12711249- (void)mouseUp:(NSEvent *)event
    12721250{
    1273     if (self._shouldIgnoreMouseEvents)
     1251    if (_data->_ignoresNonWheelEvents)
    12741252        return;
    12751253
    … …  
    12801258- (void)mouseDragged:(NSEvent *)event
    12811259{
    1282     if (self._shouldIgnoreMouseEvents)
     1260    if (_data->_ignoresNonWheelEvents)
    12831261        return;
    12841262
    … …  
    21832161- (BOOL)performKeyEquivalent:(NSEvent *)event
    21842162{
     2163    if (_data->_ignoresNonWheelEvents)
     2164        return NO;
     2165
    21852166    // There's a chance that responding to this event will run a nested event loop, and
    21862167    // fetching a new event might release the old one. Retaining and then autoreleasing
    … …  
    22202201- (void)keyUp:(NSEvent *)theEvent
    22212202{
     2203    if (_data->_ignoresNonWheelEvents)
     2204        return;
     2205
    22222206    LOG(TextInput, "keyUp:%p %@", theEvent, theEvent);
    22232207    // We don't interpret the keyUp event, as this breaks key bindings (see <https://bugs.webkit.org/show_bug.cgi?id=130100>).
    … …  
    22272211- (void)keyDown:(NSEvent *)theEvent
    22282212{
     2213    if (_data->_ignoresNonWheelEvents)
     2214        return;
     2215
    22292216    LOG(TextInput, "keyDown:%p %@%s", theEvent, theEvent, (theEvent == _data->_keyDownEventBeingResent) ? " (re-sent)" : "");
    22302217
    … …  
    22622249- (void)flagsChanged:(NSEvent *)theEvent
    22632250{
     2251    if (_data->_ignoresNonWheelEvents)
     2252        return;
     2253
    22642254    LOG(TextInput, "flagsChanged:%p %@", theEvent, theEvent);
    22652255
    … …  
    28342824- (void)quickLookWithEvent:(NSEvent *)event
    28352825{
     2826    if (_data->_ignoresNonWheelEvents)
     2827        return;
     2828
    28362829    NSPoint locationInViewCoordinates = [self convertPoint:[event locationInWindow] fromView:nil];
    28372830    _data->_page->performDictionaryLookupAtLocation(FloatPoint(locationInViewCoordinates.x, locationInViewCoordinates.y));
    … …  
    36993692- (void)prepareForMenu:(NSMenu *)menu withEvent:(NSEvent *)event
    37003693{
     3694    if (_data->_ignoresNonWheelEvents) {
     3695        [menu cancelTracking];
     3696        return;
     3697    }
     3698
    37013699    [_data->_actionMenuController prepareForMenu:menu withEvent:event];
    37023700}
    … …  
    37043702- (void)willOpenMenu:(NSMenu *)menu withEvent:(NSEvent *)event
    37053703{
     3704    if (_data->_ignoresNonWheelEvents) {
     3705        [menu cancelTracking];
     3706        return;
     3707    }
     3708
    37063709    [_data->_actionMenuController willOpenMenu:menu withEvent:event];
    37073710}
    … …  
    37093712- (void)didCloseMenu:(NSMenu *)menu withEvent:(NSEvent *)event
    37103713{
     3714    if (_data->_ignoresNonWheelEvents) {
     3715        [menu cancelTracking];
     3716        return;
     3717    }
     3718
    37113719    [_data->_actionMenuController didCloseMenu:menu withEvent:event];
    37123720}
    … …  
    40114019}
    40124020
     4021- (void)_setIgnoresAllEvents:(BOOL)ignoresAllEvents
     4022{
     4023    _data->_ignoresAllEvents = ignoresAllEvents;
     4024    [self _setIgnoresNonWheelEvents:ignoresAllEvents];
     4025}
     4026
     4027// Forward _setIgnoresNonWheelMouseEvents to _setIgnoresNonWheelEvents to avoid breaking existing clients.
    40134028- (void)_setIgnoresNonWheelMouseEvents:(BOOL)ignoresNonWheelMouseEvents
    40144029{
    4015     _data->_ignoresNonWheelMouseEvents = ignoresNonWheelMouseEvents;
    4016 }
    4017 
    4018 - (BOOL)_ignoresNonWheelMouseEvents
    4019 {
    4020     return _data->_ignoresNonWheelMouseEvents;
     4030    [self _setIgnoresNonWheelEvents:ignoresNonWheelMouseEvents];
     4031}
     4032
     4033- (void)_setIgnoresNonWheelEvents:(BOOL)ignoresNonWheelEvents
     4034{
     4035    if (_data->_ignoresNonWheelEvents == ignoresNonWheelEvents)
     4036        return;
     4037
     4038    _data->_ignoresNonWheelEvents = ignoresNonWheelEvents;
     4039    _data->_page->setShouldDispatchFakeMouseMoveEvents(!ignoresNonWheelEvents);
     4040}
     4041
     4042- (BOOL)_ignoresNonWheelEvents
     4043{
     4044    return _data->_ignoresNonWheelEvents;
     4045}
     4046
     4047- (BOOL)_ignoresAllEvents
     4048{
     4049    return _data->_ignoresAllEvents;
    40214050}
    40224051

  • trunk/Source/WebKit2/UIProcess/API/mac/WKViewInternal.h

    r176462 r176753  
    111111- (BOOL)_suppressVisibilityUpdates;
    112112
    113 - (BOOL)_shouldIgnoreMouseEvents;
    114 
    115113- (void)_didFirstVisuallyNonEmptyLayoutForMainFrame;
    116114- (void)_didFinishLoadForMainFrame;

  • trunk/Source/WebKit2/UIProcess/WebPageProxy.cpp

    r176530 r176753  
    53435343#endif
    53445344
     5345void WebPageProxy::setShouldDispatchFakeMouseMoveEvents(bool shouldDispatchFakeMouseMoveEvents)
     5346{
     5347    m_process->send(Messages::WebPage::SetShouldDispatchFakeMouseMoveEvents(shouldDispatchFakeMouseMoveEvents), m_pageID);
     5348}
     5349
    53455350} // namespace WebKit

  • trunk/Source/WebKit2/UIProcess/WebPageProxy.h

    r176530 r176753  
    948948    void getGuessesForWord(const String& word, const String& context, Vector<String>& guesses);
    949949
     950    void setShouldDispatchFakeMouseMoveEvents(bool);
     951
    950952private:
    951953    WebPageProxy(PageClient&, WebProcessProxy&, uint64_t pageID, const WebPageConfiguration&);

  • trunk/Source/WebKit2/UIProcess/mac/WKActionMenuController.mm

    r176707 r176753  
    148148    if (!_previewView) {
    149149        RetainPtr<WKWebView> webView = adoptNS([[WKWebView alloc] initWithFrame:defaultFrame]);
    150         [webView _setIgnoresNonWheelMouseEvents:YES];
     150        [webView _setIgnoresNonWheelEvents:YES];
    151151        if (_url) {
    152152            NSURLRequest *request = [NSURLRequest requestWithURL:_url.get()];
    … …  
    253253    if (menu != _wkView.actionMenu)
    254254        return;
    255 
    256     if (_wkView._shouldIgnoreMouseEvents) {
    257         [menu cancelTracking];
    258         return;
    259     }
    260255
    261256    [self dismissActionMenuPopovers];

  • trunk/Source/WebKit2/WebProcess/WebCoreSupport/WebChromeClient.cpp

    r176670 r176753  
    10811081    return (isTextOnly && WebProcess::shared().hasSelectionServices()) || WebProcess::shared().hasRichContentServices();
    10821082}
    1083 
    1084 #endif
     1083#endif
     1084
     1085bool WebChromeClient::shouldDispatchFakeMouseMoveEvents() const
     1086{
     1087    return m_page->shouldDispatchFakeMouseMoveEvents();
     1088}
    10851089
    10861090} // namespace WebKit

  • trunk/Source/WebKit2/WebProcess/WebCoreSupport/WebChromeClient.h

    r176670 r176753  
    310310#endif
    311311
     312    virtual bool shouldDispatchFakeMouseMoveEvents() const override;
     313
    312314    String m_cachedToolTip;
    313315    mutable RefPtr<WebFrame> m_cachedFrameSetLargestFrame;

  • trunk/Source/WebKit2/WebProcess/WebPage/WebPage.cpp

    r176728 r176753  
    335335#endif
    336336    , m_mainFrameProgressCompleted(false)
     337    , m_shouldDispatchFakeMouseMoveEvents(true)
    337338{
    338339    ASSERT(m_pageID);

  • trunk/Source/WebKit2/WebProcess/WebPage/WebPage.h

    r176687 r176753  
    862862
    863863    void setMainFrameProgressCompleted(bool completed) { m_mainFrameProgressCompleted = completed; }
     864    bool shouldDispatchFakeMouseMoveEvents() const { return m_shouldDispatchFakeMouseMoveEvents; }
     865
    864866private:
    865867    WebPage(uint64_t pageID, const WebPageCreationParameters&);
    … …  
    10821084    void dataDetectorsDidHideUI(WebCore::PageOverlay::PageOverlayID);
    10831085#endif
     1086
     1087    void setShouldDispatchFakeMouseMoveEvents(bool dispatch) { m_shouldDispatchFakeMouseMoveEvents = dispatch; }
    10841088
    10851089    uint64_t m_pageID;
    … …  
    13271331
    13281332    bool m_mainFrameProgressCompleted;
     1333    bool m_shouldDispatchFakeMouseMoveEvents;
    13291334};
    13301335

  • trunk/Source/WebKit2/WebProcess/WebPage/WebPage.messages.in

    r176687 r176753  
    411411    DataDetectorsDidHideUI(WebCore::PageOverlay::PageOverlayID pageOverlay)
    412412#endif
     413
     414    SetShouldDispatchFakeMouseMoveEvents(bool shouldDispatchFakeMouseMoveEvents)
    413415}
Note: See TracChangeset for help on using the changeset viewer.