WebKit merge 40722:40785 (part 1)

third_party/WebKit/WebCore/rendering/RenderObject.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 411 matching lines @@
                       RenderLayer*& beforeChild)
 {
     if (obj->hasLayer()) {
         if (!beforeChild && newObject) {
             // We need to figure out the layer that follows newObject.  We only do
             // this the first time we find a child layer, and then we update the
             // pointer values for newObject and beforeChild used by everyone else.
             beforeChild = newObject->parent()->findNextLayer(parentLayer, newObject);
             newObject = 0;
         }
-        parentLayer->addChild(toRenderBox(obj)->layer(), beforeChild);
+        parentLayer->addChild(toRenderBoxModelObject(obj)->layer(), beforeChild);
         return;
     }
 
     for (RenderObject* curr = obj->firstChild(); curr; curr = curr->nextSibling())
         addLayers(curr, parentLayer, newObject, beforeChild);
 }
 
 void RenderObject::addLayers(RenderLayer* parentLayer, RenderObject* newObject)
 {
     if (!parentLayer)
         return;
 
     RenderObject* object = newObject;
     RenderLayer* beforeChild = 0;
     WebCore::addLayers(this, parentLayer, object, beforeChild);
 }
 
 void RenderObject::removeLayers(RenderLayer* parentLayer)
 {
     if (!parentLayer)
         return;
 
     if (hasLayer()) {
-        parentLayer->removeChild(toRenderBox(this)->layer());
+        parentLayer->removeChild(toRenderBoxModelObject(this)->layer());
         return;
     }
 
     for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling())
         curr->removeLayers(parentLayer);
 }
 
 void RenderObject::moveLayers(RenderLayer* oldParent, RenderLayer* newParent)
 {
     if (!newParent)
         return;
 
     if (hasLayer()) {
-        RenderLayer* layer = toRenderBox(this)->layer();
+        RenderLayer* layer = toRenderBoxModelObject(this)->layer();
         if (oldParent)
             oldParent->removeChild(layer);
         newParent->addChild(layer);
         return;
     }
 
     for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling())
         curr->moveLayers(oldParent, newParent);
 }
 
 RenderLayer* RenderObject::findNextLayer(RenderLayer* parentLayer, RenderObject* startPoint,
                                          bool checkParent)
 {
     // Error check the parent layer passed in.  If it's null, we can't find anything.
     if (!parentLayer)
         return 0;
 
     // Step 1: If our layer is a child of the desired parent, then return our layer.
-    RenderLayer* ourLayer = hasLayer() ? toRenderBox(this)->layer() : 0;
+    RenderLayer* ourLayer = hasLayer() ? toRenderBoxModelObject(this)->layer() : 0;
     if (ourLayer && ourLayer->parent() == parentLayer)
         return ourLayer;
 
     // Step 2: If we don't have a layer, or our layer is the desired parent, then descend
     // into our siblings trying to find the next layer whose parent is the desired parent.
     if (!ourLayer || ourLayer == parentLayer) {
         for (RenderObject* curr = startPoint ? startPoint->nextSibling() : firstChild();
              curr; curr = curr->nextSibling()) {
             RenderLayer* nextLayer = curr->findNextLayer(parentLayer, 0, false);
             if (nextLayer)
@@ skipping 11 matching lines @@
     if (checkParent && parent())
         return parent()->findNextLayer(parentLayer, this, true);
 
     return 0;
 }
 
 RenderLayer* RenderObject::enclosingLayer() const
 {
     const RenderObject* curr = this;
     while (curr) {
-        RenderLayer* layer = curr->hasLayer() ? toRenderBox(curr)->layer() : 0;
+        RenderLayer* layer = curr->hasLayer() ? toRenderBoxModelObject(curr)->layer() : 0;
         if (layer)
             return layer;
         curr = curr->parent();
     }
     return 0;
 }
 
 #if USE(ACCELERATED_COMPOSITING)
 RenderLayer* RenderObject::enclosingCompositingLayer() const
 {
     const RenderObject* curr = this;
     while (curr) {
-        RenderLayer* layer = curr->hasLayer() ? toRenderBox(curr)->layer() : 0;
+        RenderLayer* layer = curr->hasLayer() ? toRenderBoxModelObject(curr)->layer() : 0;
         if (layer && layer->isComposited())
             return layer;
         curr = curr->parent();
     }
     return 0;
 }
 #endif
 
 RenderBox* RenderObject::enclosingBox() const
 {
@@ skipping 31 matching lines @@
         if (o->style()->position() == FixedPosition || o->style()->position() == AbsolutePosition)
             // A positioned object has no effect on the min/max width of its containing block ever.
             // We can optimize this case and not go up any further.
             break;
         o = o->isTableCell() ? o->containingBlock() : o->container();
     }
 }
 
 void RenderObject::setLayerNeedsFullRepaint()
 {
-    toRenderBox(this)->layer()->setNeedsFullRepaint(true);
+    ASSERT(hasLayer());
+    toRenderBoxModelObject(this)->layer()->setNeedsFullRepaint(true);
 }
 
 RenderBlock* RenderObject::containingBlock() const
 {
     if (isTableCell()) {
         const RenderTableCell* cell = static_cast<const RenderTableCell*>(this);
         if (parent() && cell->section())
             return cell->table();
         return 0;
     }
@@ skipping 945 matching lines @@
     drawBorder(graphicsContext, tx + w, ty - ow, tx + w + ow, ty + h + ow,
                BSRight, Color(oc), style->color(), os, ow, ow);
 
     drawBorder(graphicsContext, tx - ow, ty + h, tx + w + ow, ty + h + ow,
                BSBottom, Color(oc), style->color(), os, ow, ow);
 }
 
 
 void RenderObject::absoluteRectsForRange(Vector<IntRect>& rects, unsigned start, unsigned end, bool)
 {
-    if (!virtualChildren()->firstChild()) {
+    if (!firstChild()) {
         if ((isInline() || isAnonymousBlock())) {
             FloatPoint absPos = localToAbsolute(FloatPoint());
             absoluteRects(rects, absPos.x(), absPos.y());
         }
         return;
     }
 
     unsigned offset = start;
     for (RenderObject* child = childAt(start); child && offset < end; child = child->nextSibling(), ++offset) {
         if (child->isText() || child->isInline() || child->isAnonymousBlock()) {
             FloatPoint absPos = child->localToAbsolute(FloatPoint());
             child->absoluteRects(rects, absPos.x(), absPos.y());
         }
     }
 }
 
 void RenderObject::absoluteQuadsForRange(Vector<FloatQuad>& quads, unsigned start, unsigned end, bool)
 {
-    if (!virtualChildren()->firstChild()) {
+    if (!firstChild()) {
         if (isInline() || isAnonymousBlock())
             absoluteQuads(quads);
         return;
     }
 
     unsigned offset = start;
     for (RenderObject* child = childAt(start); child && offset < end; child = child->nextSibling(), ++offset) {
         if (child->isText() || child->isInline() || child->isAnonymousBlock())
             child->absoluteQuads(quads);
     }
@@ skipping 77 matching lines @@
             repaintContainer->layer()->setBackingNeedsRepaintInRect(r);
         }
 #else
         ASSERT_NOT_REACHED();
 #endif
     }
 }
 
 void RenderObject::repaint(bool immediate)
 {
-    // Can't use view(), since we might be unrooted.
-    RenderObject* o = this;
-    while (o->parent())
-        o = o->parent();
-    if (!o->isRenderView())
+    // Don't repaint if we're unrooted (note that view() still returns the view when unrooted)
+    RenderView* view;
+    if (!isRooted(&view))
         return;
 
-    RenderView* view = toRenderView(o);
     if (view->printing())
         return; // Don't repaint if we're printing.
 
     RenderBoxModelObject* repaintContainer = containerForRepaint();
     repaintUsingContainer(repaintContainer ? repaintContainer : view, clippedOverflowRectForRepaint(repaintContainer), immediate);
 }
 
 void RenderObject::repaintRectangle(const IntRect& r, bool immediate)
 {
-    // Can't use view(), since we might be unrooted.
-    RenderObject* o = this;
-    while (o->parent())
-        o = o->parent();
-    if (!o->isRenderView())
+    // Don't repaint if we're unrooted (note that view() still returns the view when unrooted)
+    RenderView* view;
+    if (!isRooted(&view))
         return;
 
-    RenderView* view = toRenderView(o);
     if (view->printing())
         return; // Don't repaint if we're printing.
 
     IntRect dirtyRect(r);
 
     // FIXME: layoutDelta needs to be applied in parts before/after transforms and
     // repaint containers. https://bugs.webkit.org/show_bug.cgi?id=23308
     dirtyRect.move(view->layoutDelta());
 
     RenderBoxModelObject* repaintContainer = containerForRepaint();
@@ skipping 265 matching lines @@
 }
 
 void RenderObject::handleDynamicFloatPositionChange()
 {
     // We have gone from not affecting the inline status of the parent flow to suddenly
     // having an impact.  See if there is a mismatch between the parent flow's
     // childrenInline() state and our state.
     setInline(style()->isDisplayInlineType());
     if (isInline() != parent()->childrenInline()) {
         if (!isInline())
-            toRenderBox(parent())->childBecameNonInline(this);
+            toRenderBoxModelObject(parent())->childBecameNonInline(this);
         else {
             // An anonymous block must be made to wrap this inline.
             RenderBlock* block = createAnonymousBlock();
             RenderObjectChildList* childlist = parent()->virtualChildren();
             childlist->insertChildNode(parent(), block, this);
             block->children()->appendChildNode(block, childlist->removeChildNode(parent(), this));
         }
     }
 }
 
@@ skipping 214 matching lines @@
        *extraWidthToEndOfLine = 0;
 
     return IntRect();
 }
 
 RenderView* RenderObject::view() const
 {
     return toRenderView(document()->renderer());
 }
 
