Made top controls work with virtual viewport pinch-to-zoom. (Blink)

Source/core/frame/PinchViewport.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 49 matching lines @@
 using blink::WebScrollbarLayer;
 using blink::FrameHost;
 using blink::GraphicsLayer;
 using blink::GraphicsLayerFactory;
 
 namespace blink {
 
 PinchViewport::PinchViewport(FrameHost& owner)
     : m_frameHost(owner)
     , m_scale(1)
+    , m_topControlsAdjustment(0)
 {
     reset();
 }
 
 PinchViewport::~PinchViewport() { }
 
 void PinchViewport::setSize(const IntSize& size)
 {
     if (m_size == size)
         return;
 
     TRACE_EVENT2("blink", "PinchViewport::setSize", "width", size.width(), "height", size.height());
     m_size = size;
 
-    clampToBoundaries();
-
     if (m_innerViewportContainerLayer) {
         m_innerViewportContainerLayer->setSize(m_size);
 
         // Need to re-compute sizes for the overlay scrollbars.
         setupScrollbar(WebScrollbar::Horizontal);
         setupScrollbar(WebScrollbar::Vertical);
     }
 }
 
 void PinchViewport::reset()
 {
     setScaleAndLocation(1, FloatPoint());
 }
 
 void PinchViewport::mainFrameDidChangeSize()
 {
     TRACE_EVENT0("blink", "PinchViewport::mainFrameDidChangeSize");
 
     // In unit tests we may not have initialized the layer tree.
     if (m_innerViewportScrollLayer)
         m_innerViewportScrollLayer->setSize(contentsSize());
 
     clampToBoundaries();
 }
 
 FloatRect PinchViewport::visibleRect() const
 {
     FloatSize scaledSize(m_size);
+    scaledSize.expand(0, m_topControlsAdjustment);
     scaledSize.scale(1 / m_scale);
     return FloatRect(m_offset, scaledSize);
 }
 
 FloatRect PinchViewport::visibleRectInDocument() const
 {
     if (!mainFrame() || !mainFrame()->view())
         return FloatRect();
 
     FloatRect viewRect = mainFrame()->view()->visibleContentRect();
@@ skipping 225 matching lines @@
     return (orientation == HorizontalScrollbar) ? scrollDimensions.width() : scrollDimensions.height();
 }
 
 IntPoint PinchViewport::minimumScrollPosition() const
 {
     return IntPoint();
 }
 
 IntPoint PinchViewport::maximumScrollPosition() const
 {
-    return flooredIntPoint(FloatSize(contentsSize()) - visibleRect().size());
+    FloatSize frameViewSize(contentsSize());

[Rick Byers, 2014/10/10 00:06:09]

not necessarily for this CL (if it's non-trivial to correct here), but note that
we've elsewhere decided that float doesn't have enough precision to properly
represent the size of a document.  Eg. it could result in off-by-one errors in
long documents (eg. with height+1==height).  Elsewhere (miletus@'s fractional
scroll offset work) we're using doubles, you may want to consider changing
PinchViewport to match (or at least testing on a page with height >1,000,000px -
I just got a real-world bug for a page nearly this long the other day).

[bokan, 2014/10/10 14:39:56]

Yes, I've been following the discussion. I'll keep this here for now since it
should match the calculation in LayerImpl::MaxScrollOffset in CC which uses
SizeF. Filed crbug.com/422331 and referenced it with a FIXME.

+
+    // The adjustment should only be non-zero in the case of a top controls offset.
+    // It is made to keep the aspect ratio of the two viewports the same.
+    float aspectRatio = visibleRect().width() / visibleRect().height();
+    float adjustment = frameViewSize.width() / aspectRatio - frameViewSize.height();
+    frameViewSize.expand(0, adjustment);
+
+    frameViewSize.scale(m_scale);
+    frameViewSize = flooredIntSize(frameViewSize);
+
+    FloatSize viewportSize(m_size);
+    viewportSize.expand(0, m_topControlsAdjustment);
+
+    FloatSize maxPosition = frameViewSize - viewportSize;
+    maxPosition.scale(1 / m_scale);
+
+    return flooredIntPoint(maxPosition);
 }
 
 IntPoint PinchViewport::clampDocumentOffsetAtScale(const IntPoint& offset, float scale)
 {
     if (!mainFrame() || !mainFrame()->view())
         return IntPoint();
 
     FrameView* view = mainFrame()->view();
 
     FloatSize scaledSize(m_size);
     scaledSize.scale(1 / scale);
 
     IntPoint pinchViewportMax = flooredIntPoint(FloatSize(contentsSize()) - scaledSize);
     IntPoint max = view->maximumScrollPosition() + pinchViewportMax;
     IntPoint min = view->minimumScrollPosition(); // PinchViewportMin should be (0, 0)
 
     IntPoint clamped = offset;
     clamped = clamped.shrunkTo(max);
     clamped = clamped.expandedTo(min);
     return clamped;
 }
 
+void PinchViewport::setTopControlsAdjustment(float adjustment)
+{
+    m_topControlsAdjustment = adjustment;
+}
+
 IntRect PinchViewport::scrollableAreaBoundingBox() const
 {
     // This method should return the bounding box in the parent view's coordinate
     // space; however, PinchViewport technically isn't a child of any Frames.
     // Nonetheless, the PinchViewport always occupies the entire main frame so just
     // return that.
     LocalFrame* frame = mainFrame();
 
     if (!frame || !frame->view())
         return IntRect();
@@ skipping 83 matching lines @@
     } else if (graphicsLayer == m_overlayScrollbarVertical.get()) {
         name =  "Overlay Scrollbar Vertical Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink