Revert the merge. Mac build is mysteriously broken.

third_party/WebKit/WebCore/dom/Document.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2008 David Levin (levin@chromium.org)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 1251 matching lines @@
         if (renderer() && ch != NoChange)
             renderer()->setStyle(documentStyle.release());
         if (change != Force)
             change = ch;
     }
 
     for (Node* n = firstChild(); n; n = n->nextSibling())
         if (change >= Inherit || n->hasChangedChild() || n->changed())
             n->recalcStyle(change);
 
-    if (view()) {
-        if (changed())
-            view()->layout();
-#if USE(ACCELERATED_COMPOSITING)
-        else {
-            // If we didn't update compositing layers because of layout(), we need to do so here.
-            view()->updateCompositingLayers();
-        }
-#endif
-    }
+    if (changed() && view())
+        view()->layout();
 
 bail_out:
     setChanged(NoStyleChange);
     setHasChangedChild(false);
     setDocumentChanged(false);
     
     resumePostAttachCallbacks();
     m_inStyleRecalc = false;
     
     // If we wanted to call implicitClose() during recalcStyle, do so now that we're finished.
@@ skipping 31 matching lines @@
         doc->m_docChanged = false;
         doc->updateRendering();
     }
 }
 
 void Document::updateLayout()
 {
     if (Element* oe = ownerElement())
         oe->document()->updateLayout();
 
+    // FIXME: Dave Hyatt's pretty sure we can remove this because layout calls recalcStyle as needed.
     updateRendering();
 
     // Only do a layout if changes have occurred that make it necessary.      
     FrameView* v = view();
     if (v && renderer() && (v->layoutPending() || renderer()->needsLayout()))
         v->layout();
 }
 
 // FIXME: This is a bad idea and needs to be removed eventually.
 // Other browsers load stylesheets before they continue parsing the web page.
