DO NOT MERGE:Fix position update

We fixed two issues here.
First, when fixed left/right both undefined, the renderlayer position already
took the fix margin into consideration, so we don't need to compute that again.

Second, for compute the fix element's ViewRect, we just need the normal width,
not the overflow one.

bug:4440999

Change-Id: Ie3f9b0d4d87de576ce852e7a4898d57a80add7a9

2 files changed, 15 insertions, 18 deletions

diff --git a/WebCore/platform/graphics/android/GraphicsLayerAndroid.cpp b/WebCore/platform/graphics/android/GraphicsLayerAndroid.cpp
index 4198608..ea95d6a 100644
--- a/WebCore/platform/graphics/android/GraphicsLayerAndroid.cpp
+++ b/WebCore/platform/graphics/android/GraphicsLayerAndroid.cpp
@@ -245,15 +245,14 @@ void GraphicsLayerAndroid::updateFixedPosition()
         marginRight = convertLength(view->style()->marginRight());
         marginBottom = convertLength(view->style()->marginBottom());
 
-        // The layer can be bigger than the element we want to draw;
-        // not only that, the layout rect of the element might also be
-        // different from the visible rect of that element (i.e. the element
-        // has a CSS shadow property -- the shadow is "outside" the element).
-        // We thus need to:
-        // 1/ get the size of the element (w,h), using the layoutOverflow rect
-        // 2/ pass the current offset of the painting relative to the layer
-        int w = view->rightLayoutOverflow() - view->leftLayoutOverflow();
-        int h = view->bottomLayoutOverflow() - view->topLayoutOverflow();
+        // In order to compute the fixed element's position, we need the width
+        // and height of the element when bottom or right is defined.
+        // And here we should use the non-overflowed value, that means, the
+        // overflowed content (e.g. outset shadow) will not be counted into the
+        // width and height.
+        int w = view->width();
+        int h = view->height();
+
         int paintingOffsetX = - offsetFromRenderer().width();
         int paintingOffsetY = - offsetFromRenderer().height();
 
diff --git a/WebCore/platform/graphics/android/LayerAndroid.cpp b/WebCore/platform/graphics/android/LayerAndroid.cpp
index 4ba2da0..ef500c4 100644
--- a/WebCore/platform/graphics/android/LayerAndroid.cpp
+++ b/WebCore/platform/graphics/android/LayerAndroid.cpp
@@ -543,21 +543,19 @@ void LayerAndroid::updateFixedLayersPositions(SkRect viewport, LayerAndroid* par
         float x = dx;
         float y = dy;
 
-        // It turns out that when it is 'auto', the webkit computation will
-        // take one more factor into account,  that is the original render
-        // layer's X,Y, such that it will align well with the parent's layer.
+        // It turns out that when it is 'auto', we should use the webkit value
+        // from the original render layer's X,Y, that will take care of alignment
+        // with the parent's layer and fix Margin etc.
         if (!(m_fixedLeft.defined() || m_fixedRight.defined()))
             x += m_renderLayerPos.x();
-
-        if (!(m_fixedTop.defined() || m_fixedBottom.defined()))
-            y += m_renderLayerPos.y();
-
-        if (m_fixedLeft.defined() || !m_fixedRight.defined())
+        else if (m_fixedLeft.defined() || !m_fixedRight.defined())
             x += m_fixedMarginLeft.calcFloatValue(w) + m_fixedLeft.calcFloatValue(w) - m_fixedRect.fLeft;
         else
             x += w - m_fixedMarginRight.calcFloatValue(w) - m_fixedRight.calcFloatValue(w) - m_fixedRect.fRight;
 
-        if (m_fixedTop.defined() || !m_fixedBottom.defined())
+        if (!(m_fixedTop.defined() || m_fixedBottom.defined()))
+            y += m_renderLayerPos.y();
+        else if (m_fixedTop.defined() || !m_fixedBottom.defined())
             y += m_fixedMarginTop.calcFloatValue(h) + m_fixedTop.calcFloatValue(h) - m_fixedRect.fTop;
         else
             y += h - m_fixedMarginBottom.calcFloatValue(h) - m_fixedBottom.calcFloatValue(h) - m_fixedRect.fBottom;