自学教程：C++ toLayoutSize函数代码示例

bool hitTestFlow(const RenderBlockFlow& flow, const Layout& layout, const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction){    if (hitTestAction != HitTestForeground)        return false;    if (!layout.runCount())        return false;    RenderStyle& style = flow.style();    if (style.visibility() != VISIBLE || style.pointerEvents() == PE_NONE)        return false;    RenderObject& renderer = *flow.firstChild();    LayoutRect rangeRect = locationInContainer.boundingBox();    rangeRect.moveBy(-accumulatedOffset);    auto resolver = lineResolver(flow, layout);    for (FloatRect lineRect : resolver.rangeForRect(rangeRect)) {        lineRect.moveBy(accumulatedOffset);        if (!locationInContainer.intersects(lineRect))            continue;        renderer.updateHitTestResult(result, locationInContainer.point() - toLayoutSize(accumulatedOffset));        if (!result.addNodeToRectBasedTestResult(renderer.node(), request, locationInContainer, lineRect))            return true;    }    return false;}

void RenderView::mapLocalToContainer(const RenderLayerModelObject* repaintContainer, TransformState& transformState, MapCoordinatesFlags mode, bool* wasFixed) const{    ASSERT_UNUSED(wasFixed, !wasFixed || *wasFixed == static_cast<bool>(mode & IsFixed));    if (!repaintContainer && mode & UseTransforms && shouldUseTransformFromContainer(0)) {        TransformationMatrix t;        getTransformFromContainer(0, LayoutSize(), t);        transformState.applyTransform(t);    }    if (mode & IsFixed && m_frameView)        transformState.move(m_frameView->scrollOffsetForFixedPosition());    if (repaintContainer == this)        return;    if (mode & TraverseDocumentBoundaries) {        if (RenderObject* parentDocRenderer = frame()->ownerRenderer()) {            transformState.move(-frame()->view()->scrollOffset());            if (parentDocRenderer->isBox())                transformState.move(toLayoutSize(toRenderBox(parentDocRenderer)->contentBoxRect().location()));            parentDocRenderer->mapLocalToContainer(repaintContainer, transformState, mode, wasFixed);            return;        }    }    // If a container was specified, and was not 0 or the RenderView,    // then we should have found it by now.    ASSERT_ARG(repaintContainer, !repaintContainer);}

LayoutPoint ScrollableArea::constrainScrollPositionForOverhang(const LayoutRect& visibleContentRect, const LayoutSize& totalContentsSize, const LayoutPoint& scrollPosition, const LayoutPoint& scrollOrigin, int headerHeight, int footerHeight){    // The viewport rect that we're scrolling shouldn't be larger than our document.    LayoutSize idealScrollRectSize(std::min(visibleContentRect.width(), totalContentsSize.width()), std::min(visibleContentRect.height(), totalContentsSize.height()));        LayoutRect scrollRect(scrollPosition + scrollOrigin - LayoutSize(0, headerHeight), idealScrollRectSize);    LayoutRect documentRect(LayoutPoint(), LayoutSize(totalContentsSize.width(), totalContentsSize.height() - headerHeight - footerHeight));    // Use intersection to constrain our ideal scroll rect by the document rect.    scrollRect.intersect(documentRect);    if (scrollRect.size() != idealScrollRectSize) {        // If the rect was clipped, restore its size, effectively pushing it "down" from the top left.        scrollRect.setSize(idealScrollRectSize);        // If we still clip, push our rect "up" from the bottom right.        scrollRect.intersect(documentRect);        if (scrollRect.width() < idealScrollRectSize.width())            scrollRect.move(-(idealScrollRectSize.width() - scrollRect.width()), 0);        if (scrollRect.height() < idealScrollRectSize.height())            scrollRect.move(0, -(idealScrollRectSize.height() - scrollRect.height()));    }    return scrollRect.location() - toLayoutSize(scrollOrigin);}

MouseRelatedEvent::MouseRelatedEvent(const AtomicString& eventType, bool canBubble, bool cancelable, PassRefPtr<AbstractView> abstractView,                                     int detail, const IntPoint& screenLocation, const IntPoint& windowLocation,                                     const IntPoint& movementDelta,                                     bool ctrlKey, bool altKey, bool shiftKey, bool metaKey, bool isSimulated)    : UIEventWithKeyState(eventType, canBubble, cancelable, abstractView, detail, ctrlKey, altKey, shiftKey, metaKey)    , m_screenLocation(screenLocation)    , m_movementDelta(movementDelta)    , m_isSimulated(isSimulated){    LayoutPoint adjustedPageLocation;    LayoutPoint scrollPosition;    LocalFrame* frame = view() ? view()->frame() : 0;    if (frame && !isSimulated) {        if (FrameView* frameView = frame->view()) {            scrollPosition = frameView->scrollPosition();            adjustedPageLocation = frameView->windowToContents(windowLocation);            float scaleFactor = 1 / frame->pageZoomFactor();            if (scaleFactor != 1.0f) {                adjustedPageLocation.scale(scaleFactor, scaleFactor);                scrollPosition.scale(scaleFactor, scaleFactor);            }        }    }    m_clientLocation = adjustedPageLocation - toLayoutSize(scrollPosition);    m_pageLocation = adjustedPageLocation;    initCoordinates();}

void MouseRelatedEvent::computeRelativePosition(){    Node* targetNode = target() ? target()->toNode() : 0;    if (!targetNode)        return;    // Compute coordinates that are based on the target.    m_layerLocation = m_pageLocation;    m_offsetLocation = m_pageLocation;    // Must have an updated render tree for this math to work correctly.    targetNode->document().updateLayoutIgnorePendingStylesheets();    // Adjust offsetLocation to be relative to the target's position.    if (RenderObject* r = targetNode->renderer()) {        FloatPoint localPos = r->absoluteToLocal(absoluteLocation(), UseTransforms);        m_offsetLocation = roundedLayoutPoint(localPos);    }    // Adjust layerLocation to be relative to the layer.    // FIXME: event.layerX and event.layerY are poorly defined,    // and probably don't always correspond to RenderLayer offsets.    // https://bugs.webkit.org/show_bug.cgi?id=21868    Node* n = targetNode;    while (n && !n->renderer())        n = n->parentNode();    if (n) {        // FIXME: This logic is a wrong implementation of convertToLayerCoords.        for (RenderLayer* layer = n->renderer()->enclosingLayer(); layer; layer = layer->parent())            m_layerLocation -= toLayoutSize(layer->location());    }    m_hasCachedRelativePosition = true;}

const RenderObject* RenderView::pushMappingToContainer(const RenderLayerModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const{    LayoutSize offsetForFixedPosition;    LayoutSize offset;    RenderObject* container = 0;    if (m_frameView)        offsetForFixedPosition = m_frameView->scrollOffsetForFixedPosition();    if (geometryMap.mapCoordinatesFlags() & TraverseDocumentBoundaries) {        if (RenderPart* parentDocRenderer = frame()->ownerRenderer()) {            offset = -m_frameView->scrollOffset();            offset += toLayoutSize(parentDocRenderer->contentBoxRect().location());            container = parentDocRenderer;        }    }    // If a container was specified, and was not 0 or the RenderView, then we    // should have found it by now unless we're traversing to a parent document.    ASSERT_ARG(ancestorToStopAt, !ancestorToStopAt || ancestorToStopAt == this || container);    if ((!ancestorToStopAt || container) && shouldUseTransformFromContainer(container)) {        TransformationMatrix t;        getTransformFromContainer(container, LayoutSize(), t);        geometryMap.push(this, t, false, false, false, true, offsetForFixedPosition);    } else {        geometryMap.push(this, offset, false, false, false, false, offsetForFixedPosition);    }    return container;}

bool EllipsisBox::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, LayoutUnit lineTop, LayoutUnit lineBottom){    LayoutPoint adjustedLocation = accumulatedOffset + roundedLayoutPoint(topLeft());    // Hit test the markup box.    if (InlineBox* markupBox = this->markupBox()) {        RenderStyle* style = renderer().style(isFirstLineStyle());        LayoutUnit mtx = adjustedLocation.x() + m_logicalWidth - markupBox->x();        LayoutUnit mty = adjustedLocation.y() + style->fontMetrics().ascent() - (markupBox->y() + markupBox->renderer().style(isFirstLineStyle())->fontMetrics().ascent());        if (markupBox->nodeAtPoint(request, result, locationInContainer, LayoutPoint(mtx, mty), lineTop, lineBottom)) {            renderer().updateHitTestResult(result, locationInContainer.point() - LayoutSize(mtx, mty));            return true;        }    }    FloatPoint boxOrigin = locationIncludingFlipping();    boxOrigin.moveBy(accumulatedOffset);    FloatRect boundsRect(boxOrigin, size());    if (visibleToHitTestRequest(request) && boundsRect.intersects(HitTestLocation::rectForPoint(locationInContainer.point(), 0, 0, 0, 0))) {        renderer().updateHitTestResult(result, locationInContainer.point() - toLayoutSize(adjustedLocation));        if (!result.addNodeToRectBasedTestResult(renderer().node(), request, locationInContainer, boundsRect))            return true;    }    return false;}

void PaintPropertyTreeBuilder::updatePerspective(    const LayoutObject& object,    PaintPropertyTreeBuilderContext& context) {  const ComputedStyle& style = object.styleRef();  if (object.isBox() && style.hasPerspective()) {    // The perspective node must not flatten (else nothing will get    // perspective), but it should still extend the rendering context as    // most transform nodes do.    TransformationMatrix matrix =        TransformationMatrix().applyPerspective(style.perspective());    FloatPoint3D origin = perspectiveOrigin(toLayoutBox(object)) +                          toLayoutSize(context.current.paintOffset);    object.getMutableForPainting().ensurePaintProperties().updatePerspective(        context.current.transform, matrix, origin,        context.current.shouldFlattenInheritedTransform,        context.current.renderingContextID);  } else {    if (auto* properties = object.getMutableForPainting().paintProperties())      properties->clearPerspective();  }  const auto* properties = object.paintProperties();  if (properties && properties->perspective()) {    context.current.transform = properties->perspective();    context.current.shouldFlattenInheritedTransform = false;  }}

void RenderView::mapLocalToContainer(const RenderLayerModelObject* paintInvalidationContainer, TransformState& transformState, MapCoordinatesFlags mode, bool* wasFixed, const PaintInvalidationState* paintInvalidationState) const{    ASSERT_UNUSED(wasFixed, !wasFixed || *wasFixed == static_cast<bool>(mode & IsFixed));    if (!paintInvalidationContainer && mode & UseTransforms && shouldUseTransformFromContainer(0)) {        TransformationMatrix t;        getTransformFromContainer(0, LayoutSize(), t);        transformState.applyTransform(t);    }    if ((mode & IsFixed) && m_frameView) {        transformState.move(m_frameView->scrollOffsetForFixedPosition());        // IsFixed flag is only applicable within this RenderView.        mode &= ~IsFixed;    }    if (paintInvalidationContainer == this)        return;    if (mode & TraverseDocumentBoundaries) {        if (RenderObject* parentDocRenderer = frame()->ownerRenderer()) {            transformState.move(-frame()->view()->scrollOffset());            if (parentDocRenderer->isBox())                transformState.move(toLayoutSize(toRenderBox(parentDocRenderer)->contentBoxRect().location()));            parentDocRenderer->mapLocalToContainer(paintInvalidationContainer, transformState, mode, wasFixed, paintInvalidationState);            return;        }    }}

bool SVGInlineTextBox::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, LayoutUnit, LayoutUnit){    // FIXME: integrate with InlineTextBox::nodeAtPoint better.    ASSERT(!isLineBreak());    PointerEventsHitRules hitRules(PointerEventsHitRules::SVG_TEXT_HITTESTING, request, renderer().style()->pointerEvents());    bool isVisible = renderer().style()->visibility() == VISIBLE;    if (isVisible || !hitRules.requireVisible) {        if (hitRules.canHitBoundingBox            || (hitRules.canHitStroke && (renderer().style()->svgStyle().hasStroke() || !hitRules.requireStroke))            || (hitRules.canHitFill && (renderer().style()->svgStyle().hasFill() || !hitRules.requireFill))) {            FloatPointWillBeLayoutPoint boxOrigin(x(), y());            boxOrigin.moveBy(accumulatedOffset);            FloatRectWillBeLayoutRect rect(boxOrigin, size());            // FIXME: both calls to rawValue() below is temporary and should be removed once the transition            // to LayoutUnit-based types is complete (crbug.com/321237)            if (locationInContainer.intersects(rect.rawValue())) {                renderer().updateHitTestResult(result, locationInContainer.point() - toLayoutSize(accumulatedOffset));                if (!result.addNodeToRectBasedTestResult(renderer().node(), request, locationInContainer, rect.rawValue()))                    return true;             }        }    }    return false;}

bool LineBoxList::hitTest(LayoutBoxModelObject* renderer, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction) const{    if (hitTestAction != HitTestForeground)        return false;    ASSERT(renderer->isLayoutBlock() || (renderer->isLayoutInline() && renderer->hasLayer())); // The only way an inline could hit test like this is if it has a layer.    // If we have no lines then we have no work to do.    if (!firstLineBox())        return false;    LayoutPoint point = locationInContainer.point();    LayoutRect rect(firstLineBox()->isHorizontal() ?                    IntRect(point.x(), point.y() - locationInContainer.topPadding(), 1, locationInContainer.topPadding() + locationInContainer.bottomPadding() + 1) :                    IntRect(point.x() - locationInContainer.leftPadding(), point.y(), locationInContainer.rightPadding() + locationInContainer.leftPadding() + 1, 1));    if (!anyLineIntersectsRect(renderer, rect, accumulatedOffset))        return false;    // See if our root lines contain the point.  If so, then we hit test    // them further.  Note that boxes can easily overlap, so we can't make any assumptions    // based off positions of our first line box or our last line box.    for (InlineFlowBox* curr = lastLineBox(); curr; curr = curr->prevLineBox()) {        RootInlineBox& root = curr->root();        if (rangeIntersectsRect(renderer, curr->logicalTopVisualOverflow(root.lineTop()), curr->logicalBottomVisualOverflow(root.lineBottom()), rect, accumulatedOffset)) {            bool inside = curr->nodeAtPoint(result, locationInContainer, accumulatedOffset, root.lineTop(), root.lineBottom());            if (inside) {                renderer->updateHitTestResult(result, locationInContainer.point() - toLayoutSize(accumulatedOffset));                return true;            }        }    }    return false;}

bool RootInlineBox::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, LayoutUnit lineTop, LayoutUnit lineBottom){    if (hasEllipsisBox() && visibleToHitTesting()) {        if (ellipsisBox()->nodeAtPoint(request, result, locationInContainer, accumulatedOffset, lineTop, lineBottom)) {            renderer().updateHitTestResult(result, locationInContainer.point() - toLayoutSize(accumulatedOffset));            return true;        }    }    return InlineFlowBox::nodeAtPoint(request, result, locationInContainer, accumulatedOffset, lineTop, lineBottom);}

static PassRefPtr<TransformPaintPropertyNode> createPerspectiveIfNeeded(const LayoutObject& object, PaintPropertyTreeBuilderContext& context){    const ComputedStyle& style = object.styleRef();    if (!object.isBox() || !style.hasPerspective())        return nullptr;    RefPtr<TransformPaintPropertyNode> newTransformNodeForPerspective = TransformPaintPropertyNode::create(        TransformationMatrix().applyPerspective(style.perspective()),        perspectiveOrigin(toLayoutBox(object)) + toLayoutSize(context.paintOffset), context.currentTransform);    context.currentTransform = newTransformNodeForPerspective.get();    return newTransformNodeForPerspective.release();}

void LayoutTextControl::hitInnerEditorElement(HitTestResult& result, const LayoutPoint& pointInContainer, const LayoutPoint& accumulatedOffset){    HTMLElement* innerEditor = innerEditorElement();    if (!innerEditor->layoutObject())        return;    LayoutPoint adjustedLocation = accumulatedOffset + location();    LayoutPoint localPoint = pointInContainer - toLayoutSize(adjustedLocation + innerEditor->layoutBox()->location());    if (hasOverflowClip())        localPoint += scrolledContentOffset();    result.setNodeAndPosition(innerEditor, localPoint);}

bool SVGInlineTextBox::nodeAtPoint(HitTestResult& result,                                   const HitTestLocation& locationInContainer,                                   const LayoutPoint& accumulatedOffset,                                   LayoutUnit,                                   LayoutUnit) {  // FIXME: integrate with InlineTextBox::nodeAtPoint better.  ASSERT(!isLineBreak());  PointerEventsHitRules hitRules(PointerEventsHitRules::SVG_TEXT_HITTESTING,                                 result.hitTestRequest(),                                 getLineLayoutItem().style()->pointerEvents());  bool isVisible =      getLineLayoutItem().style()->visibility() == EVisibility::Visible;  if (isVisible || !hitRules.requireVisible) {    if (hitRules.canHitBoundingBox ||        (hitRules.canHitStroke &&         (getLineLayoutItem().style()->svgStyle().hasStroke() ||          !hitRules.requireStroke)) ||        (hitRules.canHitFill &&         (getLineLayoutItem().style()->svgStyle().hasFill() ||          !hitRules.requireFill))) {      LayoutRect rect(topLeft(), LayoutSize(logicalWidth(), logicalHeight()));      rect.moveBy(accumulatedOffset);      if (locationInContainer.intersects(rect)) {        LineLayoutSVGInlineText lineLayoutItem =            LineLayoutSVGInlineText(this->getLineLayoutItem());        const SimpleFontData* fontData =            lineLayoutItem.scaledFont().primaryFont();        DCHECK(fontData);        if (!fontData)          return false;        DCHECK(lineLayoutItem.scalingFactor());        float baseline = fontData->getFontMetrics().floatAscent() /                         lineLayoutItem.scalingFactor();        FloatPoint floatLocation = FloatPoint(locationInContainer.point());        for (const SVGTextFragment& fragment : m_textFragments) {          FloatQuad fragmentQuad = fragment.boundingQuad(baseline);          if (fragmentQuad.containsPoint(floatLocation)) {            lineLayoutItem.updateHitTestResult(                result,                locationInContainer.point() - toLayoutSize(accumulatedOffset));            if (result.addNodeToListBasedTestResult(lineLayoutItem.node(),                                                    locationInContainer,                                                    rect) == StopHitTesting)              return true;          }        }      }    }  }  return false;}

void RenderTextControl::hitInnerTextElement(HitTestResult& result, const LayoutPoint& pointInContainer, const LayoutPoint& accumulatedOffset){    TextControlInnerTextElement* innerText = innerTextElement();    if (!innerText->renderer())        return;    LayoutPoint adjustedLocation = accumulatedOffset + location();    LayoutPoint localPoint = pointInContainer - toLayoutSize(adjustedLocation + innerText->renderBox()->location()) + scrolledContentOffset();    result.setInnerNode(innerText);    result.setInnerNonSharedNode(innerText);    result.setLocalPoint(localPoint);}

bool LayoutSVGRoot::nodeAtPoint(HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction){    LayoutPoint pointInParent = locationInContainer.point() - toLayoutSize(accumulatedOffset);    LayoutPoint pointInBorderBox = pointInParent - toLayoutSize(location());    // Only test SVG content if the point is in our content box, or in case we    // don't clip to the viewport, the visual overflow rect.    // FIXME: This should be an intersection when rect-based hit tests are supported by nodeAtFloatPoint.    if (contentBoxRect().contains(pointInBorderBox) || (!shouldApplyViewportClip() && visualOverflowRect().contains(pointInBorderBox))) {        const AffineTransform& localToParentTransform = this->localToParentTransform();        if (localToParentTransform.isInvertible()) {            FloatPoint localPoint = localToParentTransform.inverse().mapPoint(FloatPoint(pointInParent));            for (LayoutObject* child = lastChild(); child; child = child->previousSibling()) {                // FIXME: nodeAtFloatPoint() doesn't handle rect-based hit tests yet.                if (child->nodeAtFloatPoint(result, localPoint, hitTestAction)) {                    updateHitTestResult(result, pointInBorderBox);                    if (result.addNodeToListBasedTestResult(child->node(), locationInContainer) == StopHitTesting)                        return true;                }            }        }    }    // If we didn't early exit above, we've just hit the container <svg> element. Unlike SVG 1.1, 2nd Edition allows container elements to be hit.    if ((hitTestAction == HitTestBlockBackground || hitTestAction == HitTestChildBlockBackground) && visibleToHitTestRequest(result.hitTestRequest())) {        // Only return true here, if the last hit testing phase 'BlockBackground' (or 'ChildBlockBackground' - depending on context) is executed.        // If we'd return true in the 'Foreground' phase, hit testing would stop immediately. For SVG only trees this doesn't matter.        // Though when we have a <foreignObject> subtree we need to be able to detect hits on the background of a <div> element.        // If we'd return true here in the 'Foreground' phase, we are not able to detect these hits anymore.        LayoutRect boundsRect(accumulatedOffset + location(), size());        if (locationInContainer.intersects(boundsRect)) {            updateHitTestResult(result, pointInBorderBox);            if (result.addNodeToListBasedTestResult(node(), locationInContainer, boundsRect) == StopHitTesting)                return true;        }    }    return false;}

void PaintPropertyTreeBuilder::updatePerspective(const LayoutObject& object, PaintPropertyTreeBuilderContext& context){    const ComputedStyle& style = object.styleRef();    if (!object.isBox() || !style.hasPerspective())        return;    RefPtr<TransformPaintPropertyNode> perspective = TransformPaintPropertyNode::create(        TransformationMatrix().applyPerspective(style.perspective()),        perspectiveOrigin(toLayoutBox(object)) + toLayoutSize(context.paintOffset),        context.currentTransform);    context.currentTransform = perspective.get();    object.getMutableForPainting().ensureObjectPaintProperties().setPerspective(perspective.release());}

void RenderTextControl::hitInnerEditorElement(HitTestResult& result, const LayoutPoint& pointInContainer, const LayoutPoint& accumulatedOffset){    HTMLElement* innerEditor = innerEditorElement();    if (!innerEditor->renderer())        return;    LayoutPoint adjustedLocation = accumulatedOffset + location();    LayoutPoint localPoint = pointInContainer - toLayoutSize(adjustedLocation + innerEditor->renderBox()->location());    if (hasOverflowClip())        localPoint += scrolledContentOffset();    result.setInnerNode(innerEditor);    result.setInnerNonSharedNode(innerEditor);    result.setLocalPoint(localPoint);}

void MouseRelatedEvent::computeRelativePosition(){    Node* targetNode = target() ? target()->toNode() : nullptr;    if (!targetNode)        return;    // Compute coordinates that are based on the target.    m_layerLocation = m_pageLocation;    m_offsetLocation = m_pageLocation;    // Must have an updated layout tree for this math to work correctly.    targetNode->document().updateLayoutIgnorePendingStylesheets();    // Adjust offsetLocation to be relative to the target's padding box.    if (LayoutObject* r = targetNode->layoutObject()) {        FloatPoint localPos = r->absoluteToLocal(FloatPoint(absoluteLocation()), UseTransforms);        // Adding this here to address crbug.com/570666. Basically we'd like to        // find the local coordinates relative to the padding box not the border box.        if (r->isBoxModelObject()) {            LayoutBoxModelObject* layoutBox = toLayoutBoxModelObject(r);            localPos.move(-layoutBox->borderLeft(), -layoutBox->borderTop());        }        m_offsetLocation = roundedLayoutPoint(localPos);        float scaleFactor = 1 / pageZoomFactor(this);        if (scaleFactor != 1.0f)            m_offsetLocation.scale(scaleFactor, scaleFactor);    }    // Adjust layerLocation to be relative to the layer.    // FIXME: event.layerX and event.layerY are poorly defined,    // and probably don't always correspond to PaintLayer offsets.    // https://bugs.webkit.org/show_bug.cgi?id=21868    Node* n = targetNode;    while (n && !n->layoutObject())        n = n->parentNode();    if (n) {        // FIXME: This logic is a wrong implementation of convertToLayerCoords.        for (PaintLayer* layer = n->layoutObject()->enclosingLayer(); layer; layer = layer->parent())            m_layerLocation -= toLayoutSize(layer->location());    }    m_hasCachedRelativePosition = true;}

bool EllipsisBox::nodeAtPoint(HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, LayoutUnit lineTop, LayoutUnit lineBottom){    // FIXME: the call to roundedLayoutPoint() below is temporary and should be removed once    // the transition to LayoutUnit-based types is complete (crbug.com/321237)    LayoutPoint adjustedLocation = accumulatedOffset + topLeft();    LayoutPoint boxOrigin = locationIncludingFlipping();    boxOrigin.moveBy(accumulatedOffset);    LayoutRect boundsRect(boxOrigin, size());    if (visibleToHitTestRequest(result.hitTestRequest()) && boundsRect.intersects(LayoutRect(HitTestLocation::rectForPoint(locationInContainer.point(), 0, 0, 0, 0)))) {        lineLayoutItem().updateHitTestResult(result, locationInContainer.point() - toLayoutSize(adjustedLocation));        if (result.addNodeToListBasedTestResult(lineLayoutItem().node(), locationInContainer, boundsRect) == StopHitTesting)            return true;    }    return false;}

void MouseRelatedEvent::computeRelativePosition(){    Node* targetNode = target() ? target()->toNode() : 0;    if (!targetNode)        return;    // Compute coordinates that are based on the target.    m_layerLocation = m_pageLocation;    m_offsetLocation = m_pageLocation;    // Must have an updated render tree for this math to work correctly.    targetNode->document()->updateStyleIfNeeded();    // Adjust offsetLocation to be relative to the target's position.    if (!isSimulated()) {        if (RenderObject* r = targetNode->renderer()) {            FloatPoint localPos = r->absoluteToLocal(absoluteLocation(), UseTransforms | SnapOffsetForTransforms);            m_offsetLocation = roundedLayoutPoint(localPos);            float scaleFactor = 1 / (pageZoomFactor(this) * frameScaleFactor(this));            if (scaleFactor != 1.0f)                m_offsetLocation.scale(scaleFactor, scaleFactor);        }    }    // Adjust layerLocation to be relative to the layer.    // FIXME: We're pretty sure this is the wrong definition of "layer."    // Our RenderLayer is a more modern concept, and layerX/Y is some    // other notion about groups of elements (left over from the Netscape 4 days?);    // we should test and fix this.    Node* n = targetNode;    while (n && !n->renderer())        n = n->parentNode();    RenderLayer* layer;    if (n && (layer = n->renderer()->enclosingLayer())) {        layer->updateLayerPosition();        for (; layer; layer = layer->parent()) {            m_layerLocation -= toLayoutSize(layer->location());        }    }    m_hasCachedRelativePosition = true;}

bool RenderMultiColumnSet::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction action){    LayoutPoint adjustedLocation = accumulatedOffset + location();    // Check our bounds next. For this purpose always assume that we can only be hit in the    // foreground phase (which is true for replaced elements like images).    // FIXME: Once we support overflow, we need to intersect with that and not with the bounds rect.    LayoutRect boundsRect = borderBoxRectInRegion(locationInContainer.region());    boundsRect.moveBy(adjustedLocation);    if (!visibleToHitTesting() || action != HitTestForeground || !locationInContainer.intersects(boundsRect))        return false;        // The point is in one specific column. Since columns can't overlap, we don't ever have to test    // multiple columns. Put the         // FIXME: It would be nice to jump right to the specific column by just doing math on the point. Since columns    // can't overlap, we shouldn't have to walk every column like this. The old column code walked all the columns, though,    // so this is no worse. We'd have to watch out for rect-based hit testing, though, which actually could overlap    // multiple columns.    LayoutUnit colGap = columnGap();    unsigned colCount = columnCount();    for (unsigned i = 0; i < colCount; i++) {        // First we get the column rect, which is in our local coordinate space, and we make it physical and apply        // the hit test offset to it. That gives us the physical location that we want to paint the column at.        LayoutRect colRect = columnRectAt(i);        flipForWritingMode(colRect);        colRect.moveBy(adjustedLocation);                // Next we get the portion of the flow thread that corresponds to this column.        LayoutRect flowThreadPortion = flowThreadPortionRectAt(i);                // Now get the overflow rect that corresponds to the column.        LayoutRect flowThreadOverflowPortion = flowThreadPortionOverflowRect(flowThreadPortion, i, colCount, colGap);        // Do the hit test with the computed rects.        if (flowThread()->hitTestFlowThreadPortionInRegion(this, flowThreadPortion, flowThreadOverflowPortion, request, result, locationInContainer, colRect.location()))            return true;    }        updateHitTestResult(result, locationInContainer.point() - toLayoutSize(adjustedLocation));    return !result.addNodeToRectBasedTestResult(node(), request, locationInContainer, boundsRect);}

void RenderGeometryMap::pushMappingsToAncestor(    const RenderLayer* layer,    const RenderLayer* ancestorLayer) {  const RenderObject* renderer = layer->renderer();  bool crossDocument = false;  ASSERT(!crossDocument || m_mapCoordinatesFlags & TraverseDocumentBoundaries);  // We have to visit all the renderers to detect flipped blocks. This might  // defeat the gains from mapping via layers.  bool canConvertInLayerTree =      (ancestorLayer && !crossDocument)          ? canMapBetweenRenderers(layer->renderer(), ancestorLayer->renderer())          : false;  //    fprintf(stderr, "RenderGeometryMap::pushMappingsToAncestor from layer %p  //    to layer %p, canConvertInLayerTree=%d/n", layer, ancestorLayer,  //    canConvertInLayerTree);  if (canConvertInLayerTree) {    LayoutPoint layerOffset;    layer->convertToLayerCoords(ancestorLayer, layerOffset);    // The RenderView must be pushed first.    if (!m_mapping.size()) {      ASSERT(ancestorLayer->renderer()->isRenderView());      pushMappingsToAncestor(ancestorLayer->renderer(), 0);    }    TemporaryChange<size_t> positionChange(m_insertionPosition,                                           m_mapping.size());    bool accumulatingTransform =        layer->renderer()->style()->preserves3D() ||        ancestorLayer->renderer()->style()->preserves3D();    push(renderer, toLayoutSize(layerOffset), accumulatingTransform,         /*isNonUniform*/ false, /*hasTransform*/ false);    return;  }  const RenderBox* ancestorRenderer =      ancestorLayer ? ancestorLayer->renderer() : 0;  pushMappingsToAncestor(renderer, ancestorRenderer);}