Changeset 167803 in webkit


Ignore:
Timestamp:
Apr 25, 2014 6:56:12 AM (10 years ago)
Author:
stavila@adobe.com
Message:

[CSS Regions] Overflow selection doesn't work properly
​https://bugs.webkit.org/show_bug.cgi?id=130715

Reviewed by David Hyatt.

Source/WebCore:
When hit-testing, painting block selection gaps and searching for the node at a specific point inside a flow thread,
the region range of the box being checked must be validated in order to not return false positives. Otherwise, hit-testing
at the top of region B could hit elements that overflow the bottom of region A.

Tests: fast/regions/selection-in-overflow-hit-testing.html

fast/regions/selection-in-overflow.html
fast/regions/selection-in-text-after-overflow-hit-testing.html

  • accessibility/AccessibilityRenderObject.cpp:

(WebCore::AccessibilityRenderObject::visiblePositionRangeForLine):
(WebCore::AccessibilityRenderObject::visiblePositionForPoint):

  • dom/Document.cpp:

(WebCore::Document::caretRangeFromPoint):

  • editing/FrameSelection.cpp:

(WebCore::FrameSelection::contains):

  • editing/VisibleUnits.cpp:

(WebCore::previousLinePosition):
(WebCore::nextLinePosition):

  • page/EventHandler.cpp:

(WebCore::EventHandler::selectClosestWordFromHitTestResult):
(WebCore::EventHandler::selectClosestWordOrLinkFromMouseEvent):
(WebCore::EventHandler::handleMousePressEventTripleClick):
(WebCore::EventHandler::handleMousePressEventSingleClick):
(WebCore::selectionExtentRespectingEditingBoundary):
(WebCore::EventHandler::updateSelectionForMouseDrag):
(WebCore::EventHandler::handleMouseReleaseEvent):

  • page/Frame.cpp:

(WebCore::Frame::visiblePositionForPoint):

  • rendering/RenderBlock.cpp:

(WebCore::RenderBlock::selectionGaps):
(WebCore::RenderBlock::nodeAtPoint):
(WebCore::positionForPointRespectingEditingBoundaries):
(WebCore::RenderBlock::positionForPointWithInlineChildren):
(WebCore::isChildHitTestCandidate):
(WebCore::RenderBlock::positionForPoint):

  • rendering/RenderBlock.h:
  • rendering/RenderBlockFlow.cpp:

(WebCore::RenderBlockFlow::positionForPointWithInlineChildren):
(WebCore::RenderBlockFlow::positionForPoint):

  • rendering/RenderBlockFlow.h:
  • rendering/RenderBox.cpp:

(WebCore::RenderBox::positionForPoint):

  • rendering/RenderBox.h:
  • rendering/RenderFileUploadControl.cpp:

(WebCore::RenderFileUploadControl::positionForPoint):

  • rendering/RenderFileUploadControl.h:
  • rendering/RenderInline.cpp:

(WebCore::RenderInline::positionForPoint):

  • rendering/RenderInline.h:
  • rendering/RenderLineBreak.cpp:

(WebCore::RenderLineBreak::positionForPoint):

  • rendering/RenderLineBreak.h:
  • rendering/RenderMultiColumnSet.cpp:

(WebCore::RenderMultiColumnSet::positionForPoint):

  • rendering/RenderMultiColumnSet.h:
  • rendering/RenderObject.cpp:

(WebCore::RenderObject::positionForPoint):

  • rendering/RenderObject.h:
  • rendering/RenderRegion.cpp:

(WebCore::RenderRegion::positionForPoint):

  • rendering/RenderRegion.h:
  • rendering/RenderReplaced.cpp:

(WebCore::RenderReplaced::positionForPoint):

  • rendering/RenderReplaced.h:
  • rendering/RenderText.cpp:

(WebCore::RenderText::positionForPoint):

  • rendering/RenderText.h:
  • rendering/svg/RenderSVGInlineText.cpp:

(WebCore::RenderSVGInlineText::positionForPoint):

  • rendering/svg/RenderSVGInlineText.h:
  • rendering/svg/RenderSVGText.cpp:

(WebCore::RenderSVGText::positionForPoint):

  • rendering/svg/RenderSVGText.h:

LayoutTests:
Added tests for hit-testing and painting selection gaps in the region's overflow area.

  • fast/regions/selection-in-overflow-expected.html: Added.
  • fast/regions/selection-in-overflow-hit-testing-expected.html: Added.
  • fast/regions/selection-in-overflow-hit-testing.html: Added.
  • fast/regions/selection-in-overflow.html: Added.
  • fast/regions/selection-in-text-after-overflow-hit-testing-expected.html: Added.
  • fast/regions/selection-in-text-after-overflow-hit-testing.html: Added.
