Reland of ix getComputedStyle positioned element values

third_party/WebKit/Source/core/css/ComputedStyleCSSValueMapping.cpp

 /*
  * Copyright (C) 2004 Zack Rusin <zack@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2011 Sencha, Inc. All rights reserved.
  * Copyright (C) 2015 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ skipping 144 matching lines @@
         return cssValuePool().createIdentifierValue(CSSValueLuminance);
     }
 
     ASSERT_NOT_REACHED();
 
     return nullptr;
 }
 
 static CSSValue* valueForPositionOffset(const ComputedStyle& style, CSSPropertyID propertyID, const LayoutObject* layoutObject)
 {
-    Length offset;
+    Length offset, opposite;
     switch (propertyID) {
     case CSSPropertyLeft:
         offset = style.left();
+        opposite = style.right();
         break;
     case CSSPropertyRight:
         offset = style.right();
+        opposite = style.left();
         break;
     case CSSPropertyTop:
         offset = style.top();
+        opposite = style.bottom();
         break;
     case CSSPropertyBottom:
         offset = style.bottom();
+        opposite = style.top();
         break;
     default:
         return nullptr;
     }
 
     if (offset.hasPercent() && layoutObject && layoutObject->isBox() && layoutObject->isPositioned()) {
         LayoutUnit containingBlockSize = (propertyID == CSSPropertyLeft || propertyID == CSSPropertyRight) ?
             toLayoutBox(layoutObject)->containingBlockLogicalWidthForContent() :
             toLayoutBox(layoutObject)->containingBlockLogicalHeightForGetComputedStyle();
         return zoomAdjustedPixelValue(valueForLength(offset, containingBlockSize), style);
     }
-    if (offset.isAuto()) {
-        // FIXME: It's not enough to simply return "auto" values for one offset if the other side is defined.
-        // In other words if left is auto and right is not auto, then left's computed value is negative right().
-        // So we should get the opposite length unit and see if it is auto.
+
+    if (offset.isAuto() && layoutObject) {
+        // If the property applies to a positioned element and the resolved value of the display
+        // property is not none, the resolved value is the used value.
+        if (layoutObject->isInFlowPositioned()) {
+            // If e.g. left is auto and right is not auto, then left's computed value is negative right.
+            // So we get the opposite length unit and see if it is auto.
+            if (opposite.isAuto())
+                return cssValuePool().createValue(0, CSSPrimitiveValue::UnitType::Pixels);
+
+            if (opposite.hasPercent()) {
+                LayoutUnit containingBlockSize =
+                    (propertyID == CSSPropertyLeft || propertyID == CSSPropertyRight) ?
+                    toLayoutBox(layoutObject)->containingBlockLogicalWidthForContent() :
+                    toLayoutBox(layoutObject)->containingBlockLogicalHeightForGetComputedStyle();
+                return zoomAdjustedPixelValue(-floatValueForLength(opposite, containingBlockSize), style);
+            }
+            return zoomAdjustedPixelValue(-opposite.pixels(), style);
+        }
+
+        if (layoutObject->isOutOfFlowPositioned()) {
+            // For fixed and absolute positioned elements, the top, left, bottom, and right
+            // are defined relative to the corresponding sides of the containing block.
+            LayoutBlock* container = layoutObject->containingBlock();
+            const LayoutBox* layoutBox = toLayoutBox(layoutObject);
+
+            // clientOffset is the distance from this object's border edge to the container's
+            // padding edge. Thus it includes margins which we subtract below.
+            const LayoutSize clientOffset =
+                layoutBox->locationOffset() - LayoutSize(container->clientLeft(), container->clientTop());
+            LayoutUnit position;
+
+            switch (propertyID) {
+            case CSSPropertyLeft:
+                position = clientOffset.width() - layoutBox->marginLeft();
+                break;
+            case CSSPropertyTop:
+                position = clientOffset.height() - layoutBox->marginTop();
+                break;
+            case CSSPropertyRight:
+                position = container->clientWidth() - layoutBox->marginRight() -
+                    (layoutBox->offsetWidth() + clientOffset.width());
+                break;
+            case CSSPropertyBottom:
+                position = container->clientHeight() - layoutBox->marginBottom() -
+                    (layoutBox->offsetHeight() + clientOffset.height());
+                break;
+            default:
+                ASSERT_NOT_REACHED();
+            }
+            return zoomAdjustedPixelValue(position, style);
+        }
+    }
+
+    if (offset.isAuto())
         return cssValuePool().createIdentifierValue(CSSValueAuto);
-    }
 
     return zoomAdjustedPixelValueForLength(offset, style);
 }
 
 static CSSBorderImageSliceValue* valueForNinePieceImageSlice(const NinePieceImage& image)
 {
     // Create the slices.
     CSSPrimitiveValue* top = nullptr;
     CSSPrimitiveValue* right = nullptr;
     CSSPrimitiveValue* bottom = nullptr;
@@ skipping 2553 matching lines @@
     case CSSPropertyAll:
         return nullptr;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 } // namespace blink