Changeset 87880 in webkit


Ignore:
Timestamp:
Jun 1, 2011, 11:41:17 PM (14 years ago)
Author:
eae@chromium.org
Message:

2011-06-01 Emil A Eklund <​eae@chromium.org>

Reviewed by Eric Seidel.

Switch RenderLayer::convertToLayerCoords to use IntPoint
​https://bugs.webkit.org/show_bug.cgi?id=61818

Covered by existing tests.

  • platform/graphics/FloatPoint.h: (WebCore::flooredIntSize):
  • rendering/RenderLayer.cpp: (WebCore::RenderLayer::updateLayerPositions): (WebCore::expandClipRectForDescendantsAndReflection): (WebCore::transparencyClipBox): (WebCore::RenderLayer::convertToLayerCoords): (WebCore::RenderLayer::paintLayer): (WebCore::RenderLayer::paintChildLayerIntoColumns): (WebCore::RenderLayer::createLocalTransformState): (WebCore::RenderLayer::hitTestChildLayerColumns): (WebCore::RenderLayer::calculateClipRects): (WebCore::RenderLayer::calculateRects): (WebCore::RenderLayer::boundingBox): (WebCore::RenderLayer::setBackingNeedsRepaintInRect):
  • rendering/RenderLayer.h:
  • rendering/RenderLayerBacking.cpp: (WebCore::RenderLayerBacking::updateCompositedBounds): (WebCore::RenderLayerBacking::updateGraphicsLayerGeometry):
  • rendering/RenderLayerCompositor.cpp: (WebCore::RenderLayerCompositor::calculateCompositedBounds): (WebCore::RenderLayerCompositor::layerWillBeRemoved): (WebCore::RenderLayerCompositor::recursiveRepaintLayerRect):
