Add autoresize capability for Chromium.

Source/WebKit/chromium/src/WebViewImpl.cpp

 /*
  * Copyright (C) 2011 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 38 matching lines @@
 #include "DocumentLoader.h"
 #include "DragController.h"
 #include "DragData.h"
 #include "DragScrollTimer.h"
 #include "DragSession.h"
 #include "Editor.h"
 #include "EventHandler.h"
 #include "Extensions3D.h"
 #include "FocusController.h"
 #include "FontDescription.h"
+#include "Frame.h"
 #include "FrameLoader.h"
 #include "FrameSelection.h"
 #include "FrameTree.h"
 #include "FrameView.h"
 #include "GeolocationClientProxy.h"
 #include "GraphicsContext.h"
 #include "GraphicsContext3D.h"
 #include "GraphicsContext3DPrivate.h"
 #include "HTMLInputElement.h"
 #include "HTMLMediaElement.h"
@@ skipping 38 matching lines @@
 #include "TypingCommand.h"
 #include "UserGestureIndicator.h"
 #include "Vector.h"
 #include "WebAccessibilityObject.h"
 #include "WebAutofillClient.h"
 #include "WebCompositorImpl.h"
 #include "WebDevToolsAgentImpl.h"
 #include "WebDevToolsAgentPrivate.h"
 #include "WebDragData.h"
 #include "WebFrameImpl.h"
+#include "WebFrameClient.h"
 #include "WebGraphicsContext3D.h"
 #include "WebImage.h"
 #include "WebInputElement.h"
 #include "WebInputEvent.h"
 #include "WebInputEventConversion.h"
 #include "WebKit.h"
 #include "WebKitPlatformSupport.h"
 #include "WebMediaPlayerAction.h"
 #include "WebNode.h"
 #include "WebPlugin.h"
@@ skipping 200 matching lines @@
 WebViewImpl::WebViewImpl(WebViewClient* client)
     : m_client(client)
     , m_autofillClient(0)
     , m_permissionClient(0)
     , m_spellCheckClient(0)
     , m_chromeClientImpl(this)
     , m_contextMenuClientImpl(this)
     , m_dragClientImpl(this)
     , m_editorClientImpl(this)
     , m_inspectorClientImpl(this)
+    , m_autoSize(false)
+    , m_inLayoutBeforeScrollbarUpdate(false)
     , m_observedNewNavigation(false)
 #ifndef NDEBUG
     , m_newNavigationLoader(0)
 #endif
     , m_zoomLevel(0)
     , m_minimumZoomLevel(zoomFactorToZoomLevel(minTextSizeMultiplier))
     , m_maximumZoomLevel(zoomFactorToZoomLevel(maxTextSizeMultiplier))
     , m_minimumPageScaleFactor(minPageScaleFactor)
     , m_maximumPageScaleFactor(maxPageScaleFactor)
     , m_contextMenuAllowed(false)
@@ skipping 683 matching lines @@
         pluginContainer->willStartLiveResize();
 }
 
 void WebViewImpl::resize(const WebSize& newSize)
 {
     if (m_size == newSize)
         return;
     m_size = newSize;
 
     if (mainFrameImpl()->frameView()) {
-        mainFrameImpl()->frameView()->resize(m_size.width, m_size.height);
+        // Maintain the current frame size when doing autosize but still send
+        // a resize event for any auto-resizes that happened.
+        if (!m_autoSize)
+            mainFrameImpl()->frameView()->resize(m_size.width, m_size.height);
         mainFrameImpl()->frame()->eventHandler()->sendResizeEvent();
     }
 
     if (m_client) {
         if (isAcceleratedCompositingActive()) {
 #if USE(ACCELERATED_COMPOSITING)
             updateLayerTreeViewport();
 #endif
         } else {
             WebRect damagedRect(0, 0, m_size.width, m_size.height);
             m_client->didInvalidateRect(damagedRect);
         }
     }
 }
 
+void WebViewImpl::layoutBeforeScrollbarUpdate()

[darin (slow to review), 2011/11/28 16:50:40]

It feels like this should be a function on FrameView or ScrollView, perhaps
guarded by #if PLATFORM(CHROMIUM) or #if ENABLE(AUTO_SIZE)

[levin, 2011/11/28 18:34:01]

I was mildly considering that. I'm not sure it we want to add a bool and two
rects to FrameView for Chromium.

Alternately we could leave the bool and two rects in WebViewImpl and just expose
a method FrameView::autoSize(minSize, maxSize). (We would still need to add the
bool m_inLayoutBeforeScrollbarUpdate to FrameView but could ifdef that out --
likely ifdef chromium to avoid more defines/configurations until it is proven
that we need them.)

[levin, 2011/11/28 18:39:06]

I guess as long as it is ifdef'ed we could add all this to FrameView and
FrameView isn't a memory critical structure. On the plus side that avoid a
virtual call and hopefully will make it more obvious rather than the obtuse name
"layoutBeforeScrollbarUpdate".

We'll still need to store m_autoSize at this layer as well.

+{
+    if (!m_autoSize)
+        return;
+
+    if (!mainFrameImpl()->client())
+        return;
+
+    if (m_inLayoutBeforeScrollbarUpdate)
+        return;
+
+    m_inLayoutBeforeScrollbarUpdate = true;
+
+    double zoomFactor = WebView::zoomLevelToZoomFactor(zoomLevel());
+
+    WebCore::Frame* frame = mainFrameImpl()->frame();
+    WebCore::FrameView* frameView = frame->view();
+    WebCore::Document* document = frame->document();
+    for (int i = 0; i < 2; i++) {
+        // Update various sizes including contentsSize.
+        document->updateLayoutIgnorePendingStylesheets();
+        WebSize size = frameView->frameRect().size();
+        // During the first iteration, we use the preferred width but after that we use the width
+        // that was determined during the first iteration (which may be smaller than the preferred width 
+        // in order to fit within the framerect).
+        int width = (i == 0) ? mainFrameImpl()->contentsPreferredWidth() : frameView->contentsSize().width();
+        // Adjust the size because it is reported unzoomed.
+        int height = static_cast<int>(zoomFactor * mainFrameImpl()->documentElementScrollHeight());
+
+        WebSize newSize(width, height);
+
+        // Ensure the size is at least the min bounds.
+        newSize.width = std::max(newSize.width, m_minAutoSize.width);
+        newSize.height = std::max(newSize.height, m_minAutoSize.height);
+
+        // Increase the dimensions due to any scrollbars that are displayed.
+        if (newSize.width > m_maxAutoSize.width) {
+            RefPtr<Scrollbar> horizontalScrollbar = frameView->createScrollbar(WebCore::HorizontalScrollbar);
+            if (!horizontalScrollbar->isOverlayScrollbar())
+                newSize.height += horizontalScrollbar->height();
+        } else if (newSize.height > m_maxAutoSize.height) {
+            RefPtr<Scrollbar> verticalScrollbar = frameView->createScrollbar(WebCore::VerticalScrollbar);
+            if (!verticalScrollbar->isOverlayScrollbar())
+                newSize.width += verticalScrollbar->width();
+        }
+
+        // Bound the dimensions by the max bounds.
+        ScrollbarMode horizonalScrollbarMode = ScrollbarAlwaysOff;
+        if (newSize.width > m_maxAutoSize.width) {
+            newSize.width = m_maxAutoSize.width;
+            horizonalScrollbarMode = ScrollbarAlwaysOn;
+        }
+        ScrollbarMode verticalScrollbarMode = ScrollbarAlwaysOff;
+        if (newSize.height > m_maxAutoSize.height) {
+            newSize.height = m_maxAutoSize.height;
+            verticalScrollbarMode = ScrollbarAlwaysOn;
+        }
+
+        if (newSize == size)
+            continue;
+
+        // Avoid doing resizing to a smaller size while the frame is loading to avoid changing between too many sizes.
+        if (!frame->loader()->isComplete() && (newSize.width < size.width || newSize.width < size.width))
+            break;
+        frameView->resize(newSize.width, newSize.height);
+        // Force the scrollbar state to avoid the scrollbar code adding them and causing them to be needed. For example,
+        // a vertical scrollbar may cause text to wrap and thus increase the height (which is the only reason the scollbar is needed).
+        frameView->setVerticalScrollbarLock(false);
+        frameView->setHorizontalScrollbarLock(false);
+        frameView->setScrollbarModes(horizonalScrollbarMode, verticalScrollbarMode, true, true);
+    }
+
+    m_inLayoutBeforeScrollbarUpdate = false;
+}
+
+void WebViewImpl::didUpdateLayout(WebFrameImpl* webframe)
+{
+    if (!m_client || webframe != mainFrameImpl())
+        return;
+
+    if (m_autoSize) {
+        WebSize frameSize = mainFrameImpl()->frame()->view()->frameRect().size();
+        if (frameSize != m_lastAutoSize) {
+            m_lastAutoSize = frameSize;
+            m_client->autoSizeChanged(frameSize);
+        }
+    }
+
+    m_client->didUpdateLayout();
+}
+
 void WebViewImpl::willEndLiveResize()
 {
     if (mainFrameImpl() && mainFrameImpl()->frameView())
         mainFrameImpl()->frameView()->willEndLiveResize();
 
     Frame* frame = mainFrameImpl()->frame();
     WebPluginContainerImpl* pluginContainer = WebFrameImpl::pluginContainerFromFrame(frame);
     if (pluginContainer)
         pluginContainer->willEndLiveResize();
 }
@@ skipping 129 matching lines @@
         gc.translate(IntSize(0, bitmapHeight));
         gc.scale(FloatSize(1.0f, -1.0f));
         // Use invertRect in next line, so that transform above inverts it back to
         // desired destination rect.
         gc.drawImageBuffer(imageBuffer.get(), ColorSpaceDeviceRGB, invertRect.location());
         gc.restore();
     }
 }
 #endif
 
-void WebViewImpl::paint(WebCanvas* canvas, const WebRect& rect)
+void WebViewImpl::paint(WebCanvas* canvas, const WebRect& unscaledRect)
 {
+    WebRect rect = unscaledRect;
+
+    if (m_autoSize && !m_size.isEmpty() && !m_lastAutoSize.isEmpty()) {

[darin (slow to review), 2011/11/28 16:50:40]

what about the case where the page is rendered through the compositor (via GL)
instead?

i'm a little confused about why changes to painting are required.  i would have
expected the resizing to happen synchronously.  i don't think i have the big
picture in mind yet.

[levin, 2011/11/28 18:34:01]

That case is right below.  It writes into the same canvas, see
"doPixelReadbackToCanvas(canvas, resizeRect);" so the same scaling should be
applied.
"This is only to compensate for a very short term intermediate state while the
widget is being resized (animated) to match the desired size."

My explanation in the comment must not be clear. :) The rendered size is
synchronously resized but the ui window isn't. Even after the UI window gets a
new size, it typically animates from its current size to the new size.

So if the current size is 1000X1000 and the rendered size is 800x800, then as
the animation takes place, the region between 800 and 1000 is left unfilled in
the canvas which leads to it being filled with garbage. Alternately, I suppose I
could do calculations to determine the region in unscaledRect which isn't in
m_lastAutoSize and fill that in with white so get rid of the garbage. The
scaling seemed more elegant last night but either is fine. (At the moment I
think the fill in with white might be nice because that is likely faster and
avoids any issues if the ui decides to never get to the renderer size.)

+        // In autosize mode, scale the rendered content size to match what the widget wants.
+        // This is only to compensate for a very short term intermediate state while the widget
+        // is being resized (animated) to match the desired size (so mouse click, hover, etc.
+        // are not adjusted in a similar manner).
+        float scaleX = static_cast<float>(m_size.width) / m_lastAutoSize.width;
+        float scaleY = static_cast<float>(m_size.height) / m_lastAutoSize.height;
+
+        canvas->save();
+        canvas->scale(scaleX, scaleY);
+        rect.x = static_cast<int>(rect.x / scaleX);
+        rect.width = static_cast<int>(rect.width / scaleX);
+        rect.y = static_cast<int>(rect.y / scaleY);
+        rect.height = static_cast<int>(rect.height / scaleY);
+    }
+
     if (isAcceleratedCompositingActive()) {
 #if USE(ACCELERATED_COMPOSITING)
         // If a canvas was passed in, we use it to grab a copy of the
         // freshly-rendered pixels.
         if (canvas) {
             // Clip rect to the confines of the rootLayerTexture.
             IntRect resizeRect(rect);
             resizeRect.intersect(IntRect(IntPoint(0, 0), m_layerTreeHost->viewportSize()));
             doPixelReadbackToCanvas(canvas, resizeRect);
         }
 #endif
     } else {
         double paintStart = currentTime();
         WebFrameImpl* webframe = mainFrameImpl();
         if (webframe)
             webframe->paint(canvas, rect);
         double paintEnd = currentTime();
         double pixelsPerSec = (rect.width * rect.height) / (paintEnd - paintStart);
         PlatformSupport::histogramCustomCounts("Renderer4.SoftwarePaintDurationMS", (paintEnd - paintStart) * 1000, 0, 120, 30);
         PlatformSupport::histogramCustomCounts("Renderer4.SoftwarePaintMegapixPerSecond", pixelsPerSec / 1000000, 10, 210, 30);
     }
+
+    if (m_autoSize)
+        canvas->restore();
 }
 
 void WebViewImpl::themeChanged()
 {
     if (!page())
         return;
     FrameView* view = page()->mainFrame()->view();
 
     WebRect damagedRect(0, 0, m_size.width, m_size.height);
     view->invalidateRect(damagedRect);
@@ skipping 796 matching lines @@
 
 #if USE(ACCELERATED_COMPOSITING)
     // Also notify the base layer, which RenderLayerCompositor does not see.
     if (m_nonCompositedContentHost) {
         m_nonCompositedContentHost->topLevelRootLayer()->deviceOrPageScaleFactorChanged();
         updateLayerTreeViewport();
     }
 #endif
 }
 
+void WebViewImpl::enableAutoSizeMode(bool enable, const WebSize& minSize, const WebSize& maxSize)
+{
+    ASSERT(!enable || !minSize.isEmpty());
+    ASSERT(minSize.width <= maxSize.width);
+    ASSERT(minSize.height <= maxSize.height);
+
+    m_autoSize = enable;
+    m_minAutoSize = minSize;
+    m_maxAutoSize = maxSize;
+
+    FrameView* frameView = mainFrameImpl()->frame()->view();
+    frameView->setNeedsLayout();
+    frameView->scheduleRelayout();
+}
+
 void WebViewImpl::setPageScaleFactorLimits(float minPageScale, float maxPageScale)
 {
     m_minimumPageScaleFactor = min(max(minPageScale, minPageScaleFactor), maxPageScaleFactor) * deviceScaleFactor();
     m_maximumPageScaleFactor = max(min(maxPageScale, maxPageScaleFactor), minPageScaleFactor) * deviceScaleFactor();
 
     if (m_size.width && mainFrame() && mainFrame()->contentsSize().width) {
         // Limit page scaling down to the document width.
         int viewWidth = m_size.width;
         int unscaledContentWidth = mainFrame()->contentsSize().width / pageScaleFactor();
         m_minimumPageScaleFactor = max(m_minimumPageScaleFactor, static_cast<float>(viewWidth) / unscaledContentWidth);
@@ skipping 955 matching lines @@
 }
 
 #if ENABLE(GESTURE_RECOGNIZER)
 void WebViewImpl::resetGestureRecognizer()
 {
     m_gestureRecognizer->reset();
 }
 #endif
 
 } // namespace WebKit