Initial draft - modify ViewportAnchor to know about both inner and outer viewports.

Source/web/ViewportAnchor.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 55 matching lines @@
         node = node->parentNode();
 
     return node;
 }
 
 } // namespace
 
 ViewportAnchor::ViewportAnchor(EventHandler* eventHandler)
     : m_eventHandler(eventHandler) { }
 
-void ViewportAnchor::setAnchor(const IntRect& viewRect, const FloatSize& anchorInViewCoords)
+void ViewportAnchor::setAnchor(const IntRect& innerViewRect, const IntRect& outerViewRect,
+    const FloatSize& anchorInViewCoords)
 {
-    m_viewRect = viewRect;
+    m_viewRect = innerViewRect;
     m_anchorNode.clear();
     m_anchorNodeBounds = LayoutRect();
     m_anchorInNodeCoords = FloatSize();
     m_anchorInViewCoords = anchorInViewCoords;
+    m_outerInInnerCoords = FloatSize();
 
-    if (viewRect.isEmpty())
+    if (innerViewRect.isEmpty())
         return;
 
     // Preserve origins at the absolute screen origin
-    if (viewRect.location() == IntPoint::zero())
+    if (innerViewRect.location() == IntPoint::zero())
         return;
 
-    FloatSize anchorOffset = viewRect.size();
+    FloatSize anchorOffset = innerViewRect.size();
     anchorOffset.scale(anchorInViewCoords.width(), anchorInViewCoords.height());
-    const FloatPoint anchorPoint = FloatPoint(viewRect.location()) + anchorOffset;
+    const FloatPoint anchorPoint = FloatPoint(innerViewRect.location()) + anchorOffset;
 
-    Node* node = findNonEmptyAnchorNode(flooredIntPoint(anchorPoint), viewRect, m_eventHandler);
+    Node* node = findNonEmptyAnchorNode(flooredIntPoint(anchorPoint), innerViewRect, m_eventHandler);
     if (!node)
         return;
 
     m_anchorNode = node;
     m_anchorNodeBounds = node->boundingBox();
     m_anchorInNodeCoords = anchorPoint - m_anchorNodeBounds.location();
     m_anchorInNodeCoords.scale(1.f / m_anchorNodeBounds.width(), 1.f / m_anchorNodeBounds.height());
+
+    // Inner rectangle should be within the outer one.
+    ASSERT(outerViewRect.contains(innerViewRect));
+
+    // Outer rectangle is used as a scale, we need positive width and height.
+    ASSERT(!outerViewRect.isEmpty());
+
+    m_outerInInnerCoords = outerViewRect.location() - innerViewRect.location();
+
+    // Make m_outerInInnerCoords relative to the size of the outer rect
+    m_outerInInnerCoords.scale(1.0 / outerViewRect.width(), 1.0 / outerViewRect.height());
 }
 
-IntPoint ViewportAnchor::computeOrigin(const IntSize& currentViewSize) const
+IntPoint ViewportAnchor::computeInnerViewportOrigin(const IntSize& innerSize) const

[aelias_OOO_until_Jul13, 2014/09/10 01:46:24]

Could you make this a FloatPoint instead, and likewise use FloatPoint everywhere
related to inner viewport?  The only offset that really needs to be integers
here is what goes into FrameView::scrollTo.

[timav, 2014/09/10 18:22:40]

Yes, this was one of my questions, should everything be Float.

 {
     if (!m_anchorNode || !m_anchorNode->inDocument())
         return m_viewRect.location();
 
     const LayoutRect currentNodeBounds = m_anchorNode->boundingBox();
     if (m_anchorNodeBounds == currentNodeBounds)
         return m_viewRect.location();
 
     // Compute the new anchor point relative to the node position
     FloatSize anchorOffsetFromNode = currentNodeBounds.size();
     anchorOffsetFromNode.scale(m_anchorInNodeCoords.width(), m_anchorInNodeCoords.height());
     FloatPoint anchorPoint = currentNodeBounds.location() + anchorOffsetFromNode;
 
     // Compute the new origin point relative to the new anchor point
-    FloatSize anchorOffsetFromOrigin = currentViewSize;
+    FloatSize anchorOffsetFromOrigin = innerSize;
     anchorOffsetFromOrigin.scale(m_anchorInViewCoords.width(), m_anchorInViewCoords.height());
     return flooredIntPoint(anchorPoint - anchorOffsetFromOrigin);
 }
 
+IntPoint ViewportAnchor::computeOuterViewportOrigin(const IntPoint& innerOrigin, const IntSize& outerSize) const
+{
+    FloatSize outerOffset = m_outerInInnerCoords;
+
+    outerOffset.scale(outerSize.width(), outerSize.height());
+
+    return flooredIntPoint(FloatPoint(innerOrigin) + outerOffset);
+}
+
 } // namespace blink