Location:
trunk/Source/WebCore
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r87879 r87880  
     12011-06-01  Emil A Eklund  <eae@chromium.org>
     2
     3        Reviewed by Eric Seidel.
     4
     5        Switch RenderLayer::convertToLayerCoords to use IntPoint
     6        https://bugs.webkit.org/show_bug.cgi?id=61818
     7
     8        Covered by existing tests.
     9
     10        * platform/graphics/FloatPoint.h:
     11        (WebCore::flooredIntSize):
     12        * rendering/RenderLayer.cpp:
     13        (WebCore::RenderLayer::updateLayerPositions):
     14        (WebCore::expandClipRectForDescendantsAndReflection):
     15        (WebCore::transparencyClipBox):
     16        (WebCore::RenderLayer::convertToLayerCoords):
     17        (WebCore::RenderLayer::paintLayer):
     18        (WebCore::RenderLayer::paintChildLayerIntoColumns):
     19        (WebCore::RenderLayer::createLocalTransformState):
     20        (WebCore::RenderLayer::hitTestChildLayerColumns):
     21        (WebCore::RenderLayer::calculateClipRects):
     22        (WebCore::RenderLayer::calculateRects):
     23        (WebCore::RenderLayer::boundingBox):
     24        (WebCore::RenderLayer::setBackingNeedsRepaintInRect):
     25        * rendering/RenderLayer.h:
     26        * rendering/RenderLayerBacking.cpp:
     27        (WebCore::RenderLayerBacking::updateCompositedBounds):
     28        (WebCore::RenderLayerBacking::updateGraphicsLayerGeometry):
     29        * rendering/RenderLayerCompositor.cpp:
     30        (WebCore::RenderLayerCompositor::calculateCompositedBounds):
     31        (WebCore::RenderLayerCompositor::layerWillBeRemoved):
     32        (WebCore::RenderLayerCompositor::recursiveRepaintLayerRect):
     33
    1342011-06-01  Roland Steiner  <rolandsteiner@chromium.org>
    235

  • trunk/Source/WebCore/platform/graphics/FloatPoint.h

    r86705 r87880  
    6464class TransformationMatrix;
    6565class IntPoint;
     66class IntSize;
    6667
    6768class FloatPoint {
    … …  
    208209}
    209210
     211inline IntSize flooredIntSize(const FloatPoint& p)
     212{
     213    return IntSize(static_cast<int>(p.x()), static_cast<int>(p.y()));
     214}
     215
    210216float findSlope(const FloatPoint& p1, const FloatPoint& p2, float& c);
    211217

  • trunk/Source/WebCore/rendering/RenderLayer.cpp

    r87864 r87880  
    276276                cachedOffset->move(m_topLeft.x(), m_topLeft.y()); // Fast case
    277277            else {
    278                 int x = 0;
    279                 int y = 0;
    280                 convertToLayerCoords(root(), x, y);
    281                 *cachedOffset = IntPoint(x, y);
     278                IntPoint offset;
     279                convertToLayerCoords(root(), offset);
     280                *cachedOffset = offset;
    282281            }
    283282        }
    284283    }
    285284
    286     int x = 0;
    287     int y = 0;
     285    IntPoint offset;
    288286    if (cachedOffset) {
    289         x += cachedOffset->x();
    290         y += cachedOffset->y();
     287        offset = *cachedOffset;
    291288#ifndef NDEBUG
    292         int nonCachedX = 0;
    293         int nonCachedY = 0;
    294         convertToLayerCoords(root(), nonCachedX, nonCachedY);
    295         ASSERT(x == nonCachedX);
    296         ASSERT(y == nonCachedY);
     289        IntPoint nonCachedOffset;
     290        convertToLayerCoords(root(), nonCachedOffset);
     291        ASSERT(offset == nonCachedOffset);
    297292#endif
    298293    } else
    299         convertToLayerCoords(root(), x, y);
    300     positionOverflowControls(IntSize(x, y));
     294        convertToLayerCoords(root(), offset);
     295    positionOverflowControls(toSize(offset));
    301296
    302297    updateVisibilityStatus();
    … …  
    902897    // size into the parent layer.
    903898    if (l->renderer()->hasReflection()) {
    904         int deltaX = 0;
    905         int deltaY = 0;
    906         l->convertToLayerCoords(rootLayer, deltaX, deltaY);
    907         clipRect.move(-deltaX, -deltaY);
     899        IntPoint delta;
     900        l->convertToLayerCoords(rootLayer, delta);
     901        clipRect.move(-delta.x(), -delta.y());
    908902        clipRect.unite(l->renderBox()->reflectedRect(clipRect));
    909         clipRect.move(deltaX, deltaY);
     903        clipRect.move(delta);
    910904    }
    911905}
    … …  
    920914        // The best we can do here is to use enclosed bounding boxes to establish a "fuzzy" enough clip to encompass
    921915        // the transformed layer and all of its children.
    922         int x = 0;
    923         int y = 0;
    924         l->convertToLayerCoords(rootLayer, x, y);
     916        IntPoint delta;
     917        l->convertToLayerCoords(rootLayer, delta);
    925918
    926919        TransformationMatrix transform;
    927         transform.translate(x, y);
     920        transform.translate(delta.x(), delta.y());
    928921        transform = transform * *l->transform();
    929922
    … …  
    11131106
    11141107void
    1115 RenderLayer::convertToLayerCoords(const RenderLayer* ancestorLayer, int& xPos, int& yPos) const
     1108RenderLayer::convertToLayerCoords(const RenderLayer* ancestorLayer, IntPoint& location) const
    11161109{
    11171110    if (ancestorLayer == this)
    … …  
    11231116        // localToAbsolute() on the RenderView.
    11241117        FloatPoint absPos = renderer()->localToAbsolute(FloatPoint(), true);
    1125         xPos += absPos.x();
    1126         yPos += absPos.y();
     1118        location += flooredIntSize(absPos);
    11271119        return;
    11281120    }
    … …  
    11481140
    11491141        if (fixedPositionContainerLayer != ancestorLayer) {
    1150             int fixedContainerX = 0;
    1151             int fixedContainerY = 0;
    1152             convertToLayerCoords(fixedPositionContainerLayer, fixedContainerX, fixedContainerY);
    1153            
    1154             int ancestorX = 0;
    1155             int ancestorY = 0;
    1156             ancestorLayer->convertToLayerCoords(fixedPositionContainerLayer, ancestorX, ancestorY);
    1157        
    1158             xPos += (fixedContainerX - ancestorX);
    1159             yPos += (fixedContainerY - ancestorY);
     1142            IntPoint fixedContainerCoords;
     1143            convertToLayerCoords(fixedPositionContainerLayer, fixedContainerCoords);
     1144
     1145            IntPoint ancestorCoords;
     1146            ancestorLayer->convertToLayerCoords(fixedPositionContainerLayer, ancestorCoords);
     1147
     1148            location += (fixedContainerCoords - ancestorCoords);
    11601149            return;
    11611150        }
    … …  
    11841173            RenderLayer* positionedAncestor = parentLayer->enclosingPositionedAncestor();
    11851174
    1186             int thisX = 0;
    1187             int thisY = 0;
    1188             convertToLayerCoords(positionedAncestor, thisX, thisY);
     1175            IntPoint thisCoords;
     1176            convertToLayerCoords(positionedAncestor, thisCoords);
    11891177           
    1190             int ancestorX = 0;
    1191             int ancestorY = 0;
    1192             ancestorLayer->convertToLayerCoords(positionedAncestor, ancestorX, ancestorY);
    1193        
    1194             xPos += (thisX - ancestorX);
    1195             yPos += (thisY - ancestorY);
     1178            IntPoint ancestorCoords;
     1179            ancestorLayer->convertToLayerCoords(positionedAncestor, ancestorCoords);
     1180
     1181            location += (thisCoords - ancestorCoords);
    11961182            return;
    11971183        }
    … …  
    12011187    if (!parentLayer)
    12021188        return;
    1203    
    1204     parentLayer->convertToLayerCoords(ancestorLayer, xPos, yPos);
    1205 
    1206     xPos += m_topLeft.x();
    1207     yPos += m_topLeft.y();
     1189
     1190    parentLayer->convertToLayerCoords(ancestorLayer, location);
     1191
     1192    location += toSize(m_topLeft);
     1193}
     1194
     1195void
     1196RenderLayer::convertToLayerCoords(const RenderLayer* ancestorLayer, IntRect& rect) const
     1197{
     1198    IntPoint delta;
     1199    convertToLayerCoords(ancestorLayer, delta);
     1200    rect.move(-delta.x(), -delta.y());
    12081201}
    12091202
    … …  
    25722565        // Adjust the transform such that the renderer's upper left corner will paint at (0,0) in user space.
    25732566        // This involves subtracting out the position of the layer in our current coordinate space.
    2574         int x = 0;
    2575         int y = 0;
    2576         convertToLayerCoords(rootLayer, x, y);
     2567        IntPoint delta;
     2568        convertToLayerCoords(rootLayer, delta);
    25772569        TransformationMatrix transform(layerTransform);
    2578         transform.translateRight(x, y);
     2570        transform.translateRight(delta.x(), delta.y());
    25792571       
    25802572        // Apply the transform.
    … …  
    27662758        return;
    27672759   
    2768     int layerX = 0;
    2769     int layerY = 0;
    2770     columnBlock->layer()->convertToLayerCoords(rootLayer, layerX, layerY);
     2760    IntPoint layerOffset;
     2761    columnBlock->layer()->convertToLayerCoords(rootLayer, layerOffset);
    27712762   
    27722763    bool isHorizontal = columnBlock->style()->isHorizontalWritingMode();
    … …  
    27822773        IntSize offset = isHorizontal ? IntSize(logicalLeftOffset, currLogicalTopOffset) : IntSize(currLogicalTopOffset, logicalLeftOffset);
    27832774
    2784         colRect.move(layerX, layerY);
     2775        colRect.move(layerOffset);
    27852776
    27862777        IntRect localDirtyRect(paintDirtyRect);
    … …  
    28122803                // Adjust the transform such that the renderer's upper left corner will paint at (0,0) in user space.
    28132804                // This involves subtracting out the position of the layer in our current coordinate space.
    2814                 int childX = 0;
    2815                 int childY = 0;
    2816                 columnLayers[colIndex - 1]->convertToLayerCoords(rootLayer, childX, childY);
     2805                IntPoint childOffset;
     2806                columnLayers[colIndex - 1]->convertToLayerCoords(rootLayer, childOffset);
    28172807                TransformationMatrix transform;
    2818                 transform.translateRight(childX + offset.width(), childY + offset.height());
     2808                transform.translateRight(childOffset.x() + offset.width(), childOffset.y() + offset.height());
    28192809               
    28202810                // Apply the transform.
    … …  
    29102900{
    29112901    RefPtr<HitTestingTransformState> transformState;
    2912     int offsetX = 0;
    2913     int offsetY = 0;
     2902    IntPoint offset;
    29142903    if (containerTransformState) {
    29152904        // If we're already computing transform state, then it's relative to the container (which we know is non-null).
    29162905        transformState = HitTestingTransformState::create(*containerTransformState);
    2917         convertToLayerCoords(containerLayer, offsetX, offsetY);
     2906        convertToLayerCoords(containerLayer, offset);
    29182907    } else {
    29192908        // If this is the first time we need to make transform state, then base it off of hitTestPoint,
    29202909        // which is relative to rootLayer.
    29212910        transformState = HitTestingTransformState::create(hitTestPoint, FloatQuad(hitTestRect));
    2922         convertToLayerCoords(rootLayer, offsetX, offsetY);
     2911        convertToLayerCoords(rootLayer, offset);
    29232912    }
    29242913   
    … …  
    29262915    if (renderer()->shouldUseTransformFromContainer(containerRenderer)) {
    29272916        TransformationMatrix containerTransform;
    2928         renderer()->getTransformFromContainer(containerRenderer, IntSize(offsetX, offsetY), containerTransform);
     2917        renderer()->getTransformFromContainer(containerRenderer, toSize(offset), containerTransform);
    29292918        transformState->applyTransform(containerTransform, HitTestingTransformState::AccumulateTransform);
    29302919    } else {
    2931         transformState->translate(offsetX, offsetY, HitTestingTransformState::AccumulateTransform);
     2920        transformState->translate(offset.x(), offset.y(), HitTestingTransformState::AccumulateTransform);
    29322921    }
    29332922   
    … …  
    32383227    if (!columnBlock || !columnBlock->hasColumns())
    32393228        return 0;
    3240    
    3241     int layerX = 0;
    3242     int layerY = 0;
    3243     columnBlock->layer()->convertToLayerCoords(rootLayer, layerX, layerY);
     3229
     3230    IntPoint layerOffset;
     3231    columnBlock->layer()->convertToLayerCoords(rootLayer, layerOffset);
    32443232   
    32453233    ColumnInfo* colInfo = columnBlock->columnInfo();
    … …  
    32693257        else
    32703258            currLogicalTopOffset += blockDelta;
    3271         colRect.move(layerX, layerY);
     3259        colRect.move(layerOffset);
    32723260
    32733261        IntRect localClipRect(hitTestRect);
    … …  
    33783366    if (renderer()->hasOverflowClip() || renderer()->hasClip()) {
    33793367        // This layer establishes a clip of some kind.
    3380         int x = 0;
    3381         int y = 0;
    3382         convertToLayerCoords(rootLayer, x, y);
     3368        IntPoint offset;
     3369        convertToLayerCoords(rootLayer, offset);
    33833370        RenderView* view = renderer()->view();
    33843371        ASSERT(view);
    33853372        if (view && clipRects.fixed() && rootLayer->renderer() == view) {
    3386             x -= view->frameView()->scrollXForFixedPosition();
    3387             y -= view->frameView()->scrollYForFixedPosition();
     3373            offset -= view->frameView()->scrollOffsetForFixedPosition();
    33883374        }
    33893375       
    33903376        if (renderer()->hasOverflowClip()) {
    3391             IntRect newOverflowClip = toRenderBox(renderer())->overflowClipRect(x, y, relevancy);
     3377            IntRect newOverflowClip = toRenderBox(renderer())->overflowClipRect(offset.x(), offset.y(), relevancy);
    33923378            clipRects.setOverflowClipRect(intersection(newOverflowClip, clipRects.overflowClipRect()));
    33933379            if (renderer()->isPositioned() || renderer()->isRelPositioned())
    … …  
    33953381        }
    33963382        if (renderer()->hasClip()) {
    3397             IntRect newPosClip = toRenderBox(renderer())->clipRect(x, y);
     3383            IntRect newPosClip = toRenderBox(renderer())->clipRect(offset.x(), offset.y());
    33983384            clipRects.setPosClipRect(intersection(newPosClip, clipRects.posClipRect()));
    33993385            clipRects.setOverflowClipRect(intersection(newPosClip, clipRects.overflowClipRect()));
    … …  
    34453431    outlineRect = backgroundRect;
    34463432   
    3447     int x = 0;
    3448     int y = 0;
    3449     convertToLayerCoords(rootLayer, x, y);
    3450     layerBounds = IntRect(IntPoint(x, y), size());
     3433    IntPoint offset;
     3434    convertToLayerCoords(rootLayer, offset);
     3435    layerBounds = IntRect(offset, size());
    34513436   
    34523437    // Update the clip rects that will be passed to child layers.
    … …  
    34543439        // This layer establishes a clip of some kind.
    34553440        if (renderer()->hasOverflowClip())
    3456             foregroundRect.intersect(toRenderBox(renderer())->overflowClipRect(x, y, relevancy));
     3441            foregroundRect.intersect(toRenderBox(renderer())->overflowClipRect(offset.x(), offset.y(), relevancy));
    34573442        if (renderer()->hasClip()) {
    34583443            // Clip applies to *us* as well, so go ahead and update the damageRect.
    3459             IntRect newPosClip = toRenderBox(renderer())->clipRect(x, y);
     3444            IntRect newPosClip = toRenderBox(renderer())->clipRect(offset.x(), offset.y());
    34603445            backgroundRect.intersect(newPosClip);
    34613446            foregroundRect.intersect(newPosClip);
    … …  
    36113596    else
    36123597        renderer()->containingBlock()->flipForWritingMode(result);
    3613     int deltaX = 0, deltaY = 0;
    3614     convertToLayerCoords(ancestorLayer, deltaX, deltaY);
    3615     result.move(deltaX, deltaY);
     3598    IntPoint delta;
     3599    convertToLayerCoords(ancestorLayer, delta);
     3600    result.move(delta);
    36163601    return result;
    36173602}
    … …  
    39483933        // repaint to the native view system.
    39493934        IntRect absRect(r);
    3950         int x = 0;
    3951         int y = 0;
    3952         convertToLayerCoords(root(), x, y);
    3953         absRect.move(x, y);
     3935        IntPoint delta;
     3936        convertToLayerCoords(root(), delta);
     3937        absRect.move(delta);
    39543938
    39553939        RenderView* view = renderer()->view();

  • trunk/Source/WebCore/rendering/RenderLayer.h

    r87864 r87880  
    348348#endif
    349349
    350     void convertToLayerCoords(const RenderLayer* ancestorLayer, int& x, int& y) const;
     350    void convertToLayerCoords(const RenderLayer* ancestorLayer, IntPoint& location) const;
     351    void convertToLayerCoords(const RenderLayer* ancestorLayer, IntRect& rect) const;
    351352
    352353    bool hasAutoZIndex() const { return renderer()->style()->hasAutoZIndex(); }

  • trunk/Source/WebCore/rendering/RenderLayerBacking.cpp

    r87864 r87880  
    204204            clippingBounds.intersect(m_owningLayer->backgroundClipRect(rootLayer, true));
    205205
    206         int deltaX = 0;
    207         int deltaY = 0;
    208         m_owningLayer->convertToLayerCoords(rootLayer, deltaX, deltaY);
    209         clippingBounds.move(-deltaX, -deltaY);
     206        IntPoint delta;
     207        m_owningLayer->convertToLayerCoords(rootLayer, delta);
     208        clippingBounds.move(-delta.x(), -delta.y());
    210209
    211210        layerBounds.intersect(clippingBounds);
    … …  
    357356
    358357    IntRect relativeCompositingBounds(localCompositingBounds);
    359     int deltaX = 0, deltaY = 0;
    360     m_owningLayer->convertToLayerCoords(compAncestor, deltaX, deltaY);
    361     relativeCompositingBounds.move(deltaX, deltaY);
     358    IntPoint delta;
     359    m_owningLayer->convertToLayerCoords(compAncestor, delta);
     360    relativeCompositingBounds.move(delta);
    362361
    363362    IntPoint graphicsLayerParentLocation;
    … …  
    380379
    381380        // backgroundRect is relative to compAncestor, so subtract deltaX/deltaY to get back to local coords.
    382         IntSize rendererOffset(parentClipRect.location().x() - deltaX, parentClipRect.location().y() - deltaY);
    383         m_ancestorClippingLayer->setOffsetFromRenderer(rendererOffset);
     381        m_ancestorClippingLayer->setOffsetFromRenderer(parentClipRect.location() - delta);
    384382
    385383        // The primary layer is then parented in, and positioned relative to this clipping layer.
    … …  
    428426
    429427        // Get layout bounds in the coords of compAncestor to match relativeCompositingBounds.
    430         IntRect layerBounds = IntRect(deltaX, deltaY, borderBox.width(), borderBox.height());
     428        IntRect layerBounds = IntRect(delta, borderBox.size());
    431429
    432430        // Update properties that depend on layer dimensions

  • trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp

    r87547 r87880  
    450450   
    451451    if (layer->renderer()->hasOverflowClip() || layer->renderer()->hasMask()) {
    452         int ancestorRelX = 0, ancestorRelY = 0;
    453         layer->convertToLayerCoords(ancestorLayer, ancestorRelX, ancestorRelY);
    454         boundingBoxRect.move(ancestorRelX, ancestorRelY);
     452        IntPoint ancestorRelOffset;
     453        layer->convertToLayerCoords(ancestorLayer, ancestorRelOffset);
     454        boundingBoxRect.move(ancestorRelOffset);
    455455        return boundingBoxRect;
    456456    }
    … …  
    504504    }
    505505
    506     int ancestorRelX = 0, ancestorRelY = 0;
    507     layer->convertToLayerCoords(ancestorLayer, ancestorRelX, ancestorRelY);
    508     unionBounds.move(ancestorRelX, ancestorRelY);
     506    IntPoint ancestorRelOffset;
     507    layer->convertToLayerCoords(ancestorLayer, ancestorRelOffset);
     508    unionBounds.move(ancestorRelOffset);
    509509
    510510    return unionBounds;
    … …  
    528528        IntRect compBounds = child->backing()->compositedBounds();
    529529
    530         int offsetX = 0, offsetY = 0;
    531         child->convertToLayerCoords(compLayer, offsetX, offsetY);
    532         compBounds.move(offsetX, offsetY);
     530        IntPoint offset;
     531        child->convertToLayerCoords(compLayer, offset);
     532        compBounds.move(offset);
    533533
    534534        compLayer->setBackingNeedsRepaintInRect(compBounds);
    … …  
    10721072            for (size_t i = 0; i < listSize; ++i) {
    10731073                RenderLayer* curLayer = negZOrderList->at(i);
    1074                 int x = 0;
    1075                 int y = 0;
    1076                 curLayer->convertToLayerCoords(layer, x, y);
    10771074                IntRect childRect(rect);
    1078                 childRect.move(-x, -y);
     1075                curLayer->convertToLayerCoords(layer, childRect);
    10791076                recursiveRepaintLayerRect(curLayer, childRect);
    10801077            }
    … …  
    10851082            for (size_t i = 0; i < listSize; ++i) {
    10861083                RenderLayer* curLayer = posZOrderList->at(i);
    1087                 int x = 0;
    1088                 int y = 0;
    1089                 curLayer->convertToLayerCoords(layer, x, y);
    10901084                IntRect childRect(rect);
    1091                 childRect.move(-x, -y);
     1085                curLayer->convertToLayerCoords(layer, childRect);
    10921086                recursiveRepaintLayerRect(curLayer, childRect);
    10931087            }
    … …  
    10981092        for (size_t i = 0; i < listSize; ++i) {
    10991093            RenderLayer* curLayer = normalFlowList->at(i);
    1100             int x = 0;
    1101             int y = 0;
    1102             curLayer->convertToLayerCoords(layer, x, y);
    11031094            IntRect childRect(rect);
    1104             childRect.move(-x, -y);
     1095            curLayer->convertToLayerCoords(layer, childRect);
    11051096            recursiveRepaintLayerRect(curLayer, childRect);
    11061097        }
Note: See TracChangeset for help on using the changeset viewer.