<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[170273] trunk/Source/WebCore</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/170273">170273</a></dd>
<dt>Author</dt> <dd>zalan@apple.com</dd>
<dt>Date</dt> <dd>2014-06-22 17:34:25 -0700 (Sun, 22 Jun 2014)</dd>
</dl>
<h3>Log Message</h3>
<pre>Transition layer offsets from LayoutPoint to LayoutSize.
https://bugs.webkit.org/show_bug.cgi?id=134156
Reviewed by Simon Fraser.
Use better representation for offset values.
No change in functionality.
* platform/graphics/LayoutSize.h:
(WebCore::roundedForPainting):
* rendering/RenderFlowThread.cpp:
(WebCore::RenderFlowThread::fragmentsBoundingBox):
* rendering/RenderLayer.cpp:
(WebCore::expandClipRectForDescendantsAndReflection):
(WebCore::RenderLayer::convertToLayerCoords):
(WebCore::computeReferenceBox):
(WebCore::RenderLayer::setupClipPath):
(WebCore::RenderLayer::setupFilters):
(WebCore::RenderLayer::paintLayerContents):
(WebCore::RenderLayer::paintLayerByApplyingTransform):
(WebCore::RenderLayer::collectFragments):
(WebCore::RenderLayer::updatePaintingInfoForFragments):
(WebCore::RenderLayer::paintTransformedLayerIntoFragments):
(WebCore::RenderLayer::createLocalTransformState):
(WebCore::RenderLayer::hitTestTransformedLayerInFragments):
(WebCore::RenderLayer::hitTestLayerByApplyingTransform):
(WebCore::RenderLayer::calculateClipRects):
* rendering/RenderLayer.h:
* rendering/RenderMultiColumnSet.cpp:
(WebCore::RenderMultiColumnSet::collectLayerFragments):</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceWebCoreChangeLog">trunk/Source/WebCore/ChangeLog</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderFlowThreadcpp">trunk/Source/WebCore/rendering/RenderFlowThread.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderLayercpp">trunk/Source/WebCore/rendering/RenderLayer.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderLayerh">trunk/Source/WebCore/rendering/RenderLayer.h</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderMultiColumnSetcpp">trunk/Source/WebCore/rendering/RenderMultiColumnSet.cpp</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/ChangeLog (170272 => 170273)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog 2014-06-23 00:13:49 UTC (rev 170272)
+++ trunk/Source/WebCore/ChangeLog 2014-06-23 00:34:25 UTC (rev 170273)
</span><span class="lines">@@ -1,3 +1,37 @@
</span><ins>+2014-06-22 Zalan Bujtas <zalan@apple.com>
+
+ Transition layer offsets from LayoutPoint to LayoutSize.
+ https://bugs.webkit.org/show_bug.cgi?id=134156
+
+ Reviewed by Simon Fraser.
+
+ Use better representation for offset values.
+
+ No change in functionality.
+
+ * platform/graphics/LayoutSize.h:
+ (WebCore::roundedForPainting):
+ * rendering/RenderFlowThread.cpp:
+ (WebCore::RenderFlowThread::fragmentsBoundingBox):
+ * rendering/RenderLayer.cpp:
+ (WebCore::expandClipRectForDescendantsAndReflection):
+ (WebCore::RenderLayer::convertToLayerCoords):
+ (WebCore::computeReferenceBox):
+ (WebCore::RenderLayer::setupClipPath):
+ (WebCore::RenderLayer::setupFilters):
+ (WebCore::RenderLayer::paintLayerContents):
+ (WebCore::RenderLayer::paintLayerByApplyingTransform):
+ (WebCore::RenderLayer::collectFragments):
+ (WebCore::RenderLayer::updatePaintingInfoForFragments):
+ (WebCore::RenderLayer::paintTransformedLayerIntoFragments):
+ (WebCore::RenderLayer::createLocalTransformState):
+ (WebCore::RenderLayer::hitTestTransformedLayerInFragments):
+ (WebCore::RenderLayer::hitTestLayerByApplyingTransform):
+ (WebCore::RenderLayer::calculateClipRects):
+ * rendering/RenderLayer.h:
+ * rendering/RenderMultiColumnSet.cpp:
+ (WebCore::RenderMultiColumnSet::collectLayerFragments):
+
</ins><span class="cx"> 2014-06-22 Dean Jackson <dino@apple.com>
</span><span class="cx">
</span><span class="cx"> Attempted iOS build fix.
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderFlowThreadcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderFlowThread.cpp (170272 => 170273)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderFlowThread.cpp 2014-06-23 00:13:49 UTC (rev 170272)
+++ trunk/Source/WebCore/rendering/RenderFlowThread.cpp 2014-06-23 00:34:25 UTC (rev 170273)
</span><span class="lines">@@ -1159,7 +1159,7 @@
</span><span class="cx"> for (const auto& fragment : fragments) {
</span><span class="cx"> LayoutRect fragmentRect(layerBoundingBox);
</span><span class="cx"> fragmentRect.intersect(fragment.paginationClip);
</span><del>- fragmentRect.moveBy(fragment.paginationOffset);
</del><ins>+ fragmentRect.move(fragment.paginationOffset);
</ins><span class="cx"> result.unite(fragmentRect);
</span><span class="cx"> }
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderLayercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderLayer.cpp (170272 => 170273)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderLayer.cpp 2014-06-23 00:13:49 UTC (rev 170272)
+++ trunk/Source/WebCore/rendering/RenderLayer.cpp 2014-06-23 00:34:25 UTC (rev 170273)
</span><span class="lines">@@ -1590,7 +1590,7 @@
</span><span class="cx"> // size into the parent layer.
</span><span class="cx"> if (layer->renderer().hasReflection()) {
</span><span class="cx"> LayoutSize delta = layer->offsetFromAncestor(rootLayer);
</span><del>- clipRect.move(-delta.width(), -delta.height());
</del><ins>+ clipRect.move(-delta);
</ins><span class="cx"> clipRect.unite(layer->renderBox()->reflectedRect(clipRect));
</span><span class="cx"> clipRect.move(delta);
</span><span class="cx"> }
</span><span class="lines">@@ -2000,7 +2000,7 @@
</span><span class="cx"> {
</span><span class="cx"> LayoutPoint delta = convertToLayerCoords(ancestorLayer, LayoutPoint(), adjustForColumns);
</span><span class="cx"> LayoutRect rectInLayerCoords = rect;
</span><del>- rectInLayerCoords.move(-delta.x(), -delta.y());
</del><ins>+ rectInLayerCoords.moveBy(-delta);
</ins><span class="cx"> return rectInLayerCoords;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -3754,7 +3754,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template <class ReferenceBoxClipPathOperation>
</span><del>-static inline LayoutRect computeReferenceBox(const RenderObject& renderer, const ReferenceBoxClipPathOperation& clippingPath, const LayoutPoint& offsetFromRoot, const LayoutRect& rootRelativeBounds)
</del><ins>+static inline LayoutRect computeReferenceBox(const RenderObject& renderer, const ReferenceBoxClipPathOperation& clippingPath, const LayoutSize& offsetFromRoot, const LayoutRect& rootRelativeBounds)
</ins><span class="cx"> {
</span><span class="cx"> // FIXME: Support different reference boxes for inline content.
</span><span class="cx"> // https://bugs.webkit.org/show_bug.cgi?id=129047
</span><span class="lines">@@ -3766,11 +3766,11 @@
</span><span class="cx"> switch (clippingPath.referenceBox()) {
</span><span class="cx"> case ContentBox:
</span><span class="cx"> referenceBox = box.contentBoxRect();
</span><del>- referenceBox.moveBy(offsetFromRoot);
</del><ins>+ referenceBox.move(offsetFromRoot);
</ins><span class="cx"> break;
</span><span class="cx"> case PaddingBox:
</span><span class="cx"> referenceBox = box.paddingBoxRect();
</span><del>- referenceBox.moveBy(offsetFromRoot);
</del><ins>+ referenceBox.move(offsetFromRoot);
</ins><span class="cx"> break;
</span><span class="cx"> // FIXME: Support margin-box. Use bounding client rect for now.
</span><span class="cx"> // https://bugs.webkit.org/show_bug.cgi?id=127984
</span><span class="lines">@@ -3782,14 +3782,14 @@
</span><span class="cx"> case BorderBox:
</span><span class="cx"> case BoxMissing:
</span><span class="cx"> referenceBox = box.borderBoxRect();
</span><del>- referenceBox.moveBy(offsetFromRoot);
</del><ins>+ referenceBox.move(offsetFromRoot);
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> return referenceBox;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool RenderLayer::setupClipPath(GraphicsContext* context, const LayerPaintingInfo& paintingInfo, const LayoutPoint& offsetFromRoot, LayoutRect& rootRelativeBounds, bool& rootRelativeBoundsComputed)
</del><ins>+bool RenderLayer::setupClipPath(GraphicsContext* context, const LayerPaintingInfo& paintingInfo, const LayoutSize& offsetFromRoot, LayoutRect& rootRelativeBounds, bool& rootRelativeBoundsComputed)
</ins><span class="cx"> {
</span><span class="cx"> if (!renderer().hasClipPath() || context->paintingDisabled())
</span><span class="cx"> return false;
</span><span class="lines">@@ -3814,7 +3814,7 @@
</span><span class="cx"> BoxClipPathOperation& clippingPath = toBoxClipPathOperation(*(style.clipPath()));
</span><span class="cx">
</span><span class="cx"> RoundedRect shapeRect = computeRoundedRectForBoxShape(clippingPath.referenceBox(), toRenderBox(renderer()));
</span><del>- shapeRect.moveBy(offsetFromRoot);
</del><ins>+ shapeRect.move(offsetFromRoot);
</ins><span class="cx">
</span><span class="cx"> context->save();
</span><span class="cx"> context->clipPath(clippingPath.pathForReferenceRect(shapeRect), RULE_NONZERO);
</span><span class="lines">@@ -3836,7 +3836,7 @@
</span><span class="cx">
</span><span class="cx"> #if ENABLE(CSS_FILTERS)
</span><span class="cx">
</span><del>-std::unique_ptr<FilterEffectRendererHelper> RenderLayer::setupFilters(GraphicsContext* context, LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags, const LayoutPoint& offsetFromRoot, LayoutRect& rootRelativeBounds, bool& rootRelativeBoundsComputed)
</del><ins>+std::unique_ptr<FilterEffectRendererHelper> RenderLayer::setupFilters(GraphicsContext* context, LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags, const LayoutSize& offsetFromRoot, LayoutRect& rootRelativeBounds, bool& rootRelativeBoundsComputed)
</ins><span class="cx"> {
</span><span class="cx"> if (context->paintingDisabled())
</span><span class="cx"> return nullptr;
</span><span class="lines">@@ -3854,7 +3854,7 @@
</span><span class="cx"> return nullptr;
</span><span class="cx">
</span><span class="cx"> LayoutRect filterRepaintRect = filterInfo->dirtySourceRect();
</span><del>- filterRepaintRect.move(offsetFromRoot.x(), offsetFromRoot.y());
</del><ins>+ filterRepaintRect.move(offsetFromRoot);
</ins><span class="cx">
</span><span class="cx"> if (!rootRelativeBoundsComputed) {
</span><span class="cx"> rootRelativeBounds = calculateLayerBounds(paintingInfo.rootLayer, &offsetFromRoot, 0);
</span><span class="lines">@@ -3963,7 +3963,7 @@
</span><span class="cx"> && renderer().fixedPositionedWithNamedFlowContainingBlock())
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- LayoutPoint offsetFromRoot = toLayoutPoint(offsetFromAncestor(paintingInfo.rootLayer));
</del><ins>+ LayoutSize offsetFromRoot = offsetFromAncestor(paintingInfo.rootLayer);
</ins><span class="cx"> LayoutRect rootRelativeBounds;
</span><span class="cx"> bool rootRelativeBoundsComputed = false;
</span><span class="cx">
</span><span class="lines">@@ -4094,17 +4094,17 @@
</span><span class="cx"> context->restore();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void RenderLayer::paintLayerByApplyingTransform(GraphicsContext* context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags, const LayoutPoint& translationOffset)
</del><ins>+void RenderLayer::paintLayerByApplyingTransform(GraphicsContext* context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags, const LayoutSize& translationOffset)
</ins><span class="cx"> {
</span><span class="cx"> // This involves subtracting out the position of the layer in our current coordinate space, but preserving
</span><span class="cx"> // the accumulated error for sub-pixel layout.
</span><span class="cx"> float deviceScaleFactor = renderer().document().deviceScaleFactor();
</span><del>- LayoutPoint offsetFromParent = toLayoutPoint(offsetFromAncestor(paintingInfo.rootLayer));
- offsetFromParent.moveBy(translationOffset);
</del><ins>+ LayoutSize offsetFromParent = offsetFromAncestor(paintingInfo.rootLayer);
+ offsetFromParent += translationOffset;
</ins><span class="cx"> TransformationMatrix transform(renderableTransform(paintingInfo.paintBehavior));
</span><del>- FloatPoint devicePixelSnappedOffsetFromParent = roundedForPainting(offsetFromParent, deviceScaleFactor);
</del><ins>+ FloatSize devicePixelSnappedOffsetFromParent = toFloatSize(roundedForPainting(toLayoutPoint(offsetFromParent), deviceScaleFactor));
</ins><span class="cx"> // Translate the graphics context to the snapping position to avoid off-device-pixel positing.
</span><del>- transform.translateRight(devicePixelSnappedOffsetFromParent.x(), devicePixelSnappedOffsetFromParent.y());
</del><ins>+ transform.translateRight(devicePixelSnappedOffsetFromParent.width(), devicePixelSnappedOffsetFromParent.height());
</ins><span class="cx"> // We handle accumulated subpixels through nested layers here. Since the context gets translated to device pixels,
</span><span class="cx"> // all we need to do is add the delta to the accumulated pixels coming from ancestor layers. With deep nesting of subpixel positioned
</span><span class="cx"> // boxes, this could grow to a relatively large number, but the translateRight() balances it.
</span><span class="lines">@@ -4165,7 +4165,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void RenderLayer::collectFragments(LayerFragments& fragments, const RenderLayer* rootLayer, const LayoutRect& dirtyRect, PaginationInclusionMode inclusionMode,
</span><del>- ClipRectsType clipRectsType, OverlayScrollbarSizeRelevancy inOverlayScrollbarSizeRelevancy, ShouldRespectOverflowClip respectOverflowClip, const LayoutPoint* offsetFromRoot,
</del><ins>+ ClipRectsType clipRectsType, OverlayScrollbarSizeRelevancy inOverlayScrollbarSizeRelevancy, ShouldRespectOverflowClip respectOverflowClip, const LayoutSize* offsetFromRoot,
</ins><span class="cx"> const LayoutRect* layerBoundingBox, ShouldApplyRootOffsetToFragments applyRootOffsetToFragments)
</span><span class="cx"> {
</span><span class="cx"> RenderLayer* paginationLayer = enclosingPaginationLayerInSubtree(rootLayer, inclusionMode);
</span><span class="lines">@@ -4179,7 +4179,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // Compute our offset within the enclosing pagination layer.
</span><del>- LayoutPoint offsetWithinPaginatedLayer = toLayoutPoint(offsetFromAncestor(paginationLayer));
</del><ins>+ LayoutSize offsetWithinPaginatedLayer = offsetFromAncestor(paginationLayer);
</ins><span class="cx">
</span><span class="cx"> // Calculate clip rects relative to the enclosingPaginationLayer. The purpose of this call is to determine our bounds clipped to intermediate
</span><span class="cx"> // layers between us and the pagination context. It's important to minimize the number of fragments we need to create and this helps with that.
</span><span class="lines">@@ -4215,7 +4215,7 @@
</span><span class="cx"> for (auto& ancestorFragment : ancestorFragments) {
</span><span class="cx"> // Shift the dirty rect into flow thread coordinates.
</span><span class="cx"> LayoutRect dirtyRectInFlowThread(dirtyRect);
</span><del>- dirtyRectInFlowThread.move(toLayoutPoint(-offsetWithinParentPaginatedLayer) - ancestorFragment.paginationOffset);
</del><ins>+ dirtyRectInFlowThread.move(-offsetWithinParentPaginatedLayer - ancestorFragment.paginationOffset);
</ins><span class="cx">
</span><span class="cx"> size_t oldSize = fragments.size();
</span><span class="cx">
</span><span class="lines">@@ -4235,7 +4235,7 @@
</span><span class="cx"> fragment.setRects(layerBoundsInFlowThread, backgroundRectInFlowThread, foregroundRectInFlowThread, outlineRectInFlowThread, &layerBoundingBoxInFlowThread);
</span><span class="cx">
</span><span class="cx"> // Shift to the root-relative physical position used when painting the flow thread in this fragment.
</span><del>- fragment.moveBy(ancestorFragment.paginationOffset + fragment.paginationOffset + offsetWithinParentPaginatedLayer);
</del><ins>+ fragment.moveBy(toLayoutPoint(ancestorFragment.paginationOffset + fragment.paginationOffset + offsetWithinParentPaginatedLayer));
</ins><span class="cx">
</span><span class="cx"> // Intersect the fragment with our ancestor's background clip so that e.g., columns in an overflow:hidden block are
</span><span class="cx"> // properly clipped by the overflow.
</span><span class="lines">@@ -4280,7 +4280,7 @@
</span><span class="cx"> fragment.setRects(layerBoundsInFlowThread, backgroundRectInFlowThread, foregroundRectInFlowThread, outlineRectInFlowThread, &layerBoundingBoxInFlowThread);
</span><span class="cx">
</span><span class="cx"> // Shift to the root-relative physical position used when painting the flow thread in this fragment.
</span><del>- fragment.moveBy(fragment.paginationOffset + offsetOfPaginationLayerFromRoot);
</del><ins>+ fragment.moveBy(toLayoutPoint(fragment.paginationOffset + offsetOfPaginationLayerFromRoot));
</ins><span class="cx">
</span><span class="cx"> // Intersect the fragment with our ancestor's background clip so that e.g., columns in an overflow:hidden block are
</span><span class="cx"> // properly clipped by the overflow.
</span><span class="lines">@@ -4296,14 +4296,14 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void RenderLayer::updatePaintingInfoForFragments(LayerFragments& fragments, const LayerPaintingInfo& localPaintingInfo, PaintLayerFlags localPaintFlags,
</span><del>- bool shouldPaintContent, const LayoutPoint* offsetFromRoot)
</del><ins>+ bool shouldPaintContent, const LayoutSize* offsetFromRoot)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(offsetFromRoot);
</span><span class="cx"> for (size_t i = 0; i < fragments.size(); ++i) {
</span><span class="cx"> LayerFragment& fragment = fragments.at(i);
</span><span class="cx"> fragment.shouldPaintContent = shouldPaintContent;
</span><span class="cx"> if (this != localPaintingInfo.rootLayer || !(localPaintFlags & PaintLayerPaintingOverflowContents)) {
</span><del>- LayoutPoint newOffsetFromRoot = *offsetFromRoot + fragment.paginationOffset;
</del><ins>+ LayoutSize newOffsetFromRoot = *offsetFromRoot + fragment.paginationOffset;
</ins><span class="cx"> fragment.shouldPaintContent &= intersectsDamageRect(fragment.layerBounds, fragment.backgroundRect.rect(), localPaintingInfo.rootLayer, &newOffsetFromRoot, fragment.hasBoundingBox ? &fragment.boundingBox : 0);
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -4312,7 +4312,7 @@
</span><span class="cx"> void RenderLayer::paintTransformedLayerIntoFragments(GraphicsContext* context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
</span><span class="cx"> {
</span><span class="cx"> LayerFragments enclosingPaginationFragments;
</span><del>- LayoutPoint offsetOfPaginationLayerFromRoot;
</del><ins>+ LayoutSize offsetOfPaginationLayerFromRoot;
</ins><span class="cx"> RenderLayer* paginatedLayer = enclosingPaginationLayer(ExcludeCompositedPaginatedLayers);
</span><span class="cx"> LayoutRect transformedExtent = transparencyClipBox(this, paginatedLayer, PaintingTransparencyClipBox, RootOfTransparencyClipBox, paintingInfo.paintBehavior);
</span><span class="cx"> paginatedLayer->collectFragments(enclosingPaginationFragments, paintingInfo.rootLayer, paintingInfo.paintDirtyRect, ExcludeCompositedPaginatedLayers,
</span><span class="lines">@@ -4328,12 +4328,12 @@
</span><span class="cx">
</span><span class="cx"> // Now compute the clips within a given fragment
</span><span class="cx"> if (parent() != paginatedLayer) {
</span><del>- offsetOfPaginationLayerFromRoot = paginatedLayer->convertToLayerCoords(paintingInfo.rootLayer, offsetOfPaginationLayerFromRoot);
</del><ins>+ offsetOfPaginationLayerFromRoot = toLayoutSize(paginatedLayer->convertToLayerCoords(paintingInfo.rootLayer, toLayoutPoint(offsetOfPaginationLayerFromRoot)));
</ins><span class="cx">
</span><span class="cx"> ClipRectsContext clipRectsContext(paginatedLayer, (paintFlags & PaintLayerTemporaryClipRects) ? TemporaryClipRects : PaintingClipRects,
</span><span class="cx"> IgnoreOverlayScrollbarSize, (paintFlags & PaintLayerPaintingOverflowContents) ? IgnoreOverflowClip : RespectOverflowClip);
</span><span class="cx"> LayoutRect parentClipRect = backgroundClipRect(clipRectsContext).rect();
</span><del>- parentClipRect.moveBy(fragment.paginationOffset + offsetOfPaginationLayerFromRoot);
</del><ins>+ parentClipRect.move(fragment.paginationOffset + offsetOfPaginationLayerFromRoot);
</ins><span class="cx"> clipRect.intersect(parentClipRect);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -4577,7 +4577,7 @@
</span><span class="cx"> PassRefPtr<HitTestingTransformState> RenderLayer::createLocalTransformState(RenderLayer* rootLayer, RenderLayer* containerLayer,
</span><span class="cx"> const LayoutRect& hitTestRect, const HitTestLocation& hitTestLocation,
</span><span class="cx"> const HitTestingTransformState* containerTransformState,
</span><del>- const LayoutPoint& translationOffset) const
</del><ins>+ const LayoutSize& translationOffset) const
</ins><span class="cx"> {
</span><span class="cx"> RefPtr<HitTestingTransformState> transformState;
</span><span class="cx"> LayoutSize offset;
</span><span class="lines">@@ -4591,7 +4591,7 @@
</span><span class="cx"> transformState = HitTestingTransformState::create(hitTestLocation.transformedPoint(), hitTestLocation.transformedRect(), FloatQuad(hitTestRect));
</span><span class="cx"> offset = offsetFromAncestor(rootLayer);
</span><span class="cx"> }
</span><del>- offset += toLayoutSize(translationOffset);
</del><ins>+ offset += translationOffset;
</ins><span class="cx">
</span><span class="cx"> RenderObject* containerRenderer = containerLayer ? &containerLayer->renderer() : 0;
</span><span class="cx"> if (renderer().shouldUseTransformFromContainer(containerRenderer)) {
</span><span class="lines">@@ -4912,7 +4912,7 @@
</span><span class="cx"> const LayoutRect& hitTestRect, const HitTestLocation& hitTestLocation, const HitTestingTransformState* transformState, double* zOffset)
</span><span class="cx"> {
</span><span class="cx"> LayerFragments enclosingPaginationFragments;
</span><del>- LayoutPoint offsetOfPaginationLayerFromRoot;
</del><ins>+ LayoutSize offsetOfPaginationLayerFromRoot;
</ins><span class="cx"> RenderLayer* paginatedLayer = enclosingPaginationLayer(IncludeCompositedPaginatedLayers);
</span><span class="cx"> LayoutRect transformedExtent = transparencyClipBox(this, paginatedLayer, HitTestingTransparencyClipBox, RootOfTransparencyClipBox);
</span><span class="cx"> paginatedLayer->collectFragments(enclosingPaginationFragments, rootLayer, hitTestRect, IncludeCompositedPaginatedLayers,
</span><span class="lines">@@ -4927,11 +4927,11 @@
</span><span class="cx">
</span><span class="cx"> // Now compute the clips within a given fragment
</span><span class="cx"> if (parent() != paginatedLayer) {
</span><del>- offsetOfPaginationLayerFromRoot = paginatedLayer->convertToLayerCoords(rootLayer, offsetOfPaginationLayerFromRoot);
</del><ins>+ offsetOfPaginationLayerFromRoot = toLayoutSize(paginatedLayer->convertToLayerCoords(rootLayer, toLayoutPoint(offsetOfPaginationLayerFromRoot)));
</ins><span class="cx">
</span><span class="cx"> ClipRectsContext clipRectsContext(paginatedLayer, RootRelativeClipRects, IncludeOverlayScrollbarSize);
</span><span class="cx"> LayoutRect parentClipRect = backgroundClipRect(clipRectsContext).rect();
</span><del>- parentClipRect.moveBy(fragment.paginationOffset + offsetOfPaginationLayerFromRoot);
</del><ins>+ parentClipRect.move(fragment.paginationOffset + offsetOfPaginationLayerFromRoot);
</ins><span class="cx"> clipRect.intersect(parentClipRect);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -4949,7 +4949,7 @@
</span><span class="cx">
</span><span class="cx"> RenderLayer* RenderLayer::hitTestLayerByApplyingTransform(RenderLayer* rootLayer, RenderLayer* containerLayer, const HitTestRequest& request, HitTestResult& result,
</span><span class="cx"> const LayoutRect& hitTestRect, const HitTestLocation& hitTestLocation, const HitTestingTransformState* transformState, double* zOffset,
</span><del>- const LayoutPoint& translationOffset)
</del><ins>+ const LayoutSize& translationOffset)
</ins><span class="cx"> {
</span><span class="cx"> // Create a transform state to accumulate this transform.
</span><span class="cx"> RefPtr<HitTestingTransformState> newTransformState = createLocalTransformState(rootLayer, containerLayer, hitTestRect, hitTestLocation, transformState, translationOffset);
</span><span class="lines">@@ -5251,7 +5251,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void RenderLayer::calculateRects(const ClipRectsContext& clipRectsContext, const LayoutRect& paintDirtyRect, LayoutRect& layerBounds,
</span><del>- ClipRect& backgroundRect, ClipRect& foregroundRect, ClipRect& outlineRect, const LayoutPoint* offsetFromRoot) const
</del><ins>+ ClipRect& backgroundRect, ClipRect& foregroundRect, ClipRect& outlineRect, const LayoutSize* offsetFromRoot) const
</ins><span class="cx"> {
</span><span class="cx"> if (clipRectsContext.rootLayer != this && parent()) {
</span><span class="cx"> backgroundRect = backgroundClipRect(clipRectsContext);
</span><span class="lines">@@ -5259,21 +5259,21 @@
</span><span class="cx"> } else
</span><span class="cx"> backgroundRect = paintDirtyRect;
</span><span class="cx">
</span><del>- LayoutPoint offset;
</del><ins>+ LayoutSize offsetFromAcestor;
</ins><span class="cx"> if (offsetFromRoot)
</span><del>- offset = *offsetFromRoot;
</del><ins>+ offsetFromAcestor = *offsetFromRoot;
</ins><span class="cx"> else
</span><del>- offset = toLayoutPoint(offsetFromAncestor(clipRectsContext.rootLayer));
</del><ins>+ offsetFromAcestor = offsetFromAncestor(clipRectsContext.rootLayer);
</ins><span class="cx">
</span><span class="cx"> RenderNamedFlowFragment* namedFlowFragment = currentRenderNamedFlowFragment();
</span><span class="cx"> // If the view is scrolled, the flow thread is not scrolled with it and we should
</span><span class="cx"> // take the scroll offset into account.
</span><span class="cx"> if (clipRectsContext.rootLayer->isOutOfFlowRenderFlowThread() && !namedFlowFragment) {
</span><del>- FloatPoint absPos = renderer().view().localToAbsolute(FloatPoint(), IsFixed);
- offset += LayoutSize(absPos.x(), absPos.y());
</del><ins>+ LayoutPoint absPos = LayoutPoint(renderer().view().localToAbsolute(FloatPoint(), IsFixed));
+ offsetFromAcestor += toLayoutSize(absPos);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- layerBounds = LayoutRect(offset, size());
</del><ins>+ layerBounds = LayoutRect(toLayoutPoint(offsetFromAcestor), size());
</ins><span class="cx">
</span><span class="cx"> foregroundRect = backgroundRect;
</span><span class="cx"> outlineRect = backgroundRect;
</span><span class="lines">@@ -5296,7 +5296,7 @@
</span><span class="cx"> rendererContainingBlock->flipForWritingMode(layerBoundsWithVisualOverflow);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- layerBoundsWithVisualOverflow.moveBy(offset);
</del><ins>+ layerBoundsWithVisualOverflow.move(offsetFromAcestor);
</ins><span class="cx"> backgroundRect.intersect(layerBoundsWithVisualOverflow);
</span><span class="cx">
</span><span class="cx"> foregroundRect = backgroundRect;
</span><span class="lines">@@ -5313,14 +5313,14 @@
</span><span class="cx"> if (renderer().hasClipOrOverflowClip()) {
</span><span class="cx"> // This layer establishes a clip of some kind.
</span><span class="cx"> if (renderer().hasOverflowClip() && (this != clipRectsContext.rootLayer || clipRectsContext.respectOverflowClip == RespectOverflowClip)) {
</span><del>- foregroundRect.intersect(toRenderBox(renderer()).overflowClipRect(offset, namedFlowFragment, clipRectsContext.overlayScrollbarSizeRelevancy));
</del><ins>+ foregroundRect.intersect(toRenderBox(renderer()).overflowClipRect(toLayoutPoint(offsetFromAcestor), namedFlowFragment, clipRectsContext.overlayScrollbarSizeRelevancy));
</ins><span class="cx"> if (renderer().style().hasBorderRadius())
</span><span class="cx"> foregroundRect.setHasRadius(true);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (renderer().hasClip()) {
</span><span class="cx"> // Clip applies to *us* as well, so go ahead and update the damageRect.
</span><del>- LayoutRect newPosClip = toRenderBox(renderer()).clipRect(offset, namedFlowFragment);
</del><ins>+ LayoutRect newPosClip = toRenderBox(renderer()).clipRect(toLayoutPoint(offsetFromAcestor), namedFlowFragment);
</ins><span class="cx"> backgroundRect.intersect(newPosClip);
</span><span class="cx"> foregroundRect.intersect(newPosClip);
</span><span class="cx"> outlineRect.intersect(newPosClip);
</span><span class="lines">@@ -5334,7 +5334,7 @@
</span><span class="cx"> // individual region boxes as overflow.
</span><span class="cx"> LayoutRect layerBoundsWithVisualOverflow = namedFlowFragment ? namedFlowFragment->visualOverflowRectForBox(renderBox()) : renderBox()->visualOverflowRect();
</span><span class="cx"> renderBox()->flipForWritingMode(layerBoundsWithVisualOverflow); // Layers are in physical coordinates, so the overflow has to be flipped.
</span><del>- layerBoundsWithVisualOverflow.moveBy(offset);
</del><ins>+ layerBoundsWithVisualOverflow.move(offsetFromAcestor);
</ins><span class="cx"> if (this != clipRectsContext.rootLayer || clipRectsContext.respectOverflowClip == RespectOverflowClip)
</span><span class="cx"> backgroundRect.intersect(layerBoundsWithVisualOverflow);
</span><span class="cx"> } else {
</span><span class="lines">@@ -5343,7 +5343,7 @@
</span><span class="cx"> if (namedFlowFragment)
</span><span class="cx"> bounds = namedFlowFragment->rectFlowPortionForBox(renderBox(), bounds);
</span><span class="cx">
</span><del>- bounds.moveBy(offset);
</del><ins>+ bounds.move(offsetFromAcestor);
</ins><span class="cx"> if (this != clipRectsContext.rootLayer || clipRectsContext.respectOverflowClip == RespectOverflowClip)
</span><span class="cx"> backgroundRect.intersect(bounds);
</span><span class="cx">
</span><span class="lines">@@ -5394,7 +5394,7 @@
</span><span class="cx"> // FIXME: border-radius not accounted for.
</span><span class="cx"> // FIXME: Regions not accounted for.
</span><span class="cx"> RenderLayer* clippingRootLayer = clippingRootForPainting();
</span><del>- LayoutPoint offsetFromRoot = toLayoutPoint(offsetFromAncestor(clippingRootLayer));
</del><ins>+ LayoutSize offsetFromRoot = offsetFromAncestor(clippingRootLayer);
</ins><span class="cx">
</span><span class="cx"> LayoutRect layerBounds;
</span><span class="cx"> ClipRect backgroundRect, foregroundRect, outlineRect;
</span><span class="lines">@@ -5407,7 +5407,7 @@
</span><span class="cx">
</span><span class="cx"> if (renderer().hasClip()) {
</span><span class="cx"> // CSS clip may be larger than our border box.
</span><del>- LayoutRect cssClipRect = toRenderBox(renderer()).clipRect(offsetFromRoot, currentRenderNamedFlowFragment());
</del><ins>+ LayoutRect cssClipRect = toRenderBox(renderer()).clipRect(toLayoutPoint(offsetFromRoot), currentRenderNamedFlowFragment());
</ins><span class="cx"> clipExceedsBounds = !clipRect.contains(cssClipRect);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -5445,7 +5445,7 @@
</span><span class="cx"> renderer().repaintRectangle(rect);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool RenderLayer::intersectsDamageRect(const LayoutRect& layerBounds, const LayoutRect& damageRect, const RenderLayer* rootLayer, const LayoutPoint* offsetFromRoot, const LayoutRect* cachedBoundingBox) const
</del><ins>+bool RenderLayer::intersectsDamageRect(const LayoutRect& layerBounds, const LayoutRect& damageRect, const RenderLayer* rootLayer, const LayoutSize* offsetFromRoot, const LayoutRect* cachedBoundingBox) const
</ins><span class="cx"> {
</span><span class="cx"> // Always examine the canvas and the root.
</span><span class="cx"> // FIXME: Could eliminate the isRoot() check if we fix background painting so that the RenderView
</span><span class="lines">@@ -5527,7 +5527,7 @@
</span><span class="cx"> return result;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-LayoutRect RenderLayer::boundingBox(const RenderLayer* ancestorLayer, CalculateLayerBoundsFlags flags, const LayoutPoint* offsetFromRoot) const
</del><ins>+LayoutRect RenderLayer::boundingBox(const RenderLayer* ancestorLayer, CalculateLayerBoundsFlags flags, const LayoutSize* offsetFromRoot) const
</ins><span class="cx"> {
</span><span class="cx"> LayoutRect result = localBoundingBox(flags);
</span><span class="cx"> if (renderer().isBox())
</span><span class="lines">@@ -5563,7 +5563,7 @@
</span><span class="cx">
</span><span class="cx"> LayoutSize delta;
</span><span class="cx"> if (offsetFromRoot)
</span><del>- delta = toLayoutSize(*offsetFromRoot);
</del><ins>+ delta = *offsetFromRoot;
</ins><span class="cx"> else
</span><span class="cx"> delta = offsetFromAncestor(ancestorLayer);
</span><span class="cx">
</span><span class="lines">@@ -5581,7 +5581,7 @@
</span><span class="cx"> return pixelSnappedForPainting(boundingBox(root()), renderer().document().deviceScaleFactor());
</span><span class="cx"> }
</span><span class="cx">
</span><del>-LayoutRect RenderLayer::calculateLayerBounds(const RenderLayer* ancestorLayer, const LayoutPoint* offsetFromRoot, CalculateLayerBoundsFlags flags) const
</del><ins>+LayoutRect RenderLayer::calculateLayerBounds(const RenderLayer* ancestorLayer, const LayoutSize* offsetFromRoot, CalculateLayerBoundsFlags flags) const
</ins><span class="cx"> {
</span><span class="cx"> if (!isSelfPaintingLayer())
</span><span class="cx"> return LayoutRect();
</span><span class="lines">@@ -5694,12 +5694,12 @@
</span><span class="cx"> unionBounds = affineTrans->mapRect(unionBounds);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- LayoutSize ancestorRelOffset;
</del><ins>+ LayoutSize offsetFromAncestor;
</ins><span class="cx"> if (offsetFromRoot)
</span><del>- ancestorRelOffset = toLayoutSize(*offsetFromRoot);
</del><ins>+ offsetFromAncestor = *offsetFromRoot;
</ins><span class="cx"> else
</span><del>- ancestorRelOffset = offsetFromAncestor(ancestorLayer);
- unionBounds.move(ancestorRelOffset);
</del><ins>+ offsetFromAncestor = this->offsetFromAncestor(ancestorLayer);
+ unionBounds.move(offsetFromAncestor);
</ins><span class="cx">
</span><span class="cx"> return unionBounds;
</span><span class="cx"> }
</span><span class="lines">@@ -6741,7 +6741,7 @@
</span><span class="cx">
</span><span class="cx"> // Expand the hit-test rect to the flow thread's coordinate system.
</span><span class="cx"> LayoutRect hitTestRectInFlowThread = hitTestRect;
</span><del>- hitTestRectInFlowThread.move(hitTestOffset.width(), hitTestOffset.height());
</del><ins>+ hitTestRectInFlowThread.move(hitTestOffset);
</ins><span class="cx"> hitTestRectInFlowThread.expand(LayoutSize(fabs((double)hitTestOffset.width()), fabs((double)hitTestOffset.height())));
</span><span class="cx">
</span><span class="cx"> CurrentRenderFlowThreadMaintainer flowThreadMaintainer(flowThread);
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderLayerh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderLayer.h (170272 => 170273)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderLayer.h 2014-06-23 00:13:49 UTC (rev 170272)
+++ trunk/Source/WebCore/rendering/RenderLayer.h 2014-06-23 00:34:25 UTC (rev 170273)
</span><span class="lines">@@ -320,7 +320,7 @@
</span><span class="cx"> LayoutRect boundingBox;
</span><span class="cx">
</span><span class="cx"> // Unique to paginated fragments. The physical translation to apply to shift the layer when painting/hit-testing.
</span><del>- LayoutPoint paginationOffset;
</del><ins>+ LayoutSize paginationOffset;
</ins><span class="cx">
</span><span class="cx"> // Also unique to paginated fragments. An additional clip that applies to the layer. It is in layer-local
</span><span class="cx"> // (physical) coordinates.
</span><span class="lines">@@ -700,7 +700,7 @@
</span><span class="cx"> // for painting/event handling.
</span><span class="cx"> // Pass offsetFromRoot if known.
</span><span class="cx"> void calculateRects(const ClipRectsContext&, const LayoutRect& paintDirtyRect, LayoutRect& layerBounds,
</span><del>- ClipRect& backgroundRect, ClipRect& foregroundRect, ClipRect& outlineRect, const LayoutPoint* offsetFromRoot = nullptr) const;
</del><ins>+ ClipRect& backgroundRect, ClipRect& foregroundRect, ClipRect& outlineRect, const LayoutSize* offsetFromRoot = nullptr) const;
</ins><span class="cx">
</span><span class="cx"> // Compute and cache clip rects computed with the given layer as the root
</span><span class="cx"> void updateClipRects(const ClipRectsContext&);
</span><span class="lines">@@ -719,7 +719,7 @@
</span><span class="cx"> LayoutRect localClipRect(bool& clipExceedsBounds) const; // Returns the background clip rect of the layer in the local coordinate space.
</span><span class="cx">
</span><span class="cx"> // Pass offsetFromRoot if known.
</span><del>- bool intersectsDamageRect(const LayoutRect& layerBounds, const LayoutRect& damageRect, const RenderLayer* rootLayer, const LayoutPoint* offsetFromRoot = nullptr, const LayoutRect* cachedBoundingBox = nullptr) const;
</del><ins>+ bool intersectsDamageRect(const LayoutRect& layerBounds, const LayoutRect& damageRect, const RenderLayer* rootLayer, const LayoutSize* offsetFromRoot = nullptr, const LayoutRect* cachedBoundingBox = nullptr) const;
</ins><span class="cx">
</span><span class="cx"> enum CalculateLayerBoundsFlag {
</span><span class="cx"> IncludeSelfTransform = 1 << 0,
</span><span class="lines">@@ -735,7 +735,7 @@
</span><span class="cx"> typedef unsigned CalculateLayerBoundsFlags;
</span><span class="cx">
</span><span class="cx"> // Bounding box relative to some ancestor layer. Pass offsetFromRoot if known.
</span><del>- LayoutRect boundingBox(const RenderLayer* rootLayer, CalculateLayerBoundsFlags = 0, const LayoutPoint* offsetFromRoot = nullptr) const;
</del><ins>+ LayoutRect boundingBox(const RenderLayer* rootLayer, CalculateLayerBoundsFlags = 0, const LayoutSize* offsetFromRoot = nullptr) const;
</ins><span class="cx"> // Bounding box in the coordinates of this layer.
</span><span class="cx"> LayoutRect localBoundingBox(CalculateLayerBoundsFlags = 0) const;
</span><span class="cx"> // Deprecated: Pixel snapped bounding box relative to the root.
</span><span class="lines">@@ -755,7 +755,7 @@
</span><span class="cx"> #endif
</span><span class="cx">
</span><span class="cx"> // Can pass offsetFromRoot if known.
</span><del>- LayoutRect calculateLayerBounds(const RenderLayer* ancestorLayer, const LayoutPoint* offsetFromRoot = nullptr, CalculateLayerBoundsFlags = DefaultCalculateLayerBoundsFlags) const;
</del><ins>+ LayoutRect calculateLayerBounds(const RenderLayer* ancestorLayer, const LayoutSize* offsetFromRoot = nullptr, CalculateLayerBoundsFlags = DefaultCalculateLayerBoundsFlags) const;
</ins><span class="cx">
</span><span class="cx"> // Return a cached repaint rect, computed relative to the layer renderer's containerForRepaint.
</span><span class="cx"> LayoutRect repaintRect() const { return m_repaintRect; }
</span><span class="lines">@@ -986,24 +986,24 @@
</span><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> bool setupFontSubpixelQuantization(GraphicsContext*, bool& didQuantizeFonts);
</span><del>- bool setupClipPath(GraphicsContext*, const LayerPaintingInfo&, const LayoutPoint& offsetFromRoot, LayoutRect& rootRelativeBounds, bool& rootRelativeBoundsComputed);
</del><ins>+ bool setupClipPath(GraphicsContext*, const LayerPaintingInfo&, const LayoutSize& offsetFromRoot, LayoutRect& rootRelativeBounds, bool& rootRelativeBoundsComputed);
</ins><span class="cx"> #if ENABLE(CSS_FILTERS)
</span><del>- std::unique_ptr<FilterEffectRendererHelper> setupFilters(GraphicsContext*, LayerPaintingInfo&, PaintLayerFlags, const LayoutPoint& offsetFromRoot, LayoutRect& rootRelativeBounds, bool& rootRelativeBoundsComputed);
</del><ins>+ std::unique_ptr<FilterEffectRendererHelper> setupFilters(GraphicsContext*, LayerPaintingInfo&, PaintLayerFlags, const LayoutSize& offsetFromRoot, LayoutRect& rootRelativeBounds, bool& rootRelativeBoundsComputed);
</ins><span class="cx"> GraphicsContext* applyFilters(FilterEffectRendererHelper*, GraphicsContext* originalContext, LayerPaintingInfo&, LayerFragments&);
</span><span class="cx"> #endif
</span><span class="cx">
</span><span class="cx"> void paintLayer(GraphicsContext*, const LayerPaintingInfo&, PaintLayerFlags);
</span><span class="cx"> void paintFixedLayersInNamedFlows(GraphicsContext*, const LayerPaintingInfo&, PaintLayerFlags);
</span><span class="cx"> void paintLayerContentsAndReflection(GraphicsContext*, const LayerPaintingInfo&, PaintLayerFlags);
</span><del>- void paintLayerByApplyingTransform(GraphicsContext*, const LayerPaintingInfo&, PaintLayerFlags, const LayoutPoint& translationOffset = LayoutPoint());
</del><ins>+ void paintLayerByApplyingTransform(GraphicsContext*, const LayerPaintingInfo&, PaintLayerFlags, const LayoutSize& translationOffset = LayoutSize());
</ins><span class="cx"> void paintLayerContents(GraphicsContext*, const LayerPaintingInfo&, PaintLayerFlags);
</span><span class="cx"> void paintList(Vector<RenderLayer*>*, GraphicsContext*, const LayerPaintingInfo&, PaintLayerFlags);
</span><span class="cx">
</span><span class="cx"> void collectFragments(LayerFragments&, const RenderLayer* rootLayer, const LayoutRect& dirtyRect,
</span><span class="cx"> PaginationInclusionMode,
</span><span class="cx"> ClipRectsType, OverlayScrollbarSizeRelevancy inOverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize,
</span><del>- ShouldRespectOverflowClip = RespectOverflowClip, const LayoutPoint* offsetFromRoot = nullptr, const LayoutRect* layerBoundingBox = nullptr, ShouldApplyRootOffsetToFragments = IgnoreRootOffsetForFragments);
- void updatePaintingInfoForFragments(LayerFragments&, const LayerPaintingInfo&, PaintLayerFlags, bool shouldPaintContent, const LayoutPoint* offsetFromRoot);
</del><ins>+ ShouldRespectOverflowClip = RespectOverflowClip, const LayoutSize* offsetFromRoot = nullptr, const LayoutRect* layerBoundingBox = nullptr, ShouldApplyRootOffsetToFragments = IgnoreRootOffsetForFragments);
+ void updatePaintingInfoForFragments(LayerFragments&, const LayerPaintingInfo&, PaintLayerFlags, bool shouldPaintContent, const LayoutSize* offsetFromRoot);
</ins><span class="cx"> void paintBackgroundForFragments(const LayerFragments&, GraphicsContext*, GraphicsContext* transparencyLayerContext,
</span><span class="cx"> const LayoutRect& transparencyPaintDirtyRect, bool haveTransparency, const LayerPaintingInfo&, PaintBehavior, RenderObject* paintingRootForRenderer);
</span><span class="cx"> void paintForegroundForFragments(const LayerFragments&, GraphicsContext*, GraphicsContext* transparencyLayerContext,
</span><span class="lines">@@ -1020,7 +1020,7 @@
</span><span class="cx"> const HitTestingTransformState* = nullptr, double* zOffset = nullptr);
</span><span class="cx"> RenderLayer* hitTestLayerByApplyingTransform(RenderLayer* rootLayer, RenderLayer* containerLayer, const HitTestRequest&, HitTestResult&,
</span><span class="cx"> const LayoutRect& hitTestRect, const HitTestLocation&, const HitTestingTransformState* = nullptr, double* zOffset = nullptr,
</span><del>- const LayoutPoint& translationOffset = LayoutPoint());
</del><ins>+ const LayoutSize& translationOffset = LayoutSize());
</ins><span class="cx"> RenderLayer* hitTestList(Vector<RenderLayer*>*, RenderLayer* rootLayer, const HitTestRequest& request, HitTestResult& result,
</span><span class="cx"> const LayoutRect& hitTestRect, const HitTestLocation&,
</span><span class="cx"> const HitTestingTransformState*, double* zOffsetForDescendants, double* zOffset,
</span><span class="lines">@@ -1037,7 +1037,7 @@
</span><span class="cx"> PassRefPtr<HitTestingTransformState> createLocalTransformState(RenderLayer* rootLayer, RenderLayer* containerLayer,
</span><span class="cx"> const LayoutRect& hitTestRect, const HitTestLocation&,
</span><span class="cx"> const HitTestingTransformState* containerTransformState,
</span><del>- const LayoutPoint& translationOffset = LayoutPoint()) const;
</del><ins>+ const LayoutSize& translationOffset = LayoutSize()) const;
</ins><span class="cx">
</span><span class="cx"> bool hitTestContents(const HitTestRequest&, HitTestResult&, const LayoutRect& layerBounds, const HitTestLocation&, HitTestFilter) const;
</span><span class="cx"> bool hitTestContentsForFragments(const LayerFragments&, const HitTestRequest&, HitTestResult&, const HitTestLocation&, HitTestFilter, bool& insideClipRect) const;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderMultiColumnSetcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderMultiColumnSet.cpp (170272 => 170273)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderMultiColumnSet.cpp 2014-06-23 00:13:49 UTC (rev 170272)
+++ trunk/Source/WebCore/rendering/RenderMultiColumnSet.cpp 2014-06-23 00:34:25 UTC (rev 170273)
</span><span class="lines">@@ -755,7 +755,7 @@
</span><span class="cx">
</span><span class="cx"> // We also need to intersect the dirty rect. We have to apply a translation and shift based off
</span><span class="cx"> // our column index.
</span><del>- LayoutPoint translationOffset;
</del><ins>+ LayoutSize translationOffset;
</ins><span class="cx"> LayoutUnit inlineOffset = progressionIsInline ? i * (colLogicalWidth + colGap) : LayoutUnit();
</span><span class="cx">
</span><span class="cx"> bool leftToRight = style().isLeftToRightDirection() ^ progressionReversed;
</span><span class="lines">@@ -764,7 +764,7 @@
</span><span class="cx"> if (progressionReversed)
</span><span class="cx"> inlineOffset += contentLogicalWidth() - colLogicalWidth;
</span><span class="cx"> }
</span><del>- translationOffset.setX(inlineOffset);
</del><ins>+ translationOffset.setWidth(inlineOffset);
</ins><span class="cx"> LayoutUnit blockOffset = initialBlockOffset + logicalTop() - flowThread()->logicalTop() + (isHorizontalWritingMode() ? -flowThreadPortion.y() : -flowThreadPortion.x());
</span><span class="cx"> if (!progressionIsInline) {
</span><span class="cx"> if (!progressionReversed)
</span><span class="lines">@@ -774,13 +774,13 @@
</span><span class="cx"> }
</span><span class="cx"> if (isFlippedBlocksWritingMode(style().writingMode()))
</span><span class="cx"> blockOffset = -blockOffset;
</span><del>- translationOffset.setY(blockOffset);
</del><ins>+ translationOffset.setHeight(blockOffset);
</ins><span class="cx"> if (!isHorizontalWritingMode())
</span><del>- translationOffset = translationOffset.transposedPoint();
</del><ins>+ translationOffset = translationOffset.transposedSize();
</ins><span class="cx">
</span><span class="cx"> // Shift the dirty rect to be in flow thread coordinates with this translation applied.
</span><span class="cx"> LayoutRect translatedDirtyRect(dirtyRect);
</span><del>- translatedDirtyRect.moveBy(-translationOffset);
</del><ins>+ translatedDirtyRect.move(-translationOffset);
</ins><span class="cx">
</span><span class="cx"> // See if we intersect the dirty rect.
</span><span class="cx"> clippedRect = layerBoundingBox;
</span></span></pre>
</div>
</div>
</body>
</html>