Changeset 144067 in webkit

Timestamp:

Feb 26, 2013, 9:16:35 AM (14 years ago)

Author:

dino@apple.com

Message:

Draw intermediate snapshots if possible
​https://bugs.webkit.org/show_bug.cgi?id=110811

Reviewed by Simon Fraser.

After ​http://webkit.org/b/110495 we delayed snapshotting until we've
received a nice image, but this made the page look like it is broken.
We should draw any intermediate snapshots that we find, which might
include content such as progress bars/spinners.

Source/WebCore:

• html/HTMLPlugInElement.h:

(WebCore::HTMLPlugInElement::isPlugInImageElement): Expose virtual method
to indicate if this is a HTMLPlugInImageElement or not.

• html/HTMLPlugInImageElement.cpp:

(WebCore::HTMLPlugInImageElement::updateSnapshot): If we have
a RenderEmbeddedObject renderer, then tell it to repaint.

• html/HTMLPlugInImageElement.h:

(WebCore::HTMLPlugInImageElement::snapshotImage): Expose an
accessor for snapshot images.

• rendering/RenderEmbeddedObject.cpp:

(WebCore::RenderEmbeddedObject::paintSnapshotImage): New helper
method to render an image directly. This code is similar to
that in RenderSnapshottedPlugIn.
(WebCore::RenderEmbeddedObject::paintContents): The virtual implementation
of this method for use when we have a snapshot to paint. If we are a plugin that is
in the process of being snapshotted, ask our HTMLPlugInImageElement for a
snapshot and paint that instead. In the case where we are not snapshotting,
or we do not yet have a snapshot, this will call back into the RenderWidget code.

• rendering/RenderEmbeddedObject.h:

(RenderEmbeddedObject): New methods paintSnapshotImage and paintContents

• rendering/RenderWidget.cpp:

(WebCore::RenderWidget::paintContents): New method called in the middle
of paint() that can be overridden by RenderEmbeddedObject. The code here was
simply moved out of the previous paint().
(WebCore::RenderWidget::paint): Call paintContents at the appropriate time.

• rendering/RenderWidget.h:

(RenderWidget): New virtual method paintContents.

Source/WebKit2:

• WebProcess/Plugins/PluginView.cpp:

(WebKit): Reinstate 60 attempts at snapshots before giving up.
(WebKit::PluginView::isAcceleratedCompositingEnabled): We do not
want accelerated compositing enabled when we are trying to capture
snapshots.

Location:

trunk/Source

Files:

• WebCore/ChangeLog (modified) (1 diff)
• WebCore/html/HTMLPlugInElement.h (modified) (1 diff)
• WebCore/html/HTMLPlugInImageElement.cpp (modified) (1 diff)
• WebCore/html/HTMLPlugInImageElement.h (modified) (2 diffs)
• WebCore/rendering/RenderEmbeddedObject.cpp (modified) (1 diff)
• WebCore/rendering/RenderEmbeddedObject.h (modified) (1 diff)
• WebCore/rendering/RenderWidget.cpp (modified) (2 diffs)
• WebCore/rendering/RenderWidget.h (modified) (1 diff)
• WebKit2/ChangeLog (modified) (1 diff)
• WebKit2/WebProcess/Plugins/PluginView.cpp (modified) (2 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2013-02-26  Dean Jackson  <dino@apple.com>
+
+        Draw intermediate snapshots if possible
+        https://bugs.webkit.org/show_bug.cgi?id=110811
+
+        Reviewed by Simon Fraser.
+
+        After http://webkit.org/b/110495 we delayed snapshotting until we've
+        received a nice image, but this made the page look like it is broken.
+        We should draw any intermediate snapshots that we find, which might
+        include content such as progress bars/spinners.
+
+        * html/HTMLPlugInElement.h:
+        (WebCore::HTMLPlugInElement::isPlugInImageElement): Expose virtual method
+        to indicate if this is a HTMLPlugInImageElement or not.
+        * html/HTMLPlugInImageElement.cpp:
+        (WebCore::HTMLPlugInImageElement::updateSnapshot): If we have
+        a RenderEmbeddedObject renderer, then tell it to repaint.
+        * html/HTMLPlugInImageElement.h:
+        (WebCore::HTMLPlugInImageElement::snapshotImage): Expose an
+        accessor for snapshot images.
+        * rendering/RenderEmbeddedObject.cpp:
+        (WebCore::RenderEmbeddedObject::paintSnapshotImage): New helper
+        method to render an image directly. This code is similar to
+        that in RenderSnapshottedPlugIn.
+        (WebCore::RenderEmbeddedObject::paintContents): The virtual implementation
+        of this method for use when we have a snapshot to paint. If we are a plugin that is
+        in the process of being snapshotted, ask our HTMLPlugInImageElement for a
+        snapshot and paint that instead. In the case where we are not snapshotting,
+        or we do not yet have a snapshot, this will call back into the RenderWidget code.
+        * rendering/RenderEmbeddedObject.h:
+        (RenderEmbeddedObject): New methods paintSnapshotImage and paintContents
+        * rendering/RenderWidget.cpp:
+        (WebCore::RenderWidget::paintContents): New method called in the middle
+        of paint() that can be overridden by RenderEmbeddedObject. The code here was
+        simply moved out of the previous paint().
+        (WebCore::RenderWidget::paint): Call paintContents at the appropriate time.
+        * rendering/RenderWidget.h:
+        (RenderWidget): New virtual method paintContents.
+
 2013-02-26  Levi Weintraub  <leviw@chromium.org>
 

trunk/Source/WebCore/html/HTMLPlugInElement.h

@@ -75 +75 @@
     virtual bool willRespondToMouseClickEvents() OVERRIDE;
 
+    virtual bool isPlugInImageElement() const { return false; }
+
 protected:
     HTMLPlugInElement(const QualifiedName& tagName, Document*);

trunk/Source/WebCore/html/HTMLPlugInImageElement.cpp

@@ -285 +285 @@
 
     m_snapshotImage = image;
+
     if (renderer()->isSnapshottedPlugIn()) {
         toRenderSnapshottedPlugIn(renderer())->updateSnapshot(image);
         return;
     }
+
+    if (renderer()->isEmbeddedObject())
+        renderer()->repaint();
 }
 

trunk/Source/WebCore/html/HTMLPlugInImageElement.h

@@ -67 +67 @@
     void userDidClickSnapshot(PassRefPtr<MouseEvent>);
     void updateSnapshotInfo();
+    Image* snapshotImage() const { return m_snapshotImage.get(); }
 
     // Plug-in URL might not be the same as url() with overriding parameters.
@@ -112 +113 @@
     void swapRendererTimerFired(Timer<HTMLPlugInImageElement>*);
 
+    virtual bool isPlugInImageElement() const OVERRIDE { return true; }
+
     bool m_needsWidgetUpdate;
     bool m_shouldPreferPlugInsForImages;

trunk/Source/WebCore/rendering/RenderEmbeddedObject.cpp

@@ -149 +149 @@
 }
 
+void RenderEmbeddedObject::paintSnapshotImage(PaintInfo& paintInfo, const LayoutPoint& paintOffset, Image* image)
+{
+    LayoutUnit cWidth = contentWidth();
+    LayoutUnit cHeight = contentHeight();
+    if (!cWidth || !cHeight)
+        return;
+
+    GraphicsContext* context = paintInfo.context;
+    LayoutSize contentSize(cWidth, cHeight);
+    LayoutPoint contentLocation = location() + paintOffset;
+    contentLocation.move(borderLeft() + paddingLeft(), borderTop() + paddingTop());
+
+    LayoutRect rect(contentLocation, contentSize);
+    IntRect alignedRect = pixelSnappedIntRect(rect);
+    if (alignedRect.width() <= 0 || alignedRect.height() <= 0)
+        return;
+
+    bool useLowQualityScaling = shouldPaintAtLowQuality(context, image, image, alignedRect.size());
+    context->drawImage(image, style()->colorSpace(), alignedRect, CompositeSourceOver, shouldRespectImageOrientation(), useLowQualityScaling);
+}
+
+void RenderEmbeddedObject::paintContents(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
+{
+    Element* element = static_cast<Element*>(node());
+    if (!element || !element->isPluginElement())
+        return;
+
+    HTMLPlugInElement* plugInElement = static_cast<HTMLPlugInElement*>(element);
+    if (plugInElement->displayState() > HTMLPlugInElement::DisplayingSnapshot) {
+        RenderPart::paintContents(paintInfo, paintOffset);
+        return;
+    }
+
+    if (!plugInElement->isPlugInImageElement())
+        return;
+
+    Image* snapshot = static_cast<HTMLPlugInImageElement*>(plugInElement)->snapshotImage();
+    if (snapshot)
+        paintSnapshotImage(paintInfo, paintOffset, snapshot);
+}
+
 void RenderEmbeddedObject::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {

trunk/Source/WebCore/rendering/RenderEmbeddedObject.h

@@ -76 +76 @@
     virtual bool isEmbeddedObject() const { return true; }
 
+    void paintSnapshotImage(PaintInfo&, const LayoutPoint&, Image*);
+    virtual void paintContents(PaintInfo&, const LayoutPoint&) OVERRIDE;
+
 #if USE(ACCELERATED_COMPOSITING)
     virtual bool requiresLayer() const;

trunk/Source/WebCore/rendering/RenderWidget.cpp

@@ -236 +236 @@
 }
 
+void RenderWidget::paintContents(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
+{
+    LayoutPoint adjustedPaintOffset = paintOffset + location();
+
+    // Tell the widget to paint now. This is the only time the widget is allowed
+    // to paint itself. That way it will composite properly with z-indexed layers.
+    IntPoint widgetLocation = m_widget->frameRect().location();
+    IntPoint paintLocation(roundToInt(adjustedPaintOffset.x() + borderLeft() + paddingLeft()),
+        roundToInt(adjustedPaintOffset.y() + borderTop() + paddingTop()));
+    IntRect paintRect = paintInfo.rect;
+
+    IntSize widgetPaintOffset = paintLocation - widgetLocation;
+    // When painting widgets into compositing layers, tx and ty are relative to the enclosing compositing layer,
+    // not the root. In this case, shift the CTM and adjust the paintRect to be root-relative to fix plug-in drawing.
+    if (!widgetPaintOffset.isZero()) {
+        paintInfo.context->translate(widgetPaintOffset);
+        paintRect.move(-widgetPaintOffset);
+    }
+    m_widget->paint(paintInfo.context, paintRect);
+
+    if (!widgetPaintOffset.isZero())
+        paintInfo.context->translate(-widgetPaintOffset);
+
+    if (m_widget->isFrameView()) {
+        FrameView* frameView = static_cast<FrameView*>(m_widget.get());
+        bool runOverlapTests = !frameView->useSlowRepaintsIfNotOverlapped() || frameView->hasCompositedContentIncludingDescendants();
+        if (paintInfo.overlapTestRequests && runOverlapTests) {
+            ASSERT(!paintInfo.overlapTestRequests->contains(this));
+            paintInfo.overlapTestRequests->set(this, m_widget->frameRect());
+        }
+    }
+}
+
 void RenderWidget::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
@@ -275 +308 @@
     }
 
-    if (m_widget) {
-        // Tell the widget to paint now.  This is the only time the widget is allowed
-        // to paint itself.  That way it will composite properly with z-indexed layers.
-        IntPoint widgetLocation = m_widget->frameRect().location();
-        IntPoint paintLocation(roundToInt(adjustedPaintOffset.x() + borderLeft() + paddingLeft()),
-            roundToInt(adjustedPaintOffset.y() + borderTop() + paddingTop()));
-        IntRect paintRect = paintInfo.rect;
-
-        IntSize widgetPaintOffset = paintLocation - widgetLocation;
-        // When painting widgets into compositing layers, tx and ty are relative to the enclosing compositing layer,
-        // not the root. In this case, shift the CTM and adjust the paintRect to be root-relative to fix plug-in drawing.
-        if (!widgetPaintOffset.isZero()) {
-            paintInfo.context->translate(widgetPaintOffset);
-            paintRect.move(-widgetPaintOffset);
-        }
-        m_widget->paint(paintInfo.context, paintRect);
-
-        if (!widgetPaintOffset.isZero())
-            paintInfo.context->translate(-widgetPaintOffset);
-
-        if (m_widget->isFrameView()) {
-            FrameView* frameView = static_cast<FrameView*>(m_widget.get());
-            bool runOverlapTests = !frameView->useSlowRepaintsIfNotOverlapped() || frameView->hasCompositedContentIncludingDescendants();
-            if (paintInfo.overlapTestRequests && runOverlapTests) {
-                ASSERT(!paintInfo.overlapTestRequests->contains(this));
-                paintInfo.overlapTestRequests->set(this, m_widget->frameRect());
-            }
-         }
-    }
+    if (m_widget)
+        paintContents(paintInfo, paintOffset);
 
     if (style()->hasBorderRadius())

trunk/Source/WebCore/rendering/RenderWidget.h

@@ -86 +86 @@
     virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) OVERRIDE;
 
+    virtual void paintContents(PaintInfo&, const LayoutPoint&);
+
 private:
     virtual bool isWidget() const { return true; }

trunk/Source/WebKit2/ChangeLog

@@ +1 @@
+2013-02-26  Dean Jackson  <dino@apple.com>
+
+        Draw intermediate snapshots if possible
+        https://bugs.webkit.org/show_bug.cgi?id=110811
+
+        Reviewed by Simon Fraser.
+
+        After http://webkit.org/b/110495 we delayed snapshotting until we've
+        received a nice image, but this made the page look like it is broken.
+        We should draw any intermediate snapshots that we find, which might
+        include content such as progress bars/spinners.
+
+        * WebProcess/Plugins/PluginView.cpp:
+        (WebKit): Reinstate 60 attempts at snapshots before giving up.
+        (WebKit::PluginView::isAcceleratedCompositingEnabled): We do not
+        want accelerated compositing enabled when we are trying to capture
+        snapshots.
+
 2013-02-26  Andras Becsi  <andras.becsi@digia.com>
 

trunk/Source/WebKit2/WebProcess/Plugins/PluginView.cpp

@@ -72 +72 @@
 // This simulated mouse click delay in HTMLPlugInImageElement.cpp should generally be the same or shorter than this delay.
 static const double pluginSnapshotTimerDelay = 1.1;
-static const unsigned maximumSnapshotRetries = 4;
+static const unsigned maximumSnapshotRetries = 60;
 
 class PluginView::URLRequest : public RefCounted<URLRequest> {
@@ -1350 +1350 @@
         return false;
 
+    if (m_pluginElement->displayState() < HTMLPlugInElement::PlayingWithPendingMouseClick)
+        return false;
     return settings->acceleratedCompositingEnabled();
 }