Merge in WebKit r47029.

1 files changed, 107 insertions, 90 deletions

diff --git a/WebCore/dom/Node.cpp b/WebCore/dom/Node.cpp
index 5fbebb9..c475958 100644
--- a/WebCore/dom/Node.cpp
+++ b/WebCore/dom/Node.cpp
@@ -287,7 +287,7 @@ void Node::stopIgnoringLeaks()
 #endif
 }
 
-Node::StyleChange Node::diff( RenderStyle *s1, RenderStyle *s2 )
+Node::StyleChange Node::diff(const RenderStyle* s1, const RenderStyle* s2)
 {
     // FIXME: The behavior of this function is just totally wrong.  It doesn't handle
     // explicit inheritance of non-inherited properties and so you end up not re-resolving
@@ -307,6 +307,12 @@ Node::StyleChange Node::diff( RenderStyle *s1, RenderStyle *s2 )
     else if (s1->inheritedNotEqual(s2))
         ch = Inherit;
     
+    // For nth-child and other positional rules, treat styles as different if they have
+    // changed positionally in the DOM. This way subsequent sibling resolutions won't be confused
+    // by the wrong child index and evaluate to incorrect results.
+    if (ch == NoChange && s1->childIndex() != s2->childIndex())
+        ch = NoInherit;
+
     // If the pseudoStyles have changed, we want any StyleChange that is not NoChange
     // because setStyle will do the right thing with anything else.
     if (ch == NoChange && s1->hasPseudoStyle(BEFORE)) {
@@ -494,7 +500,7 @@ void Node::setTabIndexExplicitly(short i)
 
 String Node::nodeValue() const
 {
-  return String();
+    return String();
 }
 
 void Node::setNodeValue(const String& /*nodeValue*/, ExceptionCode& ec)
@@ -516,7 +522,7 @@ PassRefPtr<NodeList> Node::childNodes()
         document()->addNodeListCache();
     }
 
-    return ChildNodeList::create(this, &data->nodeLists()->m_childNodeListCaches);
+    return ChildNodeList::create(this, data->nodeLists()->m_childNodeListCaches.get());
 }
 
 Node *Node::lastDescendant() const
@@ -776,7 +782,7 @@ unsigned Node::nodeIndex() const
 {
     Node *_tempNode = previousSibling();
     unsigned count=0;
-    for( count=0; _tempNode; count++ )
+    for ( count=0; _tempNode; count++ )
         _tempNode = _tempNode->previousSibling();
     return count;
 }
@@ -1358,6 +1364,14 @@ bool Node::canStartSelection() const
 {
     if (isContentEditable())
         return true;
+
+    if (renderer()) {
+        RenderStyle* style = renderer()->style();
+        // We allow selections to begin within an element that has -webkit-user-select: none set,
+        // but if the element is draggable then dragging should take priority over selection.
+        if (style->userDrag() == DRAG_ELEMENT && style->userSelect() == SELECT_NONE)
+            return false;
+    }
     return parent() ? parent()->canStartSelection() : true;
 }
 
@@ -1491,9 +1505,9 @@ PassRefPtr<NodeList> Node::getElementsByTagNameNS(const AtomicString& namespaceU
         
     pair<NodeListsNodeData::TagCacheMap::iterator, bool> result = data->nodeLists()->m_tagNodeListCaches.add(QualifiedName(nullAtom, localNameAtom, namespaceURI), 0);
     if (result.second)
-        result.first->second = new DynamicNodeList::Caches;
+        result.first->second = DynamicNodeList::Caches::create();
     
-    return TagNodeList::create(this, namespaceURI.isEmpty() ? nullAtom : namespaceURI, localNameAtom, result.first->second);
+    return TagNodeList::create(this, namespaceURI.isEmpty() ? nullAtom : namespaceURI, localNameAtom, result.first->second.get());
 }
 
 PassRefPtr<NodeList> Node::getElementsByName(const String& elementName)