Location:
trunk
Files:
6 added
34 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r167800 r167803  
     12014-04-25  Radu Stavila  <stavila@adobe.com>
     2
     3        [CSS Regions] Overflow selection doesn't work properly
     4        https://bugs.webkit.org/show_bug.cgi?id=130715
     5
     6        Reviewed by David Hyatt.
     7
     8        Added tests for hit-testing and painting selection gaps in the region's overflow area.
     9
     10        * fast/regions/selection-in-overflow-expected.html: Added.
     11        * fast/regions/selection-in-overflow-hit-testing-expected.html: Added.
     12        * fast/regions/selection-in-overflow-hit-testing.html: Added.
     13        * fast/regions/selection-in-overflow.html: Added.
     14        * fast/regions/selection-in-text-after-overflow-hit-testing-expected.html: Added.
     15        * fast/regions/selection-in-text-after-overflow-hit-testing.html: Added.
     16
    1172014-04-25  Enrique Ocaña González  <eocanha@igalia.com>
    218

  • trunk/Source/WebCore/ChangeLog

    r167802 r167803  
     12014-04-25  Radu Stavila  <stavila@adobe.com>
     2
     3        [CSS Regions] Overflow selection doesn't work properly
     4        https://bugs.webkit.org/show_bug.cgi?id=130715
     5
     6        Reviewed by David Hyatt.
     7
     8        When hit-testing, painting block selection gaps and searching for the node at a specific point inside a flow thread,
     9        the region range of the box being checked must be validated in order to not return false positives. Otherwise, hit-testing
     10        at the top of region B could hit elements that overflow the bottom of region A.
     11
     12        Tests: fast/regions/selection-in-overflow-hit-testing.html
     13               fast/regions/selection-in-overflow.html
     14               fast/regions/selection-in-text-after-overflow-hit-testing.html
     15
     16        * accessibility/AccessibilityRenderObject.cpp:
     17        (WebCore::AccessibilityRenderObject::visiblePositionRangeForLine):
     18        (WebCore::AccessibilityRenderObject::visiblePositionForPoint):
     19        * dom/Document.cpp:
     20        (WebCore::Document::caretRangeFromPoint):
     21        * editing/FrameSelection.cpp:
     22        (WebCore::FrameSelection::contains):
     23        * editing/VisibleUnits.cpp:
     24        (WebCore::previousLinePosition):
     25        (WebCore::nextLinePosition):
     26        * page/EventHandler.cpp:
     27        (WebCore::EventHandler::selectClosestWordFromHitTestResult):
     28        (WebCore::EventHandler::selectClosestWordOrLinkFromMouseEvent):
     29        (WebCore::EventHandler::handleMousePressEventTripleClick):
     30        (WebCore::EventHandler::handleMousePressEventSingleClick):
     31        (WebCore::selectionExtentRespectingEditingBoundary):
     32        (WebCore::EventHandler::updateSelectionForMouseDrag):
     33        (WebCore::EventHandler::handleMouseReleaseEvent):
     34        * page/Frame.cpp:
     35        (WebCore::Frame::visiblePositionForPoint):
     36        * rendering/RenderBlock.cpp:
     37        (WebCore::RenderBlock::selectionGaps):
     38        (WebCore::RenderBlock::nodeAtPoint):
     39        (WebCore::positionForPointRespectingEditingBoundaries):
     40        (WebCore::RenderBlock::positionForPointWithInlineChildren):
     41        (WebCore::isChildHitTestCandidate):
     42        (WebCore::RenderBlock::positionForPoint):
     43        * rendering/RenderBlock.h:
     44        * rendering/RenderBlockFlow.cpp:
     45        (WebCore::RenderBlockFlow::positionForPointWithInlineChildren):
     46        (WebCore::RenderBlockFlow::positionForPoint):
     47        * rendering/RenderBlockFlow.h:
     48        * rendering/RenderBox.cpp:
     49        (WebCore::RenderBox::positionForPoint):
     50        * rendering/RenderBox.h:
     51        * rendering/RenderFileUploadControl.cpp:
     52        (WebCore::RenderFileUploadControl::positionForPoint):
     53        * rendering/RenderFileUploadControl.h:
     54        * rendering/RenderInline.cpp:
     55        (WebCore::RenderInline::positionForPoint):
     56        * rendering/RenderInline.h:
     57        * rendering/RenderLineBreak.cpp:
     58        (WebCore::RenderLineBreak::positionForPoint):
     59        * rendering/RenderLineBreak.h:
     60        * rendering/RenderMultiColumnSet.cpp:
     61        (WebCore::RenderMultiColumnSet::positionForPoint):
     62        * rendering/RenderMultiColumnSet.h:
     63        * rendering/RenderObject.cpp:
     64        (WebCore::RenderObject::positionForPoint):
     65        * rendering/RenderObject.h:
     66        * rendering/RenderRegion.cpp:
     67        (WebCore::RenderRegion::positionForPoint):
     68        * rendering/RenderRegion.h:
     69        * rendering/RenderReplaced.cpp:
     70        (WebCore::RenderReplaced::positionForPoint):
     71        * rendering/RenderReplaced.h:
     72        * rendering/RenderText.cpp:
     73        (WebCore::RenderText::positionForPoint):
     74        * rendering/RenderText.h:
     75        * rendering/svg/RenderSVGInlineText.cpp:
     76        (WebCore::RenderSVGInlineText::positionForPoint):
     77        * rendering/svg/RenderSVGInlineText.h:
     78        * rendering/svg/RenderSVGText.cpp:
     79        (WebCore::RenderSVGText::positionForPoint):
     80        * rendering/svg/RenderSVGText.h:
     81
    1822014-04-25  Philippe Normand  <pnormand@igalia.com>
    283

  • trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp

    r166649 r167803  
    18251825    // FIXME: this is wrong when lineNumber is lineCount+1,  because nextLinePosition takes you to the
    18261826    // last offset of the last line
    1827     VisiblePosition visiblePos = m_renderer->view().positionForPoint(IntPoint());
     1827    VisiblePosition visiblePos = m_renderer->view().positionForPoint(IntPoint(), nullptr);
    18281828    VisiblePosition savedVisiblePos;
    18291829    while (--lineCount) {
    … …  
    20332033    }
    20342034   
    2035     return innerNode->renderer()->positionForPoint(pointResult);
     2035    return innerNode->renderer()->positionForPoint(pointResult, nullptr);
    20362036}
    20372037

  • trunk/Source/WebCore/dom/Document.cpp

    r167780 r167803  
    14221422    if (!renderer)
    14231423        return nullptr;
    1424     VisiblePosition visiblePosition = renderer->positionForPoint(localPoint);
     1424    VisiblePosition visiblePosition = renderer->positionForPoint(localPoint, nullptr);
    14251425    if (visiblePosition.isNull())
    14261426        return nullptr;

  • trunk/Source/WebCore/editing/FrameSelection.cpp

    r167755 r167803  
    15861586        return false;
    15871587   
    1588     VisiblePosition visiblePos(innerNode->renderer()->positionForPoint(result.localPoint()));
     1588    VisiblePosition visiblePos(innerNode->renderer()->positionForPoint(result.localPoint(), nullptr));
    15891589    if (visiblePos.isNull())
    15901590        return false;

  • trunk/Source/WebCore/editing/VisibleUnits.cpp

    r167642 r167803  
    974974        if (node && editingIgnoresContent(node))
    975975            return positionInParentBeforeNode(node);
    976         return renderer.positionForPoint(pointInLine);
     976        return renderer.positionForPoint(pointInLine, nullptr);
    977977    }
    978978   
    … …  
    10321032        if (node && editingIgnoresContent(node))
    10331033            return positionInParentBeforeNode(node);
    1034         return renderer.positionForPoint(pointInLine);
     1034        return renderer.positionForPoint(pointInLine, nullptr);
    10351035    }
    10361036

  • trunk/Source/WebCore/page/EventHandler.cpp

    r167788 r167803  
    526526
    527527    if (targetNode && targetNode->renderer()) {
    528         VisiblePosition pos(targetNode->renderer()->positionForPoint(result.localPoint()));
     528        VisiblePosition pos(targetNode->renderer()->positionForPoint(result.localPoint(), nullptr));
    529529        if (pos.isNotNull()) {
    530530            newSelection = VisibleSelection(pos);
    … …  
    557557        VisibleSelection newSelection;
    558558        Element* URLElement = result.hitTestResult().URLElement();
    559         VisiblePosition pos(targetNode->renderer()->positionForPoint(result.localPoint()));
     559        VisiblePosition pos(targetNode->renderer()->positionForPoint(result.localPoint(), nullptr));
    560560        if (pos.isNotNull() && pos.deepEquivalent().deprecatedNode()->isDescendantOf(URLElement))
    561561            newSelection = VisibleSelection::selectionFromContentsOfNode(URLElement);
    … …  
    593593
    594594    VisibleSelection newSelection;
    595     VisiblePosition pos(targetNode->renderer()->positionForPoint(event.localPoint()));
     595    VisiblePosition pos(targetNode->renderer()->positionForPoint(event.localPoint(), nullptr));
    596596    if (pos.isNotNull()) {
    597597        newSelection = VisibleSelection(pos);
    … …  
    628628    }
    629629
    630     VisiblePosition visiblePos(targetNode->renderer()->positionForPoint(event.localPoint()));
     630    VisiblePosition visiblePos(targetNode->renderer()->positionForPoint(event.localPoint(), nullptr));
    631631    if (visiblePos.isNull())
    632632        visiblePos = VisiblePosition(firstPositionInOrBeforeNode(targetNode), DOWNSTREAM);
    … …  
    861861    }
    862862
    863     return targetNode->renderer()->positionForPoint(selectionEndPoint);
     863    return targetNode->renderer()->positionForPoint(selectionEndPoint, nullptr);
    864864}
    865865
    … …  
    907907    } else {
    908908        // Reset base for user select all when base is inside user-select-all area and extent < base.
    909         if (rootUserSelectAllForMousePressNode && comparePositions(target->renderer()->positionForPoint(hitTestResult.localPoint()), m_mousePressNode->renderer()->positionForPoint(m_dragStartPos)) < 0)
     909        if (rootUserSelectAllForMousePressNode && comparePositions(target->renderer()->positionForPoint(hitTestResult.localPoint(), nullptr), m_mousePressNode->renderer()->positionForPoint(m_dragStartPos, nullptr)) < 0)
    910910            newSelection.setBase(positionAfterNode(rootUserSelectAllForMousePressNode).downstream(CanCrossEditingBoundary));
    911911       
    912912        Node* rootUserSelectAllForTarget = Position::rootUserSelectAllForNode(target);
    913         if (rootUserSelectAllForTarget && m_mousePressNode->renderer() && comparePositions(target->renderer()->positionForPoint(hitTestResult.localPoint()), m_mousePressNode->renderer()->positionForPoint(m_dragStartPos)) < 0)
     913        if (rootUserSelectAllForTarget && m_mousePressNode->renderer() && comparePositions(target->renderer()->positionForPoint(hitTestResult.localPoint(), nullptr), m_mousePressNode->renderer()->positionForPoint(m_dragStartPos, nullptr)) < 0)
    914914            newSelection.setExtent(positionBeforeNode(rootUserSelectAllForTarget).upstream(CanCrossEditingBoundary));
    915915        else if (rootUserSelectAllForTarget && m_mousePressNode->renderer())
    … …  
    983983        bool caretBrowsing = m_frame.settings().caretBrowsingEnabled();
    984984        if (node && node->renderer() && (caretBrowsing || node->hasEditableStyle())) {
    985             VisiblePosition pos = node->renderer()->positionForPoint(event.localPoint());
     985            VisiblePosition pos = node->renderer()->positionForPoint(event.localPoint(), nullptr);
    986986            newSelection = VisibleSelection(pos);
    987987        }

  • trunk/Source/WebCore/page/Frame.cpp

    r167594 r167803  
    854854    if (!renderer)
    855855        return VisiblePosition();
    856     VisiblePosition visiblePos = renderer->positionForPoint(result.localPoint());
     856    VisiblePosition visiblePos = renderer->positionForPoint(result.localPoint(), nullptr);
    857857    if (visiblePos.isNull())
    858858        visiblePos = firstPositionInOrBeforeNode(node);

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

    r167755 r167803  
    24132413        return result;
    24142414    }
     2415   
     2416    if (paintInfo && paintInfo->renderNamedFlowFragment && paintInfo->paintContainer->isRenderFlowThread()) {
     2417        // Make sure the current object is actually flowed into the region being painted.
     2418        if (!toRenderFlowThread(paintInfo->paintContainer)->objectShouldPaintInFlowRegion(this, paintInfo->renderNamedFlowFragment))
     2419            return result;
     2420    }
    24152421
    24162422    if (childrenInline())
    … …  
    29472953    LayoutPoint adjustedLocation(accumulatedOffset + location());
    29482954    LayoutSize localOffset = toLayoutSize(adjustedLocation);
     2955
     2956    // If we are now searching inside a region, make sure this element
     2957    // is being fragmented into this region.
     2958    if (locationInContainer.region()) {
     2959        RenderFlowThread* flowThread = flowThreadContainingBlock();
     2960        ASSERT(flowThread);
     2961        if (!flowThread->objectShouldPaintInFlowRegion(this, locationInContainer.region()))
     2962            return false;
     2963    }
    29492964
    29502965    if (!isRenderView()) {
    … …  
    31413156    Element* childElement= child.nonPseudoElement();
    31423157    if (!childElement)
    3143         return child.positionForPoint(pointInChildCoordinates);
     3158        return child.positionForPoint(pointInChildCoordinates, nullptr);
    31443159
    31453160    // Otherwise, first make sure that the editability of the parent and child agree.
    … …  
    31513166    // If we can't find an ancestor to check editability on, or editability is unchanged, we recur like normal
    31523167    if (isEditingBoundary(ancestor, child))
    3153         return child.positionForPoint(pointInChildCoordinates);
     3168        return child.positionForPoint(pointInChildCoordinates, nullptr);
    31543169   
    31553170#if PLATFORM(IOS)
    … …  
    31703185}
    31713186
    3172 VisiblePosition RenderBlock::positionForPointWithInlineChildren(const LayoutPoint&)
     3187VisiblePosition RenderBlock::positionForPointWithInlineChildren(const LayoutPoint&, const RenderRegion*)
    31733188{
    31743189    ASSERT_NOT_REACHED();
    … …  
    31823197
    31833198// Valid candidates in a FlowThread must be rendered by the region.
    3184 static inline bool isChildHitTestCandidate(const RenderBox& box, RenderRegion* region, const LayoutPoint& point)
     3199static inline bool isChildHitTestCandidate(const RenderBox& box, const RenderRegion* region, const LayoutPoint& point)
    31853200{
    31863201    if (!isChildHitTestCandidate(box))
    … …  
    31923207}
    31933208
    3194 VisiblePosition RenderBlock::positionForPoint(const LayoutPoint& point)
     3209VisiblePosition RenderBlock::positionForPoint(const LayoutPoint& point, const RenderRegion* region)
    31953210{
    31963211    if (isTable())
    3197         return RenderBox::positionForPoint(point);
     3212        return RenderBox::positionForPoint(point, region);
    31983213
    31993214    if (isReplaced()) {
    … …  
    32153230
    32163231    if (childrenInline())
    3217         return positionForPointWithInlineChildren(pointInLogicalContents);
    3218 
    3219     RenderRegion* region = regionAtBlockOffset(pointInLogicalContents.y());
     3232        return positionForPointWithInlineChildren(pointInLogicalContents, region);
     3233
    32203234    RenderBox* lastCandidateBox = lastChildBox();
     3235
     3236    if (!region)
     3237        region = regionAtBlockOffset(pointInLogicalContents.y());
     3238
    32213239    while (lastCandidateBox && !isChildHitTestCandidate(*lastCandidateBox, region, pointInLogicalContents))
    32223240        lastCandidateBox = lastCandidateBox->previousSiblingBox();
    … …  
    32403258
    32413259    // We only get here if there are no hit test candidate children below the click.
    3242     return RenderBox::positionForPoint(point);
     3260    return RenderBox::positionForPoint(point, region);
    32433261}
    32443262

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

    r167093 r167803  
    184184    LayoutUnit textIndentOffset() const;
    185185
    186     virtual VisiblePosition positionForPoint(const LayoutPoint&) override;
     186    virtual VisiblePosition positionForPoint(const LayoutPoint&, const RenderRegion*) override;
    187187   
    188188    // Block flows subclass availableWidth to handle multi column layout (shrinking the width available to children when laying out.)
    … …  
    544544   
    545545    // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
    546     virtual VisiblePosition positionForPointWithInlineChildren(const LayoutPoint&);
     546    virtual VisiblePosition positionForPointWithInlineChildren(const LayoutPoint&, const RenderRegion*);
    547547
    548548    virtual void computeColumnCountAndWidth();

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

    r167617 r167803  
    30933093}
    30943094
    3095 VisiblePosition RenderBlockFlow::positionForPointWithInlineChildren(const LayoutPoint& pointInLogicalContents)
     3095VisiblePosition RenderBlockFlow::positionForPointWithInlineChildren(const LayoutPoint& pointInLogicalContents, const RenderRegion* region)
    30963096{
    30973097    ASSERT(childrenInline());
    … …  
    31103110    RootInlineBox* lastRootBoxWithChildren = 0;
    31113111    for (RootInlineBox* root = firstRootBox(); root; root = root->nextRootBox()) {
     3112        if (region && root->containingRegion() != region)
     3113            continue;
     3114
    31123115        if (!root->firstLeafChild())
    31133116            continue;
    … …  
    31663169        if (closestBox->renderer().isReplaced())
    31673170            return positionForPointRespectingEditingBoundaries(*this, toRenderBox(closestBox->renderer()), point);
    3168         return closestBox->renderer().positionForPoint(point);
     3171        return closestBox->renderer().positionForPoint(point, nullptr);
    31693172    }
    31703173
    … …  
    31833186}
    31843187
    3185 VisiblePosition RenderBlockFlow::positionForPoint(const LayoutPoint& point)
     3188VisiblePosition RenderBlockFlow::positionForPoint(const LayoutPoint& point, const RenderRegion* region)
    31863189{
    31873190    if (auto fragment = renderNamedFlowFragment())
    3188         return fragment->positionForPoint(point);
    3189     return RenderBlock::positionForPoint(point);
     3191        return fragment->positionForPoint(point, region);
     3192    return RenderBlock::positionForPoint(point, region);
    31903193}
    31913194

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

    r167617 r167803  
    286286    virtual void deleteLines() override;
    287287    virtual void computeOverflow(LayoutUnit oldClientAfterEdge, bool recomputeFloats = false) override;
    288     virtual VisiblePosition positionForPoint(const LayoutPoint&) override;
     288    virtual VisiblePosition positionForPoint(const LayoutPoint&, const RenderRegion*) override;
    289289
    290290    void removeFloatingObjects();
    … …  
    511511   
    512512    Position positionForBox(InlineBox*, bool start = true) const;
    513     virtual VisiblePosition positionForPointWithInlineChildren(const LayoutPoint& pointInLogicalContents) override;
     513    virtual VisiblePosition positionForPointWithInlineChildren(const LayoutPoint& pointInLogicalContents, const RenderRegion*) override;
    514514    virtual void addFocusRingRectsForInlineChildren(Vector<IntRect>& rects, const LayoutPoint& additionalOffset, const RenderLayerModelObject*) override;
    515515

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

    r167771 r167803  
    41304130}
    41314131
    4132 VisiblePosition RenderBox::positionForPoint(const LayoutPoint& point)
     4132VisiblePosition RenderBox::positionForPoint(const LayoutPoint& point, const RenderRegion* region)
    41334133{
    41344134    // no children...return this render object's element, if there is one, and offset 0
    … …  
    41574157        if (!renderObject->isBox())
    41584158            continue;
     4159
     4160        if (isRenderFlowThread()) {
     4161            ASSERT(region);
     4162            if (!toRenderFlowThread(this)->objectShouldPaintInFlowRegion(renderObject, region))
     4163                continue;
     4164        }
     4165
    41594166        RenderBox* renderer = toRenderBox(renderObject);
    41604167
    … …  
    41704177        if (point.x() <= right && point.x() >= left && point.y() <= top && point.y() >= bottom) {
    41714178            if (renderer->isTableRow())
    4172                 return renderer->positionForPoint(point + adjustedPoint - renderer->locationOffset());
    4173             return renderer->positionForPoint(point - renderer->locationOffset());
     4179                return renderer->positionForPoint(point + adjustedPoint - renderer->locationOffset(), region);
     4180            return renderer->positionForPoint(point - renderer->locationOffset(), region);
    41744181        }
    41754182
    … …  
    42084215   
    42094216    if (closestRenderer)
    4210         return closestRenderer->positionForPoint(adjustedPoint - closestRenderer->locationOffset());
     4217        return closestRenderer->positionForPoint(adjustedPoint - closestRenderer->locationOffset(), region);
    42114218   
    42124219    return createVisiblePosition(firstPositionInOrBeforeNode(nonPseudoElement()));

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

    r167727 r167803  
    513513    LayoutRect maskClipRect();
    514514
    515     virtual VisiblePosition positionForPoint(const LayoutPoint&) override;
     515    virtual VisiblePosition positionForPoint(const LayoutPoint&, const RenderRegion*) override;
    516516
    517517    RenderBlockFlow* outermostBlockContainingFloatingObject();

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

    r167755 r167803  
    247247}
    248248
    249 VisiblePosition RenderFileUploadControl::positionForPoint(const LayoutPoint&)
     249VisiblePosition RenderFileUploadControl::positionForPoint(const LayoutPoint&, const RenderRegion*)
    250250{
    251251    return VisiblePosition();

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

    r163560 r167803  
    5858    int maxFilenameWidth() const;
    5959   
    60     virtual VisiblePosition positionForPoint(const LayoutPoint&) override;
     60    virtual VisiblePosition positionForPoint(const LayoutPoint&, const RenderRegion*) override;
    6161
    6262    HTMLInputElement* uploadButton() const;

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

    r167524 r167803  
    846846}
    847847
    848 VisiblePosition RenderInline::positionForPoint(const LayoutPoint& point)
     848VisiblePosition RenderInline::positionForPoint(const LayoutPoint& point, const RenderRegion* region)
    849849{
    850850    // FIXME: Does not deal with relative or sticky positioned inlines (should it?)
    … …  
    853853        // This inline actually has a line box.  We must have clicked in the border/padding of one of these boxes.  We
    854854        // should try to find a result by asking our containing block.
    855         return cb->positionForPoint(point);
     855        return cb->positionForPoint(point, region);
    856856    }
    857857
    … …  
    862862        RenderBox* contBlock = c->isInline() ? c->containingBlock() : toRenderBlock(c);
    863863        if (c->isInline() || c->firstChild())
    864             return c->positionForPoint(parentBlockPoint - contBlock->locationOffset());
     864            return c->positionForPoint(parentBlockPoint - contBlock->locationOffset(), region);
    865865        c = toRenderBlock(c)->inlineElementContinuation();
    866866    }
    867867   
    868     return RenderBoxModelObject::positionForPoint(point);
     868    return RenderBoxModelObject::positionForPoint(point, region);
    869869}
    870870

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

    r165836 r167803  
    145145    virtual const RenderObject* pushMappingToContainer(const RenderLayerModelObject* ancestorToStopAt, RenderGeometryMap&) const override;
    146146
    147     virtual VisiblePosition positionForPoint(const LayoutPoint&) override final;
     147    virtual VisiblePosition positionForPoint(const LayoutPoint&, const RenderRegion*) override final;
    148148
    149149    virtual LayoutRect frameRectForStickyPositioning() const override final { return linesBoundingBox(); }

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

    r158842 r167803  
    123123}
    124124
    125 VisiblePosition RenderLineBreak::positionForPoint(const LayoutPoint&)
     125VisiblePosition RenderLineBreak::positionForPoint(const LayoutPoint&, const RenderRegion*)
    126126{
    127127    return createVisiblePosition(0, DOWNSTREAM);

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

    r162198 r167803  
    5959    virtual void paint(PaintInfo&, const LayoutPoint&) override final { }
    6060
    61     virtual VisiblePosition positionForPoint(const LayoutPoint&) override;
     61    virtual VisiblePosition positionForPoint(const LayoutPoint&, const RenderRegion*) override;
    6262    virtual int caretMinOffset() const override;
    6363    virtual int caretMaxOffset() const override;

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

    r167764 r167803  
    868868}
    869869
    870 VisiblePosition RenderMultiColumnSet::positionForPoint(const LayoutPoint& physicalPoint)
     870VisiblePosition RenderMultiColumnSet::positionForPoint(const LayoutPoint& physicalPoint, const RenderRegion*)
    871871{
    872872    // Determine which columns we intersect.
    … …  
    915915                flipForWritingMode(portion);
    916916                point.move(isHorizontalWritingMode() ? LayoutUnit() : portion.x(), isHorizontalWritingMode() ? portion.y() : LayoutUnit());
    917                 return multiColumnFlowThread()->positionForPoint(point);
     917                return multiColumnFlowThread()->positionForPoint(point, this);
    918918            }
    919919
    … …  
    952952                point.move(isHorizontalWritingMode() ? LayoutUnit() : portion.x(), isHorizontalWritingMode() ? portion.y() : LayoutUnit());
    953953               
    954                 return multiColumnFlowThread()->positionForPoint(point);
     954                return multiColumnFlowThread()->positionForPoint(point, this);
    955955            }
    956956

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

    r167597 r167803  
    143143    virtual void adjustRegionBoundsFromFlowThreadPortionRect(const LayoutPoint& layerOffset, LayoutRect& regionBounds) override;
    144144
    145     virtual VisiblePosition positionForPoint(const LayoutPoint&) override;
     145    virtual VisiblePosition positionForPoint(const LayoutPoint&, const RenderRegion*) override;
    146146
    147147    virtual const char* renderName() const;

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

    r167755 r167803  
    20022002}
    20032003
    2004 VisiblePosition RenderObject::positionForPoint(const LayoutPoint&)
     2004VisiblePosition RenderObject::positionForPoint(const LayoutPoint&, const RenderRegion*)
    20052005{
    20062006    return createVisiblePosition(caretMinOffset(), DOWNSTREAM);

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

    r167755 r167803  
    6060class RenderLayerModelObject;
    6161class RenderNamedFlowThread;
     62class RenderRegion;
    6263class RenderTheme;
    6364class SelectionSubtreeRoot;
    … …  
    649650    virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction);
    650651
    651     virtual VisiblePosition positionForPoint(const LayoutPoint&);
     652    virtual VisiblePosition positionForPoint(const LayoutPoint&, const RenderRegion*);
    652653    VisiblePosition createVisiblePosition(int offset, EAffinity) const;
    653654    VisiblePosition createVisiblePosition(const Position&) const;

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

    r167541 r167803  
    105105}
    106106
    107 VisiblePosition RenderRegion::positionForPoint(const LayoutPoint& point)
     107VisiblePosition RenderRegion::positionForPoint(const LayoutPoint& point, const RenderRegion* region)
    108108{
    109109    if (!isValid() || !m_flowThread->firstChild()) // checking for empty region blocks.
    110         return RenderBlock::positionForPoint(point);
    111 
    112     return m_flowThread->positionForPoint(mapRegionPointIntoFlowThreadCoordinates(point));
     110        return RenderBlock::positionForPoint(point, region);
     111
     112    return m_flowThread->positionForPoint(mapRegionPointIntoFlowThreadCoordinates(point), this);
    113113}
    114114

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

    r167335 r167803  
    125125    virtual bool canHaveChildren() const override { return false; }
    126126    virtual bool canHaveGeneratedChildren() const override { return true; }
    127     virtual VisiblePosition positionForPoint(const LayoutPoint&) override;
     127    virtual VisiblePosition positionForPoint(const LayoutPoint&, const RenderRegion*) override;
    128128
    129129    virtual bool hasAutoLogicalHeight() const { return false; }

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

    r165699 r167803  
    518518}
    519519
    520 VisiblePosition RenderReplaced::positionForPoint(const LayoutPoint& point)
     520VisiblePosition RenderReplaced::positionForPoint(const LayoutPoint& point, const RenderRegion* region)
    521521{
    522522    // FIXME: This code is buggy if the replaced element is relative positioned.
    … …  
    542542    }
    543543
    544     return RenderBox::positionForPoint(point);
     544    return RenderBox::positionForPoint(point, region);
    545545}
    546546

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

    r165479 r167803  
    8080    virtual LayoutRect clippedOverflowRectForRepaint(const RenderLayerModelObject* repaintContainer) const override;
    8181
    82     virtual VisiblePosition positionForPoint(const LayoutPoint&) override final;
     82    virtual VisiblePosition positionForPoint(const LayoutPoint&, const RenderRegion*) override final;
    8383   
    8484    virtual bool canBeSelectionLeaf() const override { return true; }

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

    r167568 r167803  
    432432}
    433433
    434 VisiblePosition RenderText::positionForPoint(const LayoutPoint& point)
     434VisiblePosition RenderText::positionForPoint(const LayoutPoint& point, const RenderRegion*)
    435435{
    436436    ensureLineBoxes();

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

    r167568 r167803  
    7373    Vector<FloatQuad> absoluteQuadsClippedToEllipsis() const;
    7474
    75     virtual VisiblePosition positionForPoint(const LayoutPoint&) override;
     75    virtual VisiblePosition positionForPoint(const LayoutPoint&, const RenderRegion*) override;
    7676
    7777    bool is8Bit() const { return m_text.impl()->is8Bit(); }

  • trunk/Source/WebCore/rendering/svg/RenderSVGInlineText.cpp

    r165676 r167803  
    167167}
    168168
    169 VisiblePosition RenderSVGInlineText::positionForPoint(const LayoutPoint& point)
     169VisiblePosition RenderSVGInlineText::positionForPoint(const LayoutPoint& point, const RenderRegion*)
    170170{
    171171    if (!firstTextBox() || !textLength())

  • trunk/Source/WebCore/rendering/svg/RenderSVGInlineText.h

    r163440 r167803  
    6060    virtual bool isSVGInlineText() const override { return true; }
    6161
    62     virtual VisiblePosition positionForPoint(const LayoutPoint&) override;
     62    virtual VisiblePosition positionForPoint(const LayoutPoint&, const RenderRegion*) override;
    6363    virtual LayoutRect localCaretRect(InlineBox*, int caretOffset, LayoutUnit* extraWidthToEndOfLine = 0) override;
    6464    virtual IntRect linesBoundingBox() const override;

  • trunk/Source/WebCore/rendering/svg/RenderSVGText.cpp

    r165676 r167803  
    466466}
    467467
    468 VisiblePosition RenderSVGText::positionForPoint(const LayoutPoint& pointInContents)
     468VisiblePosition RenderSVGText::positionForPoint(const LayoutPoint& pointInContents, const RenderRegion* region)
    469469{
    470470    RootInlineBox* rootBox = firstRootBox();
    … …  
    480480        return createVisiblePosition(0, DOWNSTREAM);
    481481
    482     return closestBox->renderer().positionForPoint(LayoutPoint(pointInContents.x(), closestBox->y()));
     482    return closestBox->renderer().positionForPoint(LayoutPoint(pointInContents.x(), closestBox->y()), region);
    483483}
    484484

  • trunk/Source/WebCore/rendering/svg/RenderSVGText.h

    r165676 r167803  
    7171    virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) override;
    7272    virtual bool nodeAtFloatPoint(const HitTestRequest&, HitTestResult&, const FloatPoint& pointInParent, HitTestAction);
    73     virtual VisiblePosition positionForPoint(const LayoutPoint&);
     73    virtual VisiblePosition positionForPoint(const LayoutPoint&, const RenderRegion*);
    7474
    7575    virtual bool requiresLayer() const { return false; }
Note: See TracChangeset for help on using the changeset viewer.