[SCM] WebKit Debian packaging branch, webkit-1.2, updated. upstream/1.1.90-6072-g9a69373
dbates at webkit.org
dbates at webkit.org
Wed Apr 7 23:30:15 UTC 2010
The following commit has been merged in the webkit-1.2 branch:
commit 03eecfa153e4c21cb6ffdfd4e562baf5d3e0efaa
Author: dbates at webkit.org <dbates at webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Date: Wed Nov 11 02:52:23 2009 +0000
2009-11-10 Daniel Bates <dbates at webkit.org>
Reviewed by Oliver Hunt.
https://bugs.webkit.org/show_bug.cgi?id=30754
Patch 2 of 2.
Removed method EventHandler::dragSourceMovedTo, since it is no longer
needed. This method fired a drag event whenever the mouse moved, but
section 7.9.4 of the HTML 5 spec. defines the drag-and-drop processing
model independent of when the mouse moves. See "Among other changes..."
in the change log for patch 1 for more details.
* WebCore.DragSupport.exp:
* page/EventHandler.cpp: Removed method EventHandler::dragSourceMovedTo.
(WebCore::EventHandler::handleDrag): Updated comment about reentrancy issue.
* page/EventHandler.h:
2009-11-10 Daniel Bates <dbates at webkit.org>
Reviewed by Oliver Hunt.
https://bugs.webkit.org/show_bug.cgi?id=30754
Removed method draggedImage:movedTo:
* WebView/WebFrame.mm:
* WebView/WebFrameInternal.h:
* WebView/WebHTMLView.mm:
2009-11-10 Daniel Bates <dbates at webkit.org>
Reviewed by Oliver Hunt.
https://bugs.webkit.org/show_bug.cgi?id=30754
Modified WebDropSource::QueryContinueDrag so as to not call EventHandler::dragSourceMovedTo.
* WebDropSource.cpp:
(WebDropSource::QueryContinueDrag): Removed call to EventHandler::dragSourceMovedTo.
2009-11-10 Daniel Bates <dbates at webkit.org>
Reviewed by Oliver Hunt.
https://bugs.webkit.org/show_bug.cgi?id=30754
Patch 1 of 2.
As per Section 7.9.4 of the HTML 5 spec. <http://dev.w3.org/html5/spec/Overview.html#drag-and-drop-processing-model>,
the drag event should always fire before the dragover event.
In fixing this bug, this patch also makes our drag processing model
conform to the HTML 5 spec.
Among the changes, this patch ensures that the drag event isn't fired outside
of the drag-and-drop processing loop, WebCore::EventHandler::updateDragAndDrop.
Currently, the drag event is fired whenever the mouse button is down and the OS
detects the mouse moved. But, as per the spec, the drag event should
fire approx. every 350ms so long as the mouse button is down.
Test: fast/events/drag-and-drop-fire-drag-dragover.html
* page/EventHandler.cpp:
(WebCore::EventHandler::clear):
(WebCore::EventHandler::canHandleDragAndDropForTarget): Formerly named handleDragAndDropForTarget.
Modified to determine when we are in the correct instance of EventHandler to service the drag
and drop operation.
(WebCore::EventHandler::updateDragAndDrop): Moved code from WebCore::EventHandler::dragSourceMovedTo
into this method.
(WebCore::EventHandler::cancelDragAndDrop):
(WebCore::EventHandler::performDragAndDrop):
(WebCore::EventHandler::clearDragState):
* page/EventHandler.h: Added field m_shouldOnlyFireDragOverEvent to determine whether
we should fire both drag and dragover events or only the dragover event.
2009-11-10 Daniel Bates <dbates at webkit.org>
Reviewed by Oliver Hunt.
https://bugs.webkit.org/show_bug.cgi?id=30754
Tests that the drag event always fires before the dragover event.
Also, re-bases the result for test fast/events/drag-in-frames.html, since
we now conform to the HTML 5 spec.
* fast/events/drag-and-drop-fire-drag-dragover-expected.txt: Added.
* fast/events/drag-and-drop-fire-drag-dragover.html: Added.
* fast/events/drag-in-frames-expected.txt: Rebased result.
git-svn-id: http://svn.webkit.org/repository/webkit/trunk@50786 268f45cc-cd09-0410-ab3c-d52691b4dbfc
diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog
index 48c4b72..eb47484 100644
--- a/LayoutTests/ChangeLog
+++ b/LayoutTests/ChangeLog
@@ -1,3 +1,18 @@
+2009-11-10 Daniel Bates <dbates at webkit.org>
+
+ Reviewed by Oliver Hunt.
+
+ https://bugs.webkit.org/show_bug.cgi?id=30754
+
+ Tests that the drag event always fires before the dragover event.
+
+ Also, re-bases the result for test fast/events/drag-in-frames.html, since
+ we now conform to the HTML 5 spec.
+
+ * fast/events/drag-and-drop-fire-drag-dragover-expected.txt: Added.
+ * fast/events/drag-and-drop-fire-drag-dragover.html: Added.
+ * fast/events/drag-in-frames-expected.txt: Rebased result.
+
2009-11-10 Vitaly Repeshko <vitalyr at chromium.org>
Reviewed by Dimitri Glazkov.
diff --git a/LayoutTests/fast/events/drag-and-drop-fire-drag-dragover-expected.txt b/LayoutTests/fast/events/drag-and-drop-fire-drag-dragover-expected.txt
new file mode 100644
index 0000000..639f4c1
--- /dev/null
+++ b/LayoutTests/fast/events/drag-and-drop-fire-drag-dragover-expected.txt
@@ -0,0 +1,9 @@
+This test checks that the event handlers ondrag and ondragover fire in that order, as per http://www.whatwg.org/specs/web-apps/current-work/#current-drag-operation.
+
+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
+
+
+PASS drag fired before dragover.
+
+TEST COMPLETE
+
diff --git a/LayoutTests/fast/events/drag-and-drop-fire-drag-dragover.html b/LayoutTests/fast/events/drag-and-drop-fire-drag-dragover.html
new file mode 100644
index 0000000..8dfe33c
--- /dev/null
+++ b/LayoutTests/fast/events/drag-and-drop-fire-drag-dragover.html
@@ -0,0 +1,164 @@
+<html>
+<head>
+<link rel="stylesheet" href="../js/resources/js-test-style.css">
+<script src="../js/resources/js-test-pre.js"></script>
+<style>
+#dropTarget, #dragMe { text-align: center; display: table-cell; vertical-align: middle }
+#dropTarget {width: 256px; height: 256px; border: 1px dashed}
+#dragMe {-webkit-user-drag: element; -webkit-user-select: none; background: #ff0000; width: 64px; height: 64px; color: white}
+#console { height: 250px; overflow:scroll }
+</style>
+<script>
+ var dragMe;
+ var dropTarget;
+ var consoleElm;
+ var event;
+
+ var ALLOWED_EFFECTS = 'none';
+ var DROP_EFFECT = 'copy';
+
+ var lastDragOrDragOverEventFired = null;
+ var didDragEnterTarget = false;
+
+ var DRAG_EVENT = "drag";
+ var DRAGOVER_EVENT = "dragover";
+
+ window.onload = function()
+ {
+ dragMe = document.getElementById("dragMe");
+ dropTarget = document.getElementById("dropTarget");
+ consoleElm = document.getElementById("console");
+
+ if (!dragMe || !dropTarget || !consoleElm)
+ return;
+
+ dragMe.ondragstart = dragStart;
+ dragMe.ondragend = dragEnd;
+ dragMe.ondrag = dragOverWithRespectToSource;
+
+ dropTarget.ondragenter = dragEntered;
+ dropTarget.ondragleave = dragLeft;
+ dropTarget.ondragover = dragOver;
+ dropTarget.ondrop = drop;
+
+ runTest();
+ }
+
+ function dragStart(e)
+ {
+ event = e;
+ e.dataTransfer.effectAllowed = ALLOWED_EFFECTS;
+ e.dataTransfer.setData('Text', e.target.textContent);
+ }
+
+ function dragEnd(e)
+ {
+ return;
+ }
+
+ function dragEntered(e)
+ {
+ didDragEnterTarget = true;
+ dragEnteredAndUpdated(e);
+ }
+
+ function dragLeft(e)
+ {
+ didDragEnterTarget = false;
+ cancelDrag(e);
+ }
+
+ function dragOverWithRespectToSource(e)
+ {
+ checkDragState(e);
+ lastDragOrDragOverEventFired = DRAG_EVENT;
+ cancelDrag(e);
+ }
+
+ function dragOver(e)
+ {
+ checkDragState(e);
+ lastDragOrDragOverEventFired = DRAGOVER_EVENT;
+ dragEnteredAndUpdated(e);
+ }
+
+ function dragEnteredAndUpdated(e)
+ {
+ event = e;
+ e.dataTransfer.dropEffect = DROP_EFFECT;
+ cancelDrag(e);
+ }
+
+ function drop(e)
+ {
+ cancelDrag(e);
+ }
+
+ function cancelDrag(e)
+ {
+ if (e.preventDefault)
+ e.preventDefault();
+ else {
+ // Assume this script is executing within Internet Explorer
+ e.returnValue = false;
+ }
+ }
+
+ function checkDragState(e)
+ {
+ event = e;
+ if (didDragEnterTarget && e.type == "drag" && lastDragOrDragOverEventFired == DRAG_EVENT)
+ testFailed('dragover should have fired after drag. Instead, drag fired again.');
+ else if (e.type == "dragover") {
+ if (lastDragOrDragOverEventFired == DRAG_EVENT)
+ testPassed('drag fired before dragover.');
+ else
+ testFailed('drag should have fired before dragover. Instead, dragover fired first.');
+ }
+ }
+
+ function runTest()
+ {
+ if (!window.eventSender)
+ return;
+
+ if (window.layoutTestController)
+ layoutTestController.dumpAsText();
+
+ var startX = dragMe.offsetLeft + 10;
+ var startY = dragMe.offsetTop + dragMe.offsetHeight / 2;
+ var endX = dropTarget.offsetLeft + 10;
+ var endY = dropTarget.offsetTop + dropTarget.offsetHeight / 2;
+
+ eventSender.mouseMoveTo(startX, startY);
+ eventSender.mouseDown();
+ eventSender.leapForward(100);
+ eventSender.mouseMoveTo(endX, endY);
+ eventSender.mouseUp();
+
+ var testContainer = document.getElementById("test-container");
+ if (testContainer)
+ document.body.removeChild(testContainer);
+ debug('<br /><span class="pass">TEST COMPLETE</span>');
+ }
+</script>
+</head>
+<body>
+ <p id="description"></p>
+ <div id="test-container">
+ <label for="effectAllowed">effectAllowed:</label> <code><script>document.write(ALLOWED_EFFECTS)</script></code>
+ <br/><br/>
+ <div id="dropTarget">Drop the red square onto me.</div>
+ <hr/>
+ <p>Items that can be dragged to the drop target:</p>
+ <div id="dragMe" draggable="true">Square</div>
+ <hr/>
+ </div>
+ <div id="console"></div>
+ <script>
+ description("This test checks that the event handlers ondrag and ondragover fire in that order, " +
+ "as per http://www.whatwg.org/specs/web-apps/current-work/#current-drag-operation.");
+ var successfullyParsed = true;
+ </script>
+</body>
+</html>
diff --git a/LayoutTests/fast/events/drag-in-frames-expected.txt b/LayoutTests/fast/events/drag-in-frames-expected.txt
index c729c63..fb9ca40 100644
--- a/LayoutTests/fast/events/drag-in-frames-expected.txt
+++ b/LayoutTests/fast/events/drag-in-frames-expected.txt
@@ -1,16 +1,16 @@
Event log
ondragstart src
-ondragenter left target
ondrag src
+ondragenter left target
ondragover left target
ondrag src
ondragover left target
ondrag src
ondragenter right target
ondragleave left target
-ondrag src
ondragover right target
+ondrag src
ondragover right target
ondrop right target
ondragend src
diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog
index 82466be..3cc0dc5 100644
--- a/WebCore/ChangeLog
+++ b/WebCore/ChangeLog
@@ -1,3 +1,57 @@
+2009-11-10 Daniel Bates <dbates at webkit.org>
+
+ Reviewed by Oliver Hunt.
+
+ https://bugs.webkit.org/show_bug.cgi?id=30754
+
+ Patch 2 of 2.
+
+ Removed method EventHandler::dragSourceMovedTo, since it is no longer
+ needed. This method fired a drag event whenever the mouse moved, but
+ section 7.9.4 of the HTML 5 spec. defines the drag-and-drop processing
+ model independent of when the mouse moves. See "Among other changes..."
+ in the change log for patch 1 for more details.
+
+ * WebCore.DragSupport.exp:
+ * page/EventHandler.cpp: Removed method EventHandler::dragSourceMovedTo.
+ (WebCore::EventHandler::handleDrag): Updated comment about reentrancy issue.
+ * page/EventHandler.h:
+
+2009-11-10 Daniel Bates <dbates at webkit.org>
+
+ Reviewed by Oliver Hunt.
+
+ https://bugs.webkit.org/show_bug.cgi?id=30754
+
+ Patch 1 of 2.
+
+ As per Section 7.9.4 of the HTML 5 spec. <http://dev.w3.org/html5/spec/Overview.html#drag-and-drop-processing-model>,
+ the drag event should always fire before the dragover event.
+
+ In fixing this bug, this patch also makes our drag processing model
+ conform to the HTML 5 spec.
+
+ Among the changes, this patch ensures that the drag event isn't fired outside
+ of the drag-and-drop processing loop, WebCore::EventHandler::updateDragAndDrop.
+ Currently, the drag event is fired whenever the mouse button is down and the OS
+ detects the mouse moved. But, as per the spec, the drag event should
+ fire approx. every 350ms so long as the mouse button is down.
+
+ Test: fast/events/drag-and-drop-fire-drag-dragover.html
+
+ * page/EventHandler.cpp:
+ (WebCore::EventHandler::clear):
+ (WebCore::EventHandler::canHandleDragAndDropForTarget): Formerly named handleDragAndDropForTarget.
+ Modified to determine when we are in the correct instance of EventHandler to service the drag
+ and drop operation.
+ (WebCore::EventHandler::updateDragAndDrop): Moved code from WebCore::EventHandler::dragSourceMovedTo
+ into this method.
+ (WebCore::EventHandler::cancelDragAndDrop):
+ (WebCore::EventHandler::performDragAndDrop):
+ (WebCore::EventHandler::clearDragState):
+ * page/EventHandler.h: Added field m_shouldOnlyFireDragOverEvent to determine whether
+ we should fire both drag and dragover events or only the dragover event.
+
2009-11-10 Vitaly Repeshko <vitalyr at chromium.org>
Reviewed by Dimitri Glazkov.
diff --git a/WebCore/WebCore.DragSupport.exp b/WebCore/WebCore.DragSupport.exp
index 2cfd076..30786ba 100644
--- a/WebCore/WebCore.DragSupport.exp
+++ b/WebCore/WebCore.DragSupport.exp
@@ -1,5 +1,4 @@
__ZN7WebCore12EventHandler17dragSourceEndedAtERKNS_18PlatformMouseEventENS_13DragOperationE
-__ZN7WebCore12EventHandler17dragSourceMovedToERKNS_18PlatformMouseEventE
__ZN7WebCore12EventHandler17eventMayStartDragEP7NSEvent
__ZN7WebCore14DragController10dragExitedEPNS_8DragDataE
__ZN7WebCore14DragController11dragEnteredEPNS_8DragDataE
diff --git a/WebCore/page/EventHandler.cpp b/WebCore/page/EventHandler.cpp
index bda55a9..3ab2c69 100644
--- a/WebCore/page/EventHandler.cpp
+++ b/WebCore/page/EventHandler.cpp
@@ -201,6 +201,7 @@ void EventHandler::clear()
m_frameSetBeingResized = 0;
#if ENABLE(DRAG_SUPPORT)
m_dragTarget = 0;
+ m_shouldOnlyFireDragOverEvent = false;
#endif
m_currentMousePosition = IntPoint();
m_mousePressNode = 0;
@@ -1508,29 +1509,33 @@ bool EventHandler::dispatchDragEvent(const AtomicString& eventType, Node* dragTa
return me->defaultPrevented();
}
-bool EventHandler::handleDragAndDropForTarget(DragAndDropHandleType type, Node* target, const AtomicString& eventType, const PlatformMouseEvent& event, Clipboard* clipboard)
+bool EventHandler::canHandleDragAndDropForTarget(DragAndDropHandleType type, Node* target, const PlatformMouseEvent& event, Clipboard* clipboard, bool* accepted)
{
- bool accept = false;
+ bool canHandle = false;
+ bool wasAccepted = false;
if (target->hasTagName(frameTag) || target->hasTagName(iframeTag)) {
Frame* frame = static_cast<HTMLFrameElementBase*>(target)->contentFrame();
if (frame) {
switch (type) {
case UpdateDragAndDrop:
- accept = frame->eventHandler()->updateDragAndDrop(event, clipboard);
+ wasAccepted = frame->eventHandler()->updateDragAndDrop(event, clipboard);
break;
case CancelDragAndDrop:
frame->eventHandler()->cancelDragAndDrop(event, clipboard);
break;
case PerformDragAndDrop:
- accept = frame->eventHandler()->performDragAndDrop(event, clipboard);
+ wasAccepted = frame->eventHandler()->performDragAndDrop(event, clipboard);
break;
}
}
} else
- accept = dispatchDragEvent(eventType, target, event, clipboard);
+ canHandle = true;
- return accept;
+ if (accepted)
+ *accepted = wasAccepted;
+
+ return canHandle;
}
bool EventHandler::updateDragAndDrop(const PlatformMouseEvent& event, Clipboard* clipboard)
@@ -1554,14 +1559,35 @@ bool EventHandler::updateDragAndDrop(const PlatformMouseEvent& event, Clipboard*
// FIXME: this ordering was explicitly chosen to match WinIE. However,
// it is sometimes incorrect when dragging within subframes, as seen with
// LayoutTests/fast/events/drag-in-frames.html.
- if (newTarget)
- accept = handleDragAndDropForTarget(UpdateDragAndDrop, newTarget, eventNames().dragenterEvent, event, clipboard);
+ //
+ // Moreover, this ordering conforms to section 7.9.4 of the HTML 5 spec. <http://dev.w3.org/html5/spec/Overview.html#drag-and-drop-processing-model>.
+ if (newTarget && canHandleDragAndDropForTarget(UpdateDragAndDrop, newTarget, event, clipboard, &accept)) {
+ // As per section 7.9.4 of the HTML 5 spec., we must always fire a drag event before firing a dragenter, dragleave, or dragover event.
+ if (dragState().m_dragSrc && dragState().m_dragSrcMayBeDHTML) {
+ // for now we don't care if event handler cancels default behavior, since there is none
+ dispatchDragSrcEvent(eventNames().dragEvent, event);
+ }
+ accept = dispatchDragEvent(eventNames().dragenterEvent, newTarget, event, clipboard);
+ }
- if (m_dragTarget)
- handleDragAndDropForTarget(UpdateDragAndDrop, m_dragTarget.get(), eventNames().dragleaveEvent, event, clipboard);
+ if (m_dragTarget && canHandleDragAndDropForTarget(UpdateDragAndDrop, m_dragTarget.get(), event, clipboard, &accept))
+ dispatchDragEvent(eventNames().dragleaveEvent, m_dragTarget.get(), event, clipboard);
+
+ if (newTarget) {
+ // We do not explicitly call dispatchDragEvent here because it could ultimately result in the appearance that
+ // two dragover events fired. So, we mark that we should only fire a dragover event on the next call to this function.
+ m_shouldOnlyFireDragOverEvent = true;
+ }
} else {
- if (newTarget)
- accept = handleDragAndDropForTarget(UpdateDragAndDrop, newTarget, eventNames().dragoverEvent, event, clipboard);
+ if (newTarget && canHandleDragAndDropForTarget(UpdateDragAndDrop, newTarget, event, clipboard, &accept)) {
+ // Note, when dealing with sub-frames, we may need to fire only a dragover event as a drag event may have been fired earlier.
+ if (!m_shouldOnlyFireDragOverEvent && dragState().m_dragSrc && dragState().m_dragSrcMayBeDHTML) {
+ // for now we don't care if event handler cancels default behavior, since there is none
+ dispatchDragSrcEvent(eventNames().dragEvent, event);
+ }
+ accept = dispatchDragEvent(eventNames().dragoverEvent, newTarget, event, clipboard);
+ m_shouldOnlyFireDragOverEvent = false;
+ }
}
m_dragTarget = newTarget;
@@ -1570,16 +1596,19 @@ bool EventHandler::updateDragAndDrop(const PlatformMouseEvent& event, Clipboard*
void EventHandler::cancelDragAndDrop(const PlatformMouseEvent& event, Clipboard* clipboard)
{
- if (m_dragTarget)
- handleDragAndDropForTarget(CancelDragAndDrop, m_dragTarget.get(), eventNames().dragleaveEvent, event, clipboard);
+ if (m_dragTarget && canHandleDragAndDropForTarget(CancelDragAndDrop, m_dragTarget.get(), event, clipboard)) {
+ if (dragState().m_dragSrc && dragState().m_dragSrcMayBeDHTML)
+ dispatchDragSrcEvent(eventNames().dragEvent, event);
+ dispatchDragEvent(eventNames().dragleaveEvent, m_dragTarget.get(), event, clipboard);
+ }
clearDragState();
}
bool EventHandler::performDragAndDrop(const PlatformMouseEvent& event, Clipboard* clipboard)
{
bool accept = false;
- if (m_dragTarget)
- accept = handleDragAndDropForTarget(PerformDragAndDrop, m_dragTarget.get(), eventNames().dropEvent, event, clipboard);
+ if (m_dragTarget && canHandleDragAndDropForTarget(PerformDragAndDrop, m_dragTarget.get(), event, clipboard, &accept))
+ dispatchDragEvent(eventNames().dropEvent, m_dragTarget.get(), event, clipboard);
clearDragState();
return accept;
}
@@ -1588,6 +1617,7 @@ void EventHandler::clearDragState()
{
m_dragTarget = 0;
m_capturingMouseEventsNode = 0;
+ m_shouldOnlyFireDragOverEvent = false;
#if PLATFORM(MAC)
m_sendingEventToSubview = false;
#endif
@@ -2184,14 +2214,7 @@ bool EventHandler::shouldDragAutoNode(Node* node, const IntPoint& point) const
Page* page = m_frame->page();
return page && page->dragController()->mayStartDragAtEventLocation(m_frame, point);
}
-
-void EventHandler::dragSourceMovedTo(const PlatformMouseEvent& event)
-{
- if (dragState().m_dragSrc && dragState().m_dragSrcMayBeDHTML)
- // for now we don't care if event handler cancels default behavior, since there is none
- dispatchDragSrcEvent(eventNames().dragEvent, event);
-}
-
+
void EventHandler::dragSourceEndedAt(const PlatformMouseEvent& event, DragOperation operation)
{
if (dragState().m_dragSrc && dragState().m_dragSrcMayBeDHTML) {
@@ -2317,9 +2340,10 @@ bool EventHandler::handleDrag(const MouseEventWithHitTestResults& event)
// gather values from DHTML element, if it set any
dragState().m_dragClipboard->sourceOperation(srcOp);
- // Yuck, dragSourceMovedTo() can be called as a result of kicking off the drag with
- // dragImage! Because of that dumb reentrancy, we may think we've not started the
- // drag when that happens. So we have to assume it's started before we kick it off.
+ // Yuck, a draggedImage:moveTo: message can be fired as a result of kicking off the
+ // drag with dragImage! Because of that dumb reentrancy, we may think we've not
+ // started the drag when that happens. So we have to assume it's started before we
+ // kick it off.
dragState().m_dragClipboard->setDragHasStarted();
}
}
diff --git a/WebCore/page/EventHandler.h b/WebCore/page/EventHandler.h
index e756e0b..fe87a1a 100644
--- a/WebCore/page/EventHandler.h
+++ b/WebCore/page/EventHandler.h
@@ -159,7 +159,6 @@ public:
#if ENABLE(DRAG_SUPPORT)
bool eventMayStartDrag(const PlatformMouseEvent&) const;
- void dragSourceMovedTo(const PlatformMouseEvent&);
void dragSourceEndedAt(const PlatformMouseEvent&, DragOperation);
#endif
@@ -213,7 +212,7 @@ private:
static EventHandlerDragState& dragState();
static const double TextDragDelay;
- bool handleDragAndDropForTarget(DragAndDropHandleType, Node* target, const AtomicString& eventType, const PlatformMouseEvent&, Clipboard*);
+ bool canHandleDragAndDropForTarget(DragAndDropHandleType, Node* target, const PlatformMouseEvent&, Clipboard*, bool* accepted = 0);
PassRefPtr<Clipboard> createDraggingClipboard() const;
#endif // ENABLE(DRAG_SUPPORT)
@@ -376,6 +375,7 @@ private:
#if ENABLE(DRAG_SUPPORT)
RefPtr<Node> m_dragTarget;
+ bool m_shouldOnlyFireDragOverEvent;
#endif
RefPtr<HTMLFrameSetElement> m_frameSetBeingResized;
diff --git a/WebKit/mac/ChangeLog b/WebKit/mac/ChangeLog
index 57c8240..f447849 100644
--- a/WebKit/mac/ChangeLog
+++ b/WebKit/mac/ChangeLog
@@ -1,3 +1,15 @@
+2009-11-10 Daniel Bates <dbates at webkit.org>
+
+ Reviewed by Oliver Hunt.
+
+ https://bugs.webkit.org/show_bug.cgi?id=30754
+
+ Removed method draggedImage:movedTo:
+
+ * WebView/WebFrame.mm:
+ * WebView/WebFrameInternal.h:
+ * WebView/WebHTMLView.mm:
+
2009-11-10 Beth Dakin <bdakin at apple.com>
Reviewed by Darin Adler.
diff --git a/WebKit/mac/WebView/WebFrame.mm b/WebKit/mac/WebView/WebFrame.mm
index 94fe997..6715d45 100644
--- a/WebKit/mac/WebView/WebFrame.mm
+++ b/WebKit/mac/WebView/WebFrame.mm
@@ -923,20 +923,6 @@ static inline WebDataSource *dataSource(DocumentLoader* loader)
_private->coreFrame->computeAndSetTypingStyle(core(style), undoAction);
}
-- (void)_dragSourceMovedTo:(NSPoint)windowLoc
-{
- if (!_private->coreFrame)
- return;
- FrameView* view = _private->coreFrame->view();
- if (!view)
- return;
- ASSERT([getWebView(self) _usesDocumentViews]);
- // FIXME: These are fake modifier keys here, but they should be real ones instead.
- PlatformMouseEvent event(IntPoint(windowLoc), globalPoint(windowLoc, [view->platformWidget() window]),
- LeftButton, MouseEventMoved, 0, false, false, false, false, currentTime());
- _private->coreFrame->eventHandler()->dragSourceMovedTo(event);
-}
-
- (void)_dragSourceEndedAt:(NSPoint)windowLoc operation:(NSDragOperation)operation
{
if (!_private->coreFrame)
diff --git a/WebKit/mac/WebView/WebFrameInternal.h b/WebKit/mac/WebView/WebFrameInternal.h
index 10a3015..0dcf19b 100644
--- a/WebKit/mac/WebView/WebFrameInternal.h
+++ b/WebKit/mac/WebView/WebFrameInternal.h
@@ -155,7 +155,6 @@ WebView *getWebView(WebFrame *webFrame);
- (DOMCSSStyleDeclaration *)_typingStyle;
- (void)_setTypingStyle:(DOMCSSStyleDeclaration *)style withUndoAction:(WebCore::EditAction)undoAction;
-- (void)_dragSourceMovedTo:(NSPoint)windowLoc;
- (void)_dragSourceEndedAt:(NSPoint)windowLoc operation:(NSDragOperation)operation;
- (BOOL)_canProvideDocumentSource;
diff --git a/WebKit/mac/WebView/WebHTMLView.mm b/WebKit/mac/WebView/WebHTMLView.mm
index 172463f..7c8c4db 100644
--- a/WebKit/mac/WebView/WebHTMLView.mm
+++ b/WebKit/mac/WebView/WebHTMLView.mm
@@ -3444,21 +3444,6 @@ done:
return (NSDragOperation)page->dragController()->sourceDragOperation();
}
-- (void)draggedImage:(NSImage *)image movedTo:(NSPoint)screenLoc
-{
- ASSERT(![self _webView] || [self _isTopHTMLView]);
-
- NSPoint windowImageLoc = [[self window] convertScreenToBase:screenLoc];
- NSPoint windowMouseLoc = windowImageLoc;
-
- if (Page* page = core([self _webView])) {
- DragController* dragController = page->dragController();
- NSPoint windowMouseLoc = NSMakePoint(windowImageLoc.x + dragController->dragOffset().x(), windowImageLoc.y + dragController->dragOffset().y());
- }
-
- [[self _frame] _dragSourceMovedTo:windowMouseLoc];
-}
-
- (void)draggedImage:(NSImage *)anImage endedAt:(NSPoint)aPoint operation:(NSDragOperation)operation
{
ASSERT(![self _webView] || [self _isTopHTMLView]);
diff --git a/WebKit/win/ChangeLog b/WebKit/win/ChangeLog
index d1034b7..173292e 100644
--- a/WebKit/win/ChangeLog
+++ b/WebKit/win/ChangeLog
@@ -1,3 +1,14 @@
+2009-11-10 Daniel Bates <dbates at webkit.org>
+
+ Reviewed by Oliver Hunt.
+
+ https://bugs.webkit.org/show_bug.cgi?id=30754
+
+ Modified WebDropSource::QueryContinueDrag so as to not call EventHandler::dragSourceMovedTo.
+
+ * WebDropSource.cpp:
+ (WebDropSource::QueryContinueDrag): Removed call to EventHandler::dragSourceMovedTo.
+
2009-11-10 Alexey Proskuryakov <ap at apple.com>
Reviewed by Dan Bernstein.
diff --git a/WebKit/win/WebDropSource.cpp b/WebKit/win/WebDropSource.cpp
index 5c26b37..294c337 100644
--- a/WebKit/win/WebDropSource.cpp
+++ b/WebKit/win/WebDropSource.cpp
@@ -107,9 +107,7 @@ STDMETHODIMP WebDropSource::QueryContinueDrag(BOOL fEscapePressed, DWORD grfKeyS
if (fEscapePressed || !(grfKeyState & (MK_LBUTTON|MK_RBUTTON))) {
m_dropped = !fEscapePressed;
return fEscapePressed? DRAGDROP_S_CANCEL : DRAGDROP_S_DROP;
- } else if (Page* page = m_webView->page())
- if (Frame* frame = page->mainFrame())
- frame->eventHandler()->dragSourceMovedTo(generateMouseEvent(m_webView.get(), true));
+ }
return S_OK;
}
--
WebKit Debian packaging
More information about the Pkg-webkit-commits
mailing list