@@ -1506,9 +1520,9 @@ PassRefPtr<NodeList> Node::getElementsByName(const String& elementName)
 
     pair<NodeListsNodeData::CacheMap::iterator, bool> result = data->nodeLists()->m_nameNodeListCaches.add(elementName, 0);
     if (result.second)
-        result.first->second = new DynamicNodeList::Caches;
+        result.first->second = DynamicNodeList::Caches::create();
     
-    return NameNodeList::create(this, elementName, result.first->second);
+    return NameNodeList::create(this, elementName, result.first->second.get());
 }
 
 PassRefPtr<NodeList> Node::getElementsByClassName(const String& classNames)
@@ -1521,9 +1535,9 @@ PassRefPtr<NodeList> Node::getElementsByClassName(const String& classNames)
 
     pair<NodeListsNodeData::CacheMap::iterator, bool> result = data->nodeLists()->m_classNodeListCaches.add(classNames, 0);
     if (result.second)
-        result.first->second = new DynamicNodeList::Caches;
+        result.first->second = DynamicNodeList::Caches::create();
     
-    return ClassNodeList::create(this, classNames, result.first->second);
+    return ClassNodeList::create(this, classNames, result.first->second.get());
 }
 
 template <typename Functor>
@@ -2212,7 +2226,7 @@ void Node::formatForDebugger(char* buffer, unsigned length) const
 
 void NodeListsNodeData::invalidateCaches()
 {
-    m_childNodeListCaches.reset();
+    m_childNodeListCaches->reset();
     TagCacheMap::const_iterator tagCachesEnd = m_tagNodeListCaches.end();
     for (TagCacheMap::const_iterator it = m_tagNodeListCaches.begin(); it != tagCachesEnd; ++it)
         it->second->reset();
@@ -2235,24 +2249,24 @@ bool NodeListsNodeData::isEmpty() const
     if (!m_listsWithCaches.isEmpty())
         return false;
 
-    if (m_childNodeListCaches.refCount)
+    if (m_childNodeListCaches->refCount())
         return false;
     
     TagCacheMap::const_iterator tagCachesEnd = m_tagNodeListCaches.end();
     for (TagCacheMap::const_iterator it = m_tagNodeListCaches.begin(); it != tagCachesEnd; ++it) {
-        if (it->second->refCount)
+        if (it->second->refCount())
             return false;
     }
 
     CacheMap::const_iterator classCachesEnd = m_classNodeListCaches.end();
     for (CacheMap::const_iterator it = m_classNodeListCaches.begin(); it != classCachesEnd; ++it) {
-        if (it->second->refCount)
+        if (it->second->refCount())
             return false;
     }
 
     CacheMap::const_iterator nameCachesEnd = m_nameNodeListCaches.end();
     for (CacheMap::const_iterator it = m_nameNodeListCaches.begin(); it != nameCachesEnd; ++it) {
-        if (it->second->refCount)
+        if (it->second->refCount())
             return false;
     }
 
@@ -2559,7 +2573,7 @@ bool Node::dispatchGenericEvent(PassRefPtr<Event> prpEvent)
     event->setEventPhase(Event::CAPTURING_PHASE);
 
     if (targetForWindowEvents) {
-        event->setCurrentTarget(targetForWindowEvents->document()); // FIXME: targetForWindowEvents should be the event target.
+        event->setCurrentTarget(targetForWindowEvents);
         targetForWindowEvents->handleEvent(event.get(), true);
         if (event->propagationStopped())
             goto doneDispatching;
@@ -2597,7 +2611,7 @@ bool Node::dispatchGenericEvent(PassRefPtr<Event> prpEvent)
                 goto doneDispatching;
         }
         if (targetForWindowEvents) {
-            event->setCurrentTarget(targetForWindowEvents->document()); // FIXME: targetForWindowEvents should be the event target.
+            event->setCurrentTarget(targetForWindowEvents);
             targetForWindowEvents->handleEvent(event.get(), false);
             if (event->propagationStopped() || event->cancelBubble())
                 goto doneDispatching;
@@ -2700,7 +2714,7 @@ bool Node::dispatchMouseEvent(const PlatformMouseEvent& event, const AtomicStrin
     return dispatchMouseEvent(eventType, button, detail,
         contentsPos.x(), contentsPos.y(), event.globalX(), event.globalY(),
         event.ctrlKey(), event.altKey(), event.shiftKey(), event.metaKey(),
-        false, relatedTarget);
+        false, relatedTarget, 0);
 }
 
 void Node::dispatchSimulatedMouseEvent(const AtomicString& eventType,
@@ -3164,184 +3178,184 @@ void Node::setOnmousewheel(PassRefPtr<EventListener> eventListener)
     setAttributeEventListener(eventNames().mousewheelEvent, eventListener);
 }
 
-EventListener* Node::onbeforecut() const
+EventListener* Node::ondragenter() const
 {
-    return getAttributeEventListener(eventNames().beforecutEvent);
+    return getAttributeEventListener(eventNames().dragenterEvent);
 }
 
-void Node::setOnbeforecut(PassRefPtr<EventListener> eventListener)
+void Node::setOndragenter(PassRefPtr<EventListener> eventListener)
 {
-    setAttributeEventListener(eventNames().beforecutEvent, eventListener);
+    setAttributeEventListener(eventNames().dragenterEvent, eventListener);
 }
 
-EventListener* Node::oncut() const
+EventListener* Node::ondragover() const
 {
-    return getAttributeEventListener(eventNames().cutEvent);
+    return getAttributeEventListener(eventNames().dragoverEvent);
 }
 
-void Node::setOncut(PassRefPtr<EventListener> eventListener)
+void Node::setOndragover(PassRefPtr<EventListener> eventListener)
 {
-    setAttributeEventListener(eventNames().cutEvent, eventListener);
+    setAttributeEventListener(eventNames().dragoverEvent, eventListener);
 }
 
-EventListener* Node::onbeforecopy() const
+EventListener* Node::ondragleave() const
 {
-    return getAttributeEventListener(eventNames().beforecopyEvent);
+    return getAttributeEventListener(eventNames().dragleaveEvent);
 }
 
-void Node::setOnbeforecopy(PassRefPtr<EventListener> eventListener)
+void Node::setOndragleave(PassRefPtr<EventListener> eventListener)
 {
-    setAttributeEventListener(eventNames().beforecopyEvent, eventListener);
+    setAttributeEventListener(eventNames().dragleaveEvent, eventListener);
 }
 
-EventListener* Node::oncopy() const
+EventListener* Node::ondrop() const
 {
-    return getAttributeEventListener(eventNames().copyEvent);
+    return getAttributeEventListener(eventNames().dropEvent);
 }
 
-void Node::setOncopy(PassRefPtr<EventListener> eventListener)
+void Node::setOndrop(PassRefPtr<EventListener> eventListener)
 {
-    setAttributeEventListener(eventNames().copyEvent, eventListener);
+    setAttributeEventListener(eventNames().dropEvent, eventListener);
 }
 
-EventListener* Node::onbeforepaste() const
+EventListener* Node::ondragstart() const
 {
-    return getAttributeEventListener(eventNames().beforepasteEvent);
+    return getAttributeEventListener(eventNames().dragstartEvent);
 }
 
-void Node::setOnbeforepaste(PassRefPtr<EventListener> eventListener)
+void Node::setOndragstart(PassRefPtr<EventListener> eventListener)
 {
-    setAttributeEventListener(eventNames().beforepasteEvent, eventListener);
+    setAttributeEventListener(eventNames().dragstartEvent, eventListener);
 }
 
-EventListener* Node::onpaste() const
+EventListener* Node::ondrag() const
 {
-    return getAttributeEventListener(eventNames().pasteEvent);
+    return getAttributeEventListener(eventNames().dragEvent);
 }
 
-void Node::setOnpaste(PassRefPtr<EventListener> eventListener)
+void Node::setOndrag(PassRefPtr<EventListener> eventListener)
 {
-    setAttributeEventListener(eventNames().pasteEvent, eventListener);
+    setAttributeEventListener(eventNames().dragEvent, eventListener);
 }
 
-EventListener* Node::ondragenter() const
+EventListener* Node::ondragend() const
 {
-    return getAttributeEventListener(eventNames().dragenterEvent);
+    return getAttributeEventListener(eventNames().dragendEvent);
 }
 
-void Node::setOndragenter(PassRefPtr<EventListener> eventListener)
+void Node::setOndragend(PassRefPtr<EventListener> eventListener)
 {
-    setAttributeEventListener(eventNames().dragenterEvent, eventListener);
+    setAttributeEventListener(eventNames().dragendEvent, eventListener);
 }
 
-EventListener* Node::ondragover() const
+EventListener* Node::onscroll() const
 {
-    return getAttributeEventListener(eventNames().dragoverEvent);
+    return getAttributeEventListener(eventNames().scrollEvent);
 }
 
-void Node::setOndragover(PassRefPtr<EventListener> eventListener)
+void Node::setOnscroll(PassRefPtr<EventListener> eventListener)
 {
-    setAttributeEventListener(eventNames().dragoverEvent, eventListener);
+    setAttributeEventListener(eventNames().scrollEvent, eventListener);
 }
 
-EventListener* Node::ondragleave() const
+EventListener* Node::onselect() const
 {
-    return getAttributeEventListener(eventNames().dragleaveEvent);
+    return getAttributeEventListener(eventNames().selectEvent);
 }
 
-void Node::setOndragleave(PassRefPtr<EventListener> eventListener)
+void Node::setOnselect(PassRefPtr<EventListener> eventListener)
 {
-    setAttributeEventListener(eventNames().dragleaveEvent, eventListener);
+    setAttributeEventListener(eventNames().selectEvent, eventListener);
 }
 
-EventListener* Node::ondrop() const
+EventListener* Node::onsubmit() const
 {
-    return getAttributeEventListener(eventNames().dropEvent);
+    return getAttributeEventListener(eventNames().submitEvent);
 }
 
-void Node::setOndrop(PassRefPtr<EventListener> eventListener)
+void Node::setOnsubmit(PassRefPtr<EventListener> eventListener)
 {
-    setAttributeEventListener(eventNames().dropEvent, eventListener);
+    setAttributeEventListener(eventNames().submitEvent, eventListener);
 }
 
-EventListener* Node::ondragstart() const
+EventListener* Node::onbeforecut() const
 {
-    return getAttributeEventListener(eventNames().dragstartEvent);
+    return getAttributeEventListener(eventNames().beforecutEvent);
 }
 
-void Node::setOndragstart(PassRefPtr<EventListener> eventListener)
+void Node::setOnbeforecut(PassRefPtr<EventListener> eventListener)
 {
-    setAttributeEventListener(eventNames().dragstartEvent, eventListener);
+    setAttributeEventListener(eventNames().beforecutEvent, eventListener);
 }
 
-EventListener* Node::ondrag() const
+EventListener* Node::oncut() const
 {
-    return getAttributeEventListener(eventNames().dragEvent);
+    return getAttributeEventListener(eventNames().cutEvent);
 }
 
-void Node::setOndrag(PassRefPtr<EventListener> eventListener)
+void Node::setOncut(PassRefPtr<EventListener> eventListener)
 {
-    setAttributeEventListener(eventNames().dragEvent, eventListener);
+    setAttributeEventListener(eventNames().cutEvent, eventListener);
 }
 
-EventListener* Node::ondragend() const
+EventListener* Node::onbeforecopy() const
 {
-    return getAttributeEventListener(eventNames().dragendEvent);
+    return getAttributeEventListener(eventNames().beforecopyEvent);
 }
 
-void Node::setOndragend(PassRefPtr<EventListener> eventListener)
+void Node::setOnbeforecopy(PassRefPtr<EventListener> eventListener)
 {
-    setAttributeEventListener(eventNames().dragendEvent, eventListener);
+    setAttributeEventListener(eventNames().beforecopyEvent, eventListener);
 }
 
-EventListener* Node::onreset() const
+EventListener* Node::oncopy() const
 {
-    return getAttributeEventListener(eventNames().resetEvent);
+    return getAttributeEventListener(eventNames().copyEvent);
 }
 
-void Node::setOnreset(PassRefPtr<EventListener> eventListener)
+void Node::setOncopy(PassRefPtr<EventListener> eventListener)
 {
-    setAttributeEventListener(eventNames().resetEvent, eventListener);
+    setAttributeEventListener(eventNames().copyEvent, eventListener);
 }
 
-EventListener* Node::onresize() const
+EventListener* Node::onbeforepaste() const
 {
-    return getAttributeEventListener(eventNames().resizeEvent);
+    return getAttributeEventListener(eventNames().beforepasteEvent);
 }
 
-void Node::setOnresize(PassRefPtr<EventListener> eventListener)
+void Node::setOnbeforepaste(PassRefPtr<EventListener> eventListener)
 {
-    setAttributeEventListener(eventNames().resizeEvent, eventListener);
+    setAttributeEventListener(eventNames().beforepasteEvent, eventListener);
 }
 
-EventListener* Node::onscroll() const
+EventListener* Node::onpaste() const
 {
-    return getAttributeEventListener(eventNames().scrollEvent);
+    return getAttributeEventListener(eventNames().pasteEvent);
 }
 
-void Node::setOnscroll(PassRefPtr<EventListener> eventListener)
+void Node::setOnpaste(PassRefPtr<EventListener> eventListener)
 {
-    setAttributeEventListener(eventNames().scrollEvent, eventListener);
+    setAttributeEventListener(eventNames().pasteEvent, eventListener);
 }
 
-EventListener* Node::onsearch() const
+EventListener* Node::onreset() const
 {
-    return getAttributeEventListener(eventNames().searchEvent);
+    return getAttributeEventListener(eventNames().resetEvent);
 }
 
-void Node::setOnsearch(PassRefPtr<EventListener> eventListener)
+void Node::setOnreset(PassRefPtr<EventListener> eventListener)
 {
-    setAttributeEventListener(eventNames().searchEvent, eventListener);
+    setAttributeEventListener(eventNames().resetEvent, eventListener);
 }
 
-EventListener* Node::onselect() const
+EventListener* Node::onsearch() const
 {
-    return getAttributeEventListener(eventNames().selectEvent);
+    return getAttributeEventListener(eventNames().searchEvent);
 }
 
-void Node::setOnselect(PassRefPtr<EventListener> eventListener)
+void Node::setOnsearch(PassRefPtr<EventListener> eventListener)
 {
-    setAttributeEventListener(eventNames().selectEvent, eventListener);
+    setAttributeEventListener(eventNames().searchEvent, eventListener);
 }
 
 EventListener* Node::onselectstart() const
@@ -3354,6 +3368,7 @@ void Node::setOnselectstart(PassRefPtr<EventListener> eventListener)
     setAttributeEventListener(eventNames().selectstartEvent, eventListener);
 }
 
+#ifdef MANUAL_MERGE_REQUIRED
 EventListener* Node::onsubmit() const
 {
     return getAttributeEventListener(eventNames().submitEvent);
@@ -3416,6 +3431,8 @@ void Node::setOntouchcancel(PassRefPtr<EventListener> eventListener)
 }
 #endif // ENABLE(TOUCH_EVENT)
 
+#else // MANUAL_MERGE_REQUIRED
+#endif // MANUAL_MERGE_REQUIRED
 } // namespace WebCore
 
 #ifndef NDEBUG