@@ skipping 32 matching lines @@
 {
     ASSERT(!attached());
     ASSERT(!m_inPageCache);
     ASSERT(!m_axObjectCache);
 
     if (!m_renderArena)
         m_renderArena = new RenderArena();
     
     // Create the rendering tree
     setRenderer(new (m_renderArena) RenderView(this, view()));
-#if USE(ACCELERATED_COMPOSITING)
-    renderView()->didMoveOnscreen();
-#endif
 
     if (!m_styleSelector) {
         bool matchAuthorAndUserStyles = true;
         if (Settings* docSettings = settings())
             matchAuthorAndUserStyles = docSettings->authorAndUserStylesEnabled();
         m_styleSelector = new CSSStyleSelector(this, userStyleSheet(), m_styleSheets.get(), m_mappedElementSheet.get(), !inCompatMode(), matchAuthorAndUserStyles);
     }
 
     recalcStyle(Force);
 
     RenderObject* render = renderer();
     setRenderer(0);
 
     ContainerNode::attach();
 
     setRenderer(render);
 }
 
 void Document::detach()
 {
     ASSERT(attached());
     ASSERT(!m_inPageCache);
 
     clearAXObjectCache();
     stopActiveDOMObjects();
     
     RenderObject* render = renderer();
 
-#if USE(ACCELERATED_COMPOSITING)
-    if (render)
-        renderView()->willMoveOffscreen();
-#endif
-
     // indicate destruction mode,  i.e. attached() but renderer == 0
     setRenderer(0);
     
     // Empty out these lists as a performance optimization, since detaching
     // all the individual render objects will cause all the RenderImage
     // objects to remove themselves from the lists.
     m_imageLoadEventDispatchSoonList.clear();
     m_imageLoadEventDispatchingList.clear();
     
     m_hoverNode = 0;
@@ skipping 22 matching lines @@
     m_frame = 0;
 }
 
 void Document::removeAllEventListenersFromAllNodes()
 {
     size_t size = m_windowEventListeners.size();
     for (size_t i = 0; i < size; ++i)
         m_windowEventListeners[i]->setRemoved(true);
     m_windowEventListeners.clear();
     removeAllDisconnectedNodeEventListeners();
-    for (Node* node = this; node; node = node->traverseNextNode())
-        node->removeAllEventListeners();
+    removeAllEventListeners();
+    Element* documentElement = this->documentElement();
+    for (Node* node = documentElement; node; node = node->traverseNextNode(documentElement))
+        toEventTargetNode(node)->removeAllEventListeners();
 }
 
 void Document::registerDisconnectedNodeWithEventListeners(Node* node)
 {
     m_disconnectedNodesWithEventListeners.add(node);
 }
 
 void Document::unregisterDisconnectedNodeWithEventListeners(Node* node)
 {
     m_disconnectedNodesWithEventListeners.remove(node);
 }
 
 void Document::removeAllDisconnectedNodeEventListeners()
 {
     HashSet<Node*>::iterator end = m_disconnectedNodesWithEventListeners.end();
     for (HashSet<Node*>::iterator i = m_disconnectedNodesWithEventListeners.begin(); i != end; ++i)
-        (*i)->removeAllEventListeners();
+        EventTargetNodeCast(*i)->removeAllEventListeners();
     m_disconnectedNodesWithEventListeners.clear();
 }
 
 RenderView* Document::renderView() const
 {
     return toRenderView(renderer());
 }
 
 void Document::clearAXObjectCache()
 {
@@ skipping 1094 matching lines @@
     // Remove focus from the existing focus node (if any)
     if (oldFocusedNode && !oldFocusedNode->m_inDetach) { 
         if (oldFocusedNode->active())
             oldFocusedNode->setActive(false);
 
         oldFocusedNode->setFocus(false);
                 
         // Dispatch a change event for text fields or textareas that have been edited
         RenderObject* r = static_cast<RenderObject*>(oldFocusedNode.get()->renderer());
         if (r && (r->isTextArea() || r->isTextField()) && r->isEdited()) {
-            oldFocusedNode->dispatchEventForType(eventNames().changeEvent, true, false);
+            EventTargetNodeCast(oldFocusedNode.get())->dispatchEventForType(eventNames().changeEvent, true, false);
             if ((r = static_cast<RenderObject*>(oldFocusedNode.get()->renderer())))
                 r->setEdited(false);
         }
 
         // Dispatch the blur event and let the node do any other blur related activities (important for text fields)
-        oldFocusedNode->dispatchBlurEvent();
+        EventTargetNodeCast(oldFocusedNode.get())->dispatchBlurEvent();
 
         if (m_focusedNode) {
             // handler shifted focus
             focusChangeBlocked = true;
             newFocusedNode = 0;
         }
-        oldFocusedNode->dispatchUIEvent(eventNames().DOMFocusOutEvent);
+        EventTargetNodeCast(oldFocusedNode.get())->dispatchUIEvent(eventNames().DOMFocusOutEvent);
         if (m_focusedNode) {
             // handler shifted focus
             focusChangeBlocked = true;
             newFocusedNode = 0;
         }
         if ((oldFocusedNode.get() == this) && oldFocusedNode->hasOneRef())
             return true;
             
         if (oldFocusedNode.get() == oldFocusedNode->rootEditableElement())
             frame()->editor()->didEndEditing();
     }
 
     if (newFocusedNode) {
         if (newFocusedNode == newFocusedNode->rootEditableElement() && !acceptsEditingFocus(newFocusedNode.get())) {
             // delegate blocks focus change
             focusChangeBlocked = true;
             goto SetFocusedNodeDone;
         }
         // Set focus on the new node
         m_focusedNode = newFocusedNode.get();
 
         // Dispatch the focus event and let the node do any other focus related activities (important for text fields)
-        m_focusedNode->dispatchFocusEvent();
+        EventTargetNodeCast(m_focusedNode.get())->dispatchFocusEvent();
 
         if (m_focusedNode != newFocusedNode) {
             // handler shifted focus
             focusChangeBlocked = true;
             goto SetFocusedNodeDone;
         }
-        m_focusedNode->dispatchUIEvent(eventNames().DOMFocusInEvent);
+        EventTargetNodeCast(m_focusedNode.get())->dispatchUIEvent(eventNames().DOMFocusInEvent);
         if (m_focusedNode != newFocusedNode) { 
             // handler shifted focus
             focusChangeBlocked = true;
             goto SetFocusedNodeDone;
         }
         m_focusedNode->setFocus();
 
         if (m_focusedNode.get() == m_focusedNode->rootEditableElement())
             frame()->editor()->didBeginEditing();
 
@@ skipping 651 matching lines @@
     } else {
         ASSERT(renderer() == 0 || renderer() == m_savedRenderer);
         ASSERT(m_renderArena);
         setRenderer(m_savedRenderer);
         m_savedRenderer = 0;
     }
 }
 
 void Document::documentWillBecomeInactive() 
 {
-#if USE(ACCELERATED_COMPOSITING)
-    if (renderer())
-        renderView()->willMoveOffscreen();
-#endif
-
     HashSet<Element*>::iterator end = m_documentActivationCallbackElements.end();
     for (HashSet<Element*>::iterator i = m_documentActivationCallbackElements.begin(); i != end; ++i)
         (*i)->documentWillBecomeInactive();
 }
 
 void Document::documentDidBecomeActive() 
 {
     HashSet<Element*>::iterator end = m_documentActivationCallbackElements.end();
     for (HashSet<Element*>::iterator i = m_documentActivationCallbackElements.begin(); i != end; ++i)
         (*i)->documentDidBecomeActive();
-
-#if USE(ACCELERATED_COMPOSITING)
-    if (renderer())
-        renderView()->didMoveOnscreen();
-#endif
 }
 
 void Document::registerForDocumentActivationCallbacks(Element* e)
 {
     m_documentActivationCallbackElements.add(e);
 }
 
 void Document::unregisterForDocumentActivationCallbacks(Element* e)
 {
     m_documentActivationCallbackElements.remove(e);
@@ skipping 1187 matching lines @@
             }
         }
     }
     return 0;
 }
 
 } // namespace WebCore