Fix incorrect position when using CSS shadows, and use left/top over right/bottom if defined

Change-Id: I38dbc87faffdb6806b356d89bfff1162023124e7

3 files changed, 42 insertions, 56 deletions

diff --git a/WebCore/platform/graphics/android/GraphicsLayerAndroid.cpp b/WebCore/platform/graphics/android/GraphicsLayerAndroid.cpp
index 0d22719..c3df943 100644
--- a/WebCore/platform/graphics/android/GraphicsLayerAndroid.cpp
+++ b/WebCore/platform/graphics/android/GraphicsLayerAndroid.cpp
@@ -229,30 +229,39 @@ void GraphicsLayerAndroid::updateFixedPosition()
 
     // If we are a fixed position layer, just set it
     if (view->isPositioned() && view->style()->position() == FixedPosition) {
+        // We need to get the passed CSS properties for the element
         SkLength left, top, right, bottom;
         left = convertLength(view->style()->left());
         top = convertLength(view->style()->top());
         right = convertLength(view->style()->right());
         bottom = convertLength(view->style()->bottom());
-        // We need to pass the size of the element to compute the final fixed
-        // position -- we can't use the layer's size as it could possibly differs.
-        // We also have to use the visible overflow and not just the size,
-        // as some child elements could be overflowing.
-        int w = view->rightVisibleOverflow() - view->leftVisibleOverflow();
-        int h = view->bottomVisibleOverflow() - view->topVisibleOverflow();
 
+        // We also need to get the margin...
         SkLength marginLeft, marginTop, marginRight, marginBottom;
         marginLeft = convertLength(view->style()->marginLeft());
         marginTop = convertLength(view->style()->marginTop());
         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();
+        int paintingOffsetX = - offsetFromRenderer().width();
+        int paintingOffsetY = - offsetFromRenderer().height();
+
+        SkRect viewRect;
+        viewRect.set(paintingOffsetX, paintingOffsetY, paintingOffsetX + w, paintingOffsetY + h);
+
         m_contentLayer->setFixedPosition(left, top, right, bottom,
                                          marginLeft, marginTop,
                                          marginRight, marginBottom,
-                                         offsetFromRenderer().width(),
-                                         offsetFromRenderer().height(),
-                                         w, h);
+                                         viewRect);
     }
 }
 
@@ -283,6 +292,7 @@ void GraphicsLayerAndroid::setSize(const FloatSize& size)
         MLOG("(%x) setSize (%.2f,%.2f)", this, size.width(), size.height());
         GraphicsLayer::setSize(size);
         m_contentLayer->setSize(size.width(), size.height());
+        updateFixedPosition();
         askForSync();
     }
 }
diff --git a/WebCore/platform/graphics/android/LayerAndroid.cpp b/WebCore/platform/graphics/android/LayerAndroid.cpp
index 2f10d33..5aaa243 100644
--- a/WebCore/platform/graphics/android/LayerAndroid.cpp
+++ b/WebCore/platform/graphics/android/LayerAndroid.cpp
@@ -87,9 +87,7 @@ LayerAndroid::LayerAndroid(const LayerAndroid& layer) : SkLayer(layer),
     m_fixedMarginTop = layer.m_fixedMarginTop;
     m_fixedMarginRight = layer.m_fixedMarginRight;
     m_fixedMarginBottom = layer.m_fixedMarginBottom;
-    m_fixedOffset = layer.m_fixedOffset;
-    m_fixedWidth = layer.m_fixedWidth;
-    m_fixedHeight = layer.m_fixedHeight;
+    m_fixedRect = layer.m_fixedRect;
 
     m_recordingPicture = layer.m_recordingPicture;
     SkSafeRef(m_recordingPicture);
@@ -256,20 +254,6 @@ const LayerAndroid* LayerAndroid::find(int x, int y) const
 
 ///////////////////////////////////////////////////////////////////////////////
 
