Fix LayoutObject::mapLocalToAncestor() for fixed under absolute

third_party/WebKit/Source/core/layout/LayoutObject.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved.
  *               (http://www.torchmobile.com/)
@@ skipping 2020 matching lines @@
   return transformState.lastPlanarQuad();
 }
 
 void LayoutObject::mapLocalToAncestor(const LayoutBoxModelObject* ancestor,
                                       TransformState& transformState,
                                       MapCoordinatesFlags mode) const {
   if (ancestor == this)
     return;
 
   bool ancestorSkipped;
-  const LayoutObject* o = container(ancestor, &ancestorSkipped);
-  if (!o)
+  const LayoutObject* container = this->container(ancestor, &ancestorSkipped);
+  if (!container)
     return;
 
   if (mode & ApplyContainerFlip) {
     if (isBox()) {
       mode &= ~ApplyContainerFlip;
-    } else if (o->isBox()) {
-      if (o->style()->isFlippedBlocksWritingMode()) {
+    } else if (container->isBox()) {
+      if (container->style()->isFlippedBlocksWritingMode()) {
         IntPoint centerPoint = roundedIntPoint(transformState.mappedPoint());
-        transformState.move(
-            toLayoutBox(o)->flipForWritingMode(LayoutPoint(centerPoint)) -
-            centerPoint);
+        transformState.move(toLayoutBox(container)->flipForWritingMode(
+                                LayoutPoint(centerPoint)) -
+                            centerPoint);
       }
       mode &= ~ApplyContainerFlip;
     }
   }
 
-  LayoutSize containerOffset = offsetFromContainer(o);
+  LayoutSize containerOffset = offsetFromContainer(container);
   if (isLayoutFlowThread()) {
     // So far the point has been in flow thread coordinates (i.e. as if
     // everything in the fragmentation context lived in one tall single column).
     // Convert it to a visual point now, since we're about to escape the flow
     // thread.
     containerOffset +=
         columnOffset(roundedLayoutPoint(transformState.mappedPoint()));
   }
 
   // Text objects just copy their parent's computed style, so we need to ignore
   // them.
   bool preserve3D =
-      mode & UseTransforms && ((o->style()->preserves3D() && !o->isText()) ||
-                               (style()->preserves3D() && !isText()));
-  if (mode & UseTransforms && shouldUseTransformFromContainer(o)) {
+      mode & UseTransforms &&
+      ((container->style()->preserves3D() && !container->isText()) ||
+       (style()->preserves3D() && !isText()));
+  if (mode & UseTransforms && shouldUseTransformFromContainer(container)) {
     TransformationMatrix t;
-    getTransformFromContainer(o, containerOffset, t);
+    getTransformFromContainer(container, containerOffset, t);
     transformState.applyTransform(t, preserve3D
                                          ? TransformState::AccumulateTransform
                                          : TransformState::FlattenTransform);
   } else {
     transformState.move(containerOffset.width(), containerOffset.height(),
                         preserve3D ? TransformState::AccumulateTransform
                                    : TransformState::FlattenTransform);
   }
 
   if (ancestorSkipped) {
     // There can't be a transform between |ancestor| and |o|, because transforms
     // create containers, so it should be safe to just subtract the delta
     // between the ancestor and |o|.
-    LayoutSize containerOffset = ancestor->offsetFromAncestorContainer(o);
+    LayoutSize containerOffset =
+        ancestor->offsetFromAncestorContainer(container);
     transformState.move(-containerOffset.width(), -containerOffset.height(),
                         preserve3D ? TransformState::AccumulateTransform
                                    : TransformState::FlattenTransform);
+    // If the ancestor is fixed, then the rect is already in its coordinates so
+    // doesn't need viewport-adjusting.
+    if (ancestor->style()->position() != FixedPosition &&
+        container->isLayoutView() && styleRef().position() == FixedPosition) {
+      LayoutRect rect;
+      toLayoutView(container)->adjustOffsetForFixedPosition(rect);
+      transformState.move(rect.x(), rect.y());
+    }
     return;
   }
 
-  o->mapLocalToAncestor(ancestor, transformState, mode);
+  container->mapLocalToAncestor(ancestor, transformState, mode);
 }
 
 const LayoutObject* LayoutObject::pushMappingToContainer(
     const LayoutBoxModelObject* ancestorToStopAt,
     LayoutGeometryMap& geometryMap) const {
   ASSERT_NOT_REACHED();
   return nullptr;
 }
 
 void LayoutObject::mapAncestorToLocal(const LayoutBoxModelObject* ancestor,
                                       TransformState& transformState,
                                       MapCoordinatesFlags mode) const {
   if (this == ancestor)
     return;
 
   bool ancestorSkipped;
-  LayoutObject* o = container(ancestor, &ancestorSkipped);
-  if (!o)
+  LayoutObject* container = this->container(ancestor, &ancestorSkipped);
+  if (!container)
     return;
 
   bool applyContainerFlip = false;
   if (mode & ApplyContainerFlip) {
     if (isBox()) {
       mode &= ~ApplyContainerFlip;
-    } else if (o->isBox()) {
-      applyContainerFlip = o->style()->isFlippedBlocksWritingMode();
+    } else if (container->isBox()) {
+      applyContainerFlip = container->style()->isFlippedBlocksWritingMode();
       mode &= ~ApplyContainerFlip;
     }
   }
 
   if (!ancestorSkipped)
-    o->mapAncestorToLocal(ancestor, transformState, mode);
+    container->mapAncestorToLocal(ancestor, transformState, mode);
 
-  LayoutSize containerOffset = offsetFromContainer(o);
+  LayoutSize containerOffset = offsetFromContainer(container);
   if (isLayoutFlowThread()) {
     // Descending into a flow thread. Convert to the local coordinate space,
     // i.e. flow thread coordinates.
     LayoutPoint visualPoint = LayoutPoint(transformState.mappedPoint());
     transformState.move(
         visualPoint -
         toLayoutFlowThread(this)->visualPointToFlowThreadPoint(visualPoint));
   }
 
-  bool preserve3D = mode & UseTransforms &&
-                    (o->style()->preserves3D() || style()->preserves3D());
-  if (mode & UseTransforms && shouldUseTransformFromContainer(o)) {
+  bool preserve3D =
+      mode & UseTransforms &&
+      (container->style()->preserves3D() || style()->preserves3D());
+  if (mode & UseTransforms && shouldUseTransformFromContainer(container)) {
     TransformationMatrix t;
-    getTransformFromContainer(o, containerOffset, t);
+    getTransformFromContainer(container, containerOffset, t);
     transformState.applyTransform(t, preserve3D
                                          ? TransformState::AccumulateTransform
                                          : TransformState::FlattenTransform);
   } else {
     transformState.move(containerOffset.width(), containerOffset.height(),
                         preserve3D ? TransformState::AccumulateTransform
                                    : TransformState::FlattenTransform);
   }
 
   if (applyContainerFlip) {
     IntPoint centerPoint = roundedIntPoint(transformState.mappedPoint());
     transformState.move(
         centerPoint -
-        toLayoutBox(o)->flipForWritingMode(LayoutPoint(centerPoint)));
+        toLayoutBox(container)->flipForWritingMode(LayoutPoint(centerPoint)));
   }
 
   if (ancestorSkipped) {
-    containerOffset = ancestor->offsetFromAncestorContainer(o);
+    containerOffset = ancestor->offsetFromAncestorContainer(container);
     transformState.move(-containerOffset.width(), -containerOffset.height());
+    // If the ancestor is fixed, then the rect is already in its coordinates so
+    // doesn't need viewport-adjusting.
+    if (ancestor->style()->position() != FixedPosition &&
+        container->isLayoutView() && styleRef().position() == FixedPosition) {
+      LayoutRect rect;
+      toLayoutView(container)->adjustOffsetForFixedPosition(rect);
+      transformState.move(rect.x(), rect.y());
+    }
   }
 }
 
 bool LayoutObject::shouldUseTransformFromContainer(
     const LayoutObject* containerObject) const {
   // hasTransform() indicates whether the object has transform, transform-style
   // or perspective. We just care about transform, so check the layer's
   // transform directly.
   return (hasLayer() && toLayoutBoxModelObject(this)->layer()->transform()) ||
          (containerObject && containerObject->style()->hasPerspective());
@@ skipping 1360 matching lines @@
     const blink::LayoutObject* root = object1;
     while (root->parent())
       root = root->parent();
     root->showLayoutTreeAndMark(object1, "*", object2, "-", 0);
   } else {
     WTFLogAlways("%s", "Cannot showLayoutTree. Root is (nil)");
   }
 }
 
 #endif