Do another merge using nifty new merge script (CL for that coming soon).

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 1686 matching lines @@
     if (topLevel && continuation()) {
         rects.append(IntRect(tx, ty - collapsedMarginTop(),
                              width(), height() + collapsedMarginTop() + collapsedMarginBottom()));
         continuation()->absoluteRects(rects,
                                       tx - xPos() + continuation()->containingBlock()->xPos(),
                                       ty - yPos() + continuation()->containingBlock()->yPos(), topLevel);
     } else
         rects.append(IntRect(tx, ty, width(), height() + borderTopExtra() + borderBottomExtra()));
 }
 
-IntRect RenderObject::absoluteBoundingBoxRect()
+IntRect RenderObject::absoluteBoundingBoxRect(bool useTransforms)
 {
-    // FIXME: This doesn't work correctly with transforms.
+    if (useTransforms) {
+        Vector<FloatQuad> quads;
+        absoluteQuads(quads);
+
+        size_t n = quads.size();
+        if (!n)
+            return IntRect();
+    
+        IntRect result = quads[0].enclosingBoundingBox();
+        for (size_t i = 1; i < n; ++i)
+            result.unite(quads[i].enclosingBoundingBox());
+        return result;
+    }
+
     FloatPoint absPos = localToAbsolute();
     Vector<IntRect> rects;
     absoluteRects(rects, absPos.x(), absPos.y());
 
     size_t n = rects.size();
     if (!n)
         return IntRect();
 
     IntRect result = rects[0];
     for (size_t i = 1; i < n; ++i)
         result.unite(rects[i]);
     return result;
 }
 
+void RenderObject::collectAbsoluteLineBoxQuads(Vector<FloatQuad>& quads, unsigned startOffset, unsigned endOffset, bool useSelectionHeight)
+{
+}
+
+void RenderObject::absoluteQuads(Vector<FloatQuad>& quads, bool topLevel)
+{
+    // For blocks inside inlines, we go ahead and include margins so that we run right up to the
+    // inline boxes above and below us (thus getting merged with them to form a single irregular
+    // shape).
+    if (topLevel && continuation()) {
+        FloatRect localRect(0, -collapsedMarginTop(),
+                            width(), height() + collapsedMarginTop() + collapsedMarginBottom());
+        quads.append(localToAbsoluteQuad(localRect));
+        continuation()->absoluteQuads(quads, topLevel);
+    } else
+        quads.append(localToAbsoluteQuad(FloatRect(0, 0, width(), height() + borderTopExtra() + borderBottomExtra())));
+}
+
 void RenderObject::addAbsoluteRectForLayer(IntRect& result)
 {
     if (hasLayer())
         result.unite(absoluteBoundingBoxRect());
     for (RenderObject* current = firstChild(); current; current = current->nextSibling())
         current->addAbsoluteRectForLayer(result);
 }
 
 IntRect RenderObject::paintingRootRect(IntRect& topLevelRect)
 {
@@ skipping 657 matching lines @@
     if (o) {
         FloatPoint localPoint = o->absoluteToLocal(containerPoint, fixed, useTransforms);
         localPoint.move(0.0f, -static_cast<float>(o->borderTopExtra()));
         if (o->hasOverflowClip())
             localPoint += o->layer()->scrolledContentOffset();
         return localPoint;
     }
     return FloatPoint();
 }
 
+FloatQuad RenderObject::localToAbsoluteQuad(const FloatQuad& localQuad, bool fixed) const
+{
+    RenderObject* o = parent();
+    if (o) {
+        FloatQuad quad = localQuad;
+        quad.move(0.0f, static_cast<float>(o->borderTopExtra()));
+        if (o->hasOverflowClip())
+            quad -= o->layer()->scrolledContentOffset();
+        return o->localToAbsoluteQuad(quad, fixed);
+    }
+
+    return FloatQuad();
+}
+
 IntRect RenderObject::caretRect(InlineBox* inlineBox, int caretOffset, int* extraWidthToEndOfLine)
 {
    if (extraWidthToEndOfLine)
        *extraWidthToEndOfLine = 0;
 
     return IntRect();
 }
 
 int RenderObject::paddingTop() const
 {
@@ skipping 652 matching lines @@
 }
 
 IntRect RenderObject::absoluteContentBox() const
 {
     IntRect rect = contentBox();
     FloatPoint absPos = localToAbsoluteForContent(FloatPoint());
     rect.move(absPos.x(), absPos.y());
     return rect;
 }
 
+FloatQuad RenderObject::absoluteContentQuad() const
+{
+    IntRect rect = contentBox();
+    return localToAbsoluteQuad(FloatRect(rect));
+}
+
 void RenderObject::adjustRectForOutlineAndShadow(IntRect& rect) const
 {
     int outlineSize = !isInline() && continuation() ? continuation()->style()->outlineSize() : style()->outlineSize();
     if (ShadowData* boxShadow = style()->boxShadow()) {
         int shadowLeft = 0;
         int shadowRight = 0;
         int shadowTop = 0;
         int shadowBottom = 0;
 
         do {
@@ skipping 96 matching lines @@
 
 #ifndef NDEBUG
 
 void showTree(const WebCore::RenderObject* ro)
 {
     if (ro)
         ro->showTreeForThis();
 }
 
 #endif