-// The Layer bounds and the renderview bounds are not always indentical.
-// We need to compute the intersection to correctly compute the
-// positiong...
-static SkRect computeLayerRect(LayerAndroid* layer) {
-  SkRect layerRect, viewRect;
-  SkScalar fX, fY;
-  fX = layer->getOffset().fX;
-  fY = layer->getOffset().fY;
-  layerRect.set(0, 0, layer->getSize().width(), layer->getSize().height());
-  viewRect.set(-fX, -fY, -fX + layer->getFixedWidth(), -fY + layer->getFixedHeight());
-  layerRect.intersect(viewRect);
-  return layerRect;
-}
-
 void LayerAndroid::updateFixedLayersPositions(const SkRect& viewport)
 {
     if (m_isFixed) {
@@ -280,23 +264,21 @@ void LayerAndroid::updateFixedLayersPositions(const SkRect& viewport)
         float x = dx;
         float y = dy;
 
-        SkRect layerRect = computeLayerRect(this);
-
         // Not defined corresponds to 'auto';
-        // so if right is auto, and left is auto, the w3c says we should set
-        // left to zero (in left-to-right layout). So basically, if right is not
-        // defined, we always apply auto.
-        if (m_fixedRight.defined())
-            x += w - m_fixedMarginRight.calcFloatValue(w) - m_fixedRight.calcFloatValue(w) - layerRect.width();
+        // If both left and right are auto, the w3c says we should set left
+        // to zero (in left-to-right layout). So we use left if it's defined
+        // or if right isn't defined.
+        if (m_fixedLeft.defined() || !m_fixedRight.defined())
+            x += m_fixedMarginLeft.calcFloatValue(w) + m_fixedLeft.calcFloatValue(w) - m_fixedRect.fLeft;
         else
-            x += m_fixedMarginLeft.calcFloatValue(w) + m_fixedLeft.calcFloatValue(w) - layerRect.fLeft;
+            x += w - m_fixedMarginRight.calcFloatValue(w) - m_fixedRight.calcFloatValue(w) - m_fixedRect.fRight;
 
         // Following the same reason as above, if bottom isn't defined, we apply
         // top regardless of it being defined or not.
-        if (m_fixedBottom.defined())
-            y += h - m_fixedMarginBottom.calcFloatValue(h) - m_fixedBottom.calcFloatValue(h) - layerRect.fTop - layerRect.height();
+        if (m_fixedTop.defined() || !m_fixedBottom.defined())
+            y += m_fixedMarginTop.calcFloatValue(h) + m_fixedTop.calcFloatValue(h) - m_fixedRect.fTop;
         else
-            y += m_fixedMarginTop.calcFloatValue(h) + m_fixedTop.calcFloatValue(h) - layerRect.fTop;
+            y += h - m_fixedMarginBottom.calcFloatValue(h) - m_fixedBottom.calcFloatValue(h) - m_fixedRect.fBottom;
 
         this->setPosition(x, y);
     }
@@ -375,10 +357,9 @@ void LayerAndroid::onDraw(SkCanvas* canvas, SkScalar opacity) {
     canvas->drawLine(w, 0, 0, 0, paint);
 
     if (m_isFixed) {
-      SkRect layerRect = computeLayerRect(this);
       SkPaint paint;
-      paint.setARGB(128, 0, 0, 255);
-      canvas->drawRect(layerRect, paint);
+      paint.setARGB(80, 255, 0, 0);
+      canvas->drawRect(m_fixedRect, paint);
     }
 #endif
 }
@@ -513,6 +494,13 @@ void writeSize(FILE* file, int indentLevel, const char* str, SkSize size)
     fprintf(file, "%s = { w = %.3f; h = %.3f; };\n", str, size.width(), size.height());
 }
 
+void writeRect(FILE* file, int indentLevel, const char* str, SkRect rect)
+{
+    writeIndent(file, indentLevel);
+    fprintf(file, "%s = { x = %.3f; y = %.3f; w = %.3f; h = %.3f; };\n",
+            str, rect.fLeft, rect.fTop, rect.width(), rect.height());
+}
+
 void writeLength(FILE* file, int indentLevel, const char* str, SkLength length)
 {
     if (!length.defined()) return;
@@ -549,9 +537,7 @@ void LayerAndroid::dumpLayers(FILE* file, int indentLevel) const
         writeLength(file, indentLevel + 1, "fixedMarginTop", m_fixedMarginTop);
         writeLength(file, indentLevel + 1, "fixedMarginRight", m_fixedMarginRight);
         writeLength(file, indentLevel + 1, "fixedMarginBottom", m_fixedMarginBottom);
-        writePoint(file, indentLevel + 1, "fixedOffset", m_fixedOffset);
-        writeIntVal(file, indentLevel + 1, "fixedWidth", m_fixedWidth);
-        writeIntVal(file, indentLevel + 1, "fixedHeight", m_fixedHeight);
+        writeRect(file, indentLevel + 1, "fixedRect", m_fixedRect);
     }
 
     if (m_recordingPicture) {
diff --git a/WebCore/platform/graphics/android/LayerAndroid.h b/WebCore/platform/graphics/android/LayerAndroid.h
index 2b106d1..b6b6f70 100644
--- a/WebCore/platform/graphics/android/LayerAndroid.h
+++ b/WebCore/platform/graphics/android/LayerAndroid.h
@@ -104,10 +104,7 @@ public:
                           SkLength marginTop,    // CSS margin-top property
                           SkLength marginRight,  // CSS margin-right property
                           SkLength marginBottom, // CSS margin-bottom property
-                          int offsetX,     // X Offset from the renderer
-                          int offsetY,     // Y Offset from the renderer
-                          int width,       // visible overflow width
-                          int height) {    // visible overflow height
+                          SkRect viewRect) { // view rect, can be smaller than the layer's
         m_fixedLeft = left;
         m_fixedTop = top;
         m_fixedRight = right;
@@ -116,9 +113,7 @@ public:
         m_fixedMarginTop = marginTop;
         m_fixedMarginRight = marginRight;
         m_fixedMarginBottom = marginBottom;
-        m_fixedOffset.set(offsetX, offsetY);
-        m_fixedWidth = width;
-        m_fixedHeight = height;
+        m_fixedRect = viewRect;
         m_isFixed = true;
         setInheritFromRootTransform(true);
     }
@@ -171,9 +166,6 @@ public:
     void setExtra(DrawExtra* extra);  // does not assign ownership
     int uniqueId() const { return m_uniqueId; }
     bool isFixed() { return m_isFixed; }
-    const SkPoint& getOffset() const { return m_fixedOffset; }
-    int getFixedWidth() { return m_fixedWidth; }
-    int getFixedHeight() { return m_fixedHeight; }
 
     /** This sets a content image -- calling it means we will use
         the image directly when drawing the layer instead of using
@@ -208,9 +200,7 @@ private:
     SkLength m_fixedMarginTop;
     SkLength m_fixedMarginRight;
     SkLength m_fixedMarginBottom;
-    SkPoint  m_fixedOffset;
-    int m_fixedWidth;
-    int m_fixedHeight;
+    SkRect   m_fixedRect;
 
     SkPoint m_translation;
     SkPoint m_scale;