+bool RenderObject::isRooted(RenderView** view)
+{
+    RenderObject* o = this;
+    while (o->parent())
+        o = o->parent();
+
+    if (!o->isRenderView())
+        return false;
+
+    if (view)
+        *view = toRenderView(o);
+
+    return true;
+}
+
 bool RenderObject::hasOutlineAnnotation() const
 {
     return element() && element()->isLink() && document()->printing();
 }
 
 RenderObject* RenderObject::container() const
 {
     // This method is extremely similar to containingBlock(), but with a few notable
     // exceptions.
     // (1) It can be used on orphaned subtrees, i.e., it can be called safely even when
@@ skipping 56 matching lines @@
         document()->axObjectCache()->remove(this);
     }
     animation()->cancelAnimations(this);
 
     // By default no ref-counting. RenderWidget::destroy() doesn't call
     // this function because it needs to do ref-counting. If anything
     // in this function changes, be sure to fix RenderWidget::destroy() as well.
 
     remove();
 
-    // FIXME: Would like to do this in RenderBox, but the timing is so complicated that this can't easily
-    // be moved into RenderBox::destroy.
+    // FIXME: Would like to do this in RenderBoxModelObject, but the timing is so complicated that this can't easily
+    // be moved into RenderBoxModelObject::destroy.
     RenderArena* arena = renderArena();
     if (hasLayer())
-        toRenderBox(this)->layer()->destroy(arena);
+        toRenderBoxModelObject(this)->layer()->destroy(arena);
     arenaDelete(arena, this);
 }
 
 void RenderObject::arenaDelete(RenderArena* arena, void* base)
 {
     if (m_style) {
         for (const FillLayer* bgLayer = m_style->backgroundLayers(); bgLayer; bgLayer = bgLayer->next()) {
             if (StyleImage* backgroundImage = bgLayer->image())
                 backgroundImage->removeClient(this);
         }
@@ skipping 477 matching lines @@
 AnimationController* RenderObject::animation() const
 {
     return document()->frame()->animation();
 }
 
 void RenderObject::imageChanged(CachedImage* image, const IntRect* rect)
 {
     imageChanged(static_cast<WrappedImagePtr>(image), rect);
 }
 
+RenderBoxModelObject* RenderObject::offsetParent() const
+{
+    // If any of the following holds true return null and stop this algorithm:
+    // A is the root element.
+    // A is the HTML body element.
+    // The computed value of the position property for element A is fixed.
+    if (isRoot() || isBody() || (isPositioned() && style()->position() == FixedPosition))
+        return 0;
+
+    // If A is an area HTML element which has a map HTML element somewhere in the ancestor
+    // chain return the nearest ancestor map HTML element and stop this algorithm.
+    // FIXME: Implement!
+    
+    // Return the nearest ancestor element of A for which at least one of the following is
+    // true and stop this algorithm if such an ancestor is found:
+    //     * The computed value of the position property is not static.
+    //     * It is the HTML body element.
+    //     * The computed value of the position property of A is static and the ancestor
+    //       is one of the following HTML elements: td, th, or table.
+    //     * Our own extension: if there is a difference in the effective zoom
+    bool skipTables = isPositioned() || isRelPositioned();
+    float currZoom = style()->effectiveZoom();
+    RenderObject* curr = parent();
+    while (curr && (!curr->element() ||
+                    (!curr->isPositioned() && !curr->isRelPositioned() && !curr->isBody()))) {
+        Node* element = curr->element();
+        if (!skipTables && element) {
+            bool isTableElement = element->hasTagName(tableTag) ||
+                                  element->hasTagName(tdTag) ||
+                                  element->hasTagName(thTag);
+
+#if ENABLE(WML)
+            if (!isTableElement && element->isWMLElement())
+                isTableElement = element->hasTagName(WMLNames::tableTag) ||
+                                 element->hasTagName(WMLNames::tdTag);
+#endif
+
+            if (isTableElement)
+                break;
+        }
+
+        float newZoom = curr->style()->effectiveZoom();
+        if (currZoom != newZoom)
+            break;
+        currZoom = newZoom;
+        curr = curr->parent();
+    }
+    return curr && curr->isBox() ? toRenderBox(curr) : 0;
+}
+
 #if ENABLE(SVG)
 
 FloatRect RenderObject::relativeBBox(bool) const
 {
     return FloatRect();
 }
 
 TransformationMatrix RenderObject::localTransform() const
 {
     return TransformationMatrix();
@@ skipping 13 matching lines @@
 #ifndef NDEBUG
 
 void showTree(const WebCore::RenderObject* ro)
 {
     if (ro)
         ro->showTreeForThis();
 }
 
 #endif