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());
+
+    if (m_topControlsAdjustment) {

[aelias_OOO_until_Jul13, 2014/10/09 22:58:53]

Please remove this if() statement, it's unnecessary complexity since it doesn't
change the behavior.  Maybe replace it with a comment explaining you expect this
will have an effect in the top controls case.

[bokan, 2014/10/09 23:22:49]

Done.

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

Actually, the 'if' is needed, there are cases where the aspect ratios don't
match. The CrOS OSK is the one real world example. That's by design since we
don't want the fixed pos elements to move when the keyboard comes up.

+        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