2010-02-04 No'am Rosenthal <noam.rosenthal@nokia.com>

        Reviewed by Ariya Hidayat.

        [Qt] Tuning and optimizations to GraphicsLayerQt. Reduce unnecessary
        recaching, remove QTimer::singleShot and QPixmap::scaled, more
        accurate strategy of handling transform operation blends. Rotating a
        bordered-table, for example, now runs at 50FPS instead of 40FPS on Maemo5.

        https://bugs.webkit.org/show_bug.cgi?id=34062

        This is tested by https://bugs.webkit.org/show_bug.cgi?id=34450, fps measurements.

        * platform/graphics/qt/GraphicsLayerQt.cpp:
        (WebCore::GraphicsLayerQtImpl::flushChanges): Fine-tune caching
        (WebCore::TransformAnimationQt::TransformAnimationQt): transform bugs
        (WebCore::OpacityAnimationQt::updateState): style change
2010-02-04  No'am Rosenthal  <noam.rosenthal@nokia.com>

        Reviewed by Ariya Hidayat.

        [Qt] Tuning and optimizations to GraphicsLayerQt. Mainly reduced usage
        of QTimer::singleShot, and moved syncLayers() from paint() to update()
        https://bugs.webkit.org/show_bug.cgi?id=34062

        * Api/qgraphicswebview.cpp:
        (QGraphicsWebViewPrivate::update): Moved the sync operation to update
        (QGraphicsWebView::paint): Moved the sync operation to update

git-svn-id: svn://svn.chromium.org/blink/trunk@54344 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/WebCore/ChangeLog

+2010-02-04  No'am Rosenthal  <noam.rosenthal@nokia.com>
+
+        Reviewed by Ariya Hidayat.
+
+        [Qt] Tuning and optimizations to GraphicsLayerQt. Reduce unnecessary
+        recaching, remove QTimer::singleShot and QPixmap::scaled, more
+        accurate strategy of handling transform operation blends. Rotating a
+        bordered-table, for example, now runs at 50FPS instead of 40FPS on Maemo5.
+
+        https://bugs.webkit.org/show_bug.cgi?id=34062
+
+        This is tested by https://bugs.webkit.org/show_bug.cgi?id=34450, fps measurements.
+
+        * platform/graphics/qt/GraphicsLayerQt.cpp:
+        (WebCore::GraphicsLayerQtImpl::flushChanges): Fine-tune caching
+        (WebCore::TransformAnimationQt::TransformAnimationQt): transform bugs
+        (WebCore::OpacityAnimationQt::updateState): style change
+
 2010-02-04  Pavel Feldman  <pfeldman@chromium.org>
 
         Reviewed by Timothy Hatcher.

third_party/WebKit/WebCore/platform/graphics/qt/GraphicsLayerQt.cpp

@@ -99,14 +99,26 @@ public:
     // or ChromeClientQt::scheduleCompositingLayerSync (meaning the sync will happen ASAP)
     void flushChanges(bool recursive = true);
 
+    // optimization: when we have an animation running on an element with no contents, that has child-elements with contents,
+    // ALL of them have to have ItemCoordinateCache and not DeviceCoordinateCache
+    void adjustCachingRecursively(bool animationIsRunning);
+
+    // optimization: returns true if this or an ancestor has a transform animation running.
+    // this enables us to use ItemCoordinatesCache while the animation is running, otherwise we have to recache for every frame
+    bool isTransformAnimationRunning() const;
+
 public slots:
     // we need to notify the client (aka the layer compositor) when the animation actually starts
     void notifyAnimationStarted();
 
+signals:
+    // optimization: we don't want to use QTimer::singleShot
+    void notifyAnimationStartedAsync();
+
 public:
     GraphicsLayerQt* m_layer;
 
-    QTransform m_baseTransfom;
+    QTransform m_baseTransform;
     bool m_transformAnimationRunning;
     bool m_opacityAnimationRunning;
 
@@ -157,12 +169,14 @@ public:
         bool backfaceVisibility: 1;
         bool distributeOpacity: 1;
         bool align: 2;
-        State(): maskLayer(0), opacity(1), preserves3D(false), masksToBounds(false),
+        State(): maskLayer(0), opacity(1.f), preserves3D(false), masksToBounds(false),
                   drawsContent(false), contentsOpaque(false), backfaceVisibility(false),
                   distributeOpacity(false)
         {
         }
     } m_state;
+
+    friend class AnimationQtBase;
 };
 
 GraphicsLayerQtImpl::GraphicsLayerQtImpl(GraphicsLayerQt* newLayer)
@@ -171,16 +185,14 @@ GraphicsLayerQtImpl::GraphicsLayerQtImpl(GraphicsLayerQt* newLayer)
     , m_transformAnimationRunning(false)
     , m_changeMask(NoChanges)
 {
-    // better to calculate the exposed rect in QGraphicsView than over-render in WebCore
-    // FIXME: test different approaches
-    setFlag(QGraphicsItem::ItemUsesExtendedStyleOption, true);
-
     // we use graphics-view for compositing, not for interactivity
     setAcceptedMouseButtons(Qt::NoButton);
     setEnabled(false);
 
     // we'll set the cache when we know what's going on
     setCacheMode(NoCache);
+
+    connect(this, SIGNAL(notifyAnimationStartedAsync()), this, SLOT(notifyAnimationStarted()), Qt::QueuedConnection);
 }
 
 GraphicsLayerQtImpl::~GraphicsLayerQtImpl()
@@ -203,22 +215,42 @@ GraphicsLayerQtImpl::~GraphicsLayerQtImpl()
             delete anim;
 }
 
+void GraphicsLayerQtImpl::adjustCachingRecursively(bool animationIsRunning)
+{
+    // optimization: we make sure all our children have ItemCoordinateCache -
+    // otherwise we end up re-rendering them during the animation
+    const QList<QGraphicsItem*> children = childItems();
+
+    for (QList<QGraphicsItem*>::const_iterator it = children.begin(); it != children.end(); ++it) {
+        if (QGraphicsItem* item = *it)
+            if (GraphicsLayerQtImpl* layer = qobject_cast<GraphicsLayerQtImpl*>(item->toGraphicsObject())) {
+                if (layer->m_layer->drawsContent() && layer->m_currentContent.contentType == HTMLContentType)
+                    layer->setCacheMode(animationIsRunning ? QGraphicsItem::ItemCoordinateCache : QGraphicsItem::DeviceCoordinateCache);
+            }
+    }    
+}
+
 void GraphicsLayerQtImpl::setBaseTransform(const QTransform& transform)
 {
     if (!m_layer)
         return;
-    // webkit has relative-to-size originPoint, graphics-view has a pixel originPoint
-    // here we convert
-    QPointF originTranslate(
-            m_layer->anchorPoint().x() * m_layer->size().width(), m_layer->anchorPoint().y() * m_layer->size().height());
-
-    resetTransform();
-
-    // we have to manage this ourselves because QGraphicsView's transformOrigin is incomplete
-    translate(originTranslate.x(), originTranslate.y());
+    // webkit has relative-to-size originPoint, graphics-view has a pixel originPoint, here we convert
+    // we have to manage this ourselves because QGraphicsView's transformOrigin is incompatible
+    const qreal x = m_layer->anchorPoint().x() * m_layer->size().width();
+    const qreal y = m_layer->anchorPoint().y() * m_layer->size().height();
+    setTransform(QTransform::fromTranslate(x, y));
     setTransform(transform, true);
-    translate(-originTranslate.x(), -originTranslate.y());
-    m_baseTransfom = transform;
+    translate(-x, -y);
+    m_baseTransform = transform;
+}
+
+bool GraphicsLayerQtImpl::isTransformAnimationRunning() const
+{
+    if (m_transformAnimationRunning)
+        return true;
+    if (GraphicsLayerQtImpl* parent = qobject_cast<GraphicsLayerQtImpl*>(parentObject()))
+        return parent->isTransformAnimationRunning();
+    return false;
 }
 
 QPainterPath GraphicsLayerQtImpl::opaqueArea() const
@@ -270,42 +302,31 @@ void GraphicsLayerQtImpl::paint(QPainter* painter, const QStyleOptionGraphicsIte
     drawContents(painter, option->exposedRect);
 }
 
-void GraphicsLayerQtImpl::drawContents(QPainter* painter, const QRectF& r, bool mask)
+void GraphicsLayerQtImpl::drawContents(QPainter* painter, const QRectF& exposedRect, bool mask)
 {
-    QRect rect = r.toAlignedRect();
-    
-    if (m_currentContent.contentType != HTMLContentType && !m_state.contentsRect.isEmpty())
-        rect = rect.intersected(m_state.contentsRect);
-
     if (m_currentContent.backgroundColor.isValid())
-        painter->fillRect(r, QColor(m_currentContent.backgroundColor));
+        painter->fillRect(exposedRect, QColor(m_currentContent.backgroundColor));
 
-    if (!rect.isEmpty()) {
-        switch (m_currentContent.contentType) {
-        case PixmapContentType:
-            // we have to scale the image to the contentsRect
-            // FIXME: a better way would probably be drawPixmap with a src/target rect
-            painter->drawPixmap(rect.topLeft(), m_currentContent.pixmap.scaled(m_state.contentsRect.size()), r);
-            break;
-        case ColorContentType:
-            painter->fillRect(rect, m_currentContent.contentsBackgroundColor);
-            break;
-        default:
-            if (m_state.drawsContent) {
-                // this is the "expensive" bit. we try to minimize calls to this
-                // neck of the woods by proper caching
-                GraphicsContext gc(painter);
-                m_layer->paintGraphicsLayerContents(gc, rect);
-            }
-            break;
+    switch (m_currentContent.contentType) {
+    case PixmapContentType:
+        painter->drawPixmap(m_state.contentsRect, m_currentContent.pixmap);
+        break;
+    case ColorContentType:
+        painter->fillRect(m_state.contentsRect, m_currentContent.contentsBackgroundColor);
+        break;
+    default:
+        if (m_state.drawsContent) {
+            // this is the "expensive" bit. we try to minimize calls to this neck of the woods by proper caching
+            GraphicsContext gc(painter);
+            m_layer->paintGraphicsLayerContents(gc, exposedRect.toAlignedRect());
         }
+        break;
     }
 }
 
 void GraphicsLayerQtImpl::notifyChange(ChangeMask changeMask)
 {
-    if (!this)
-        return;
+    Q_ASSERT(this);
 
     m_changeMask |= changeMask;
 
@@ -342,14 +363,14 @@ void GraphicsLayerQtImpl::flushChanges(bool recursive)
         const QSet<QGraphicsItem*> currentChildren = childItems().toSet();
         const QSet<QGraphicsItem*> childrenToAdd = newChildren - currentChildren;
         const QSet<QGraphicsItem*> childrenToRemove = currentChildren - newChildren;
-        for (QSet<QGraphicsItem*>::const_iterator it = childrenToAdd.begin(); it != childrenToAdd.end(); ++it) {
+
+        for (QSet<QGraphicsItem*>::const_iterator it = childrenToAdd.begin(); it != childrenToAdd.end(); ++it)
              if (QGraphicsItem* w = *it)
                 w->setParentItem(this);
-        }
-        for (QSet<QGraphicsItem*>::const_iterator it = childrenToRemove.begin(); it != childrenToRemove.end(); ++it) {
+
+        for (QSet<QGraphicsItem*>::const_iterator it = childrenToRemove.begin(); it != childrenToRemove.end(); ++it)
              if (QGraphicsItem* w = *it)
                 w->setParentItem(0);
-        }
 
         // children are ordered by z-value, let graphics-view know.
         for (size_t i = 0; i < newChildrenVector.size(); ++i)
@@ -383,17 +404,17 @@ void GraphicsLayerQtImpl::flushChanges(bool recursive)
         // the anchor-point, transform and size from WebCore all affect the one
         // that we give Qt
         if (m_state.transform != m_layer->transform() || m_state.anchorPoint != m_layer->anchorPoint() || m_state.size != m_layer->size())
-            setBaseTransform(QTransform(m_layer->transform()));
+            setBaseTransform(m_layer->transform());
     }
 
     if (m_changeMask & (ContentChange | DrawsContentChange)) {
         switch (m_pendingContent.contentType) {
         case PixmapContentType:
-            // we need cache even for images, because they need to be resized
-            // to the contents rect. maybe this can be optimized though
-            setCacheMode(m_transformAnimationRunning ? ItemCoordinateCache : DeviceCoordinateCache);
             update();
             setFlag(ItemHasNoContents, false);
+
+            // we only use ItemUsesExtendedStyleOption for HTML content - pixmap can be handled better with regular clipping
+            setFlag(QGraphicsItem::ItemUsesExtendedStyleOption, false);
             break;
 
         case ColorContentType:
@@ -403,6 +424,9 @@ void GraphicsLayerQtImpl::flushChanges(bool recursive)
                 update();
             m_state.drawsContent = false;
             setFlag(ItemHasNoContents, false);
+
+            // we only use ItemUsesExtendedStyleOption for HTML content - colors don't gain much from that anyway
+            setFlag(QGraphicsItem::ItemUsesExtendedStyleOption, false);
             break;
 
         case HTMLContentType:
@@ -410,8 +434,16 @@ void GraphicsLayerQtImpl::flushChanges(bool recursive)
                 update();
             if (!m_state.drawsContent && m_layer->drawsContent())
                 update();
-            if (m_layer->drawsContent())
-                setCacheMode(m_transformAnimationRunning ? ItemCoordinateCache : DeviceCoordinateCache);
+                if (m_layer->drawsContent()) {
+                    const QGraphicsItem::CacheMode mewCacheMode = isTransformAnimationRunning() ? ItemCoordinateCache : DeviceCoordinateCache;
+
+                    // optimization: QGraphicsItem doesn't always perform this test
+                    if (mewCacheMode != cacheMode())
+                        setCacheMode(mewCacheMode);
+
+                    // HTML content: we want to use exposedRect so we don't use WebCore rendering if we don't have to
+                    setFlag(QGraphicsItem::ItemUsesExtendedStyleOption, true);
+                }
             else
                 setCacheMode(NoCache);
 
@@ -448,7 +480,7 @@ void GraphicsLayerQtImpl::flushChanges(bool recursive)
         update();
 
     // FIXME: the following flags are currently not handled, as they don't have a clear test or are in low priority
-    // GeometryOrientationChange, ContentsOrientationChange, BackfaceVisibilityChange, ChildrenTransformChange
+    // GeometryOrientationChange, ContentsOrientationChange, BackfaceVisibilityChange, ChildrenTransformChange, Preserves3DChange
 
     m_state.maskLayer = m_layer->maskLayer();
     m_state.pos = m_layer->position();
@@ -523,9 +555,9 @@ void GraphicsLayerQt::setNeedsDisplay()
 }
 
 // reimp from GraphicsLayer.h
-void GraphicsLayerQt::setNeedsDisplayInRect(const FloatRect& r)
+void GraphicsLayerQt::setNeedsDisplayInRect(const FloatRect& rect)
 {
-    m_impl->m_pendingContent.regionToUpdate|= QRectF(r).toAlignedRect();
+    m_impl->m_pendingContent.regionToUpdate|= QRectF(rect).toAlignedRect();
     m_impl->notifyChange(GraphicsLayerQtImpl::DisplayChange);
 }
 
@@ -807,16 +839,16 @@ static inline double solveCubicBezierFunction(qreal p1x, qreal p1y, qreal p2x, q
 // Using easing-curves would probably work for some of the cases, but wouldn't really buy us anything as we'd have to convert the bezier function back to an easing curve
 static inline qreal applyTimingFunction(const TimingFunction& timingFunction, qreal progress, int duration)
 {
-    if (timingFunction.type() == LinearTimingFunction)
+        if (timingFunction.type() == LinearTimingFunction)
+            return progress;
+        if (timingFunction.type() == CubicBezierTimingFunction) {
+            return solveCubicBezierFunction(timingFunction.x1(),
+                                            timingFunction.y1(),
+                                            timingFunction.x2(),
+                                            timingFunction.y2(),
+                                            double(progress), double(duration) / 1000);
+        }
         return progress;
-    if (timingFunction.type() == CubicBezierTimingFunction) {
-        return solveCubicBezierFunction(timingFunction.x1(),
-                                        timingFunction.y1(),
-                                        timingFunction.x2(),
-                                        timingFunction.y2(),
-                                        double(progress), double(duration) / 1000);
-    }
-    return progress;
 }
 
 // helper functions to safely get a value out of WebCore's AnimationValue*
@@ -826,9 +858,7 @@ static void webkitAnimationToQtAnimationValue(const AnimationValue* animationVal
     if (!animationValue)
         return;
 
-    const TransformOperations* ops = static_cast<const TransformAnimationValue*>(animationValue)->value();
-
-    if (ops)
+    if (const TransformOperations* ops = static_cast<const TransformAnimationValue*>(animationValue)->value())
         transformOperations = *ops;
 }
 
@@ -856,8 +886,8 @@ public:
         QAbstractAnimation::updateState(newState, oldState);
 
         // for some reason I have do this asynchronously - or the animation won't work
-        if (newState == Running && oldState == Stopped)
-            QTimer::singleShot(0, m_layer.data(), SLOT(notifyAnimationStarted()));
+        if (newState == Running && oldState == Stopped && m_layer.data())
+            m_layer.data()->notifyAnimationStartedAsync();
     }
 
     virtual int duration() const { return m_duration; }
@@ -932,9 +962,10 @@ protected:
 
         // now we have a source keyframe, origin keyframe and a timing function
         // we can now process the progress and apply the frame
-        qreal normalizedProgress = (it.key() == it2.key()) ? 0 : (progress - it.key()) / (it2.key() - it.key());
-        normalizedProgress = applyTimingFunction(timingFunc, normalizedProgress, duration() / 1000);
-        applyFrame(fromValue, toValue, normalizedProgress);
+        progress = (!progress || progress == 1 || it.key() == it2.key())
+                                         ? progress
+                                         : applyTimingFunction(timingFunc, (progress - it.key()) / (it2.key() - it.key()), duration() / 1000);
+        applyFrame(fromValue, toValue, progress);
     }
 
     QMap<qreal, KeyframeValueQt<T> > m_keyframeValues;
@@ -943,7 +974,7 @@ protected:
 class TransformAnimationQt : public AnimationQt<TransformOperations> {
 public:
     TransformAnimationQt(GraphicsLayerQtImpl* layer, const KeyframeValueList& values, const IntSize& boxSize, const Animation* anim, const QString & name)
-                : AnimationQt<TransformOperations>(layer, values, boxSize, anim, name)
+        : AnimationQt<TransformOperations>(layer, values, boxSize, anim, name)
     {
     }
 
@@ -952,7 +983,7 @@ public:
         // this came up during the compositing/animation LayoutTests
         // when the animation dies, the transform has to go back to default
         if (m_layer)
-            m_layer.data()->setBaseTransform(QTransform(m_layer.data()->m_layer->transform()));
+            m_layer.data()->setBaseTransform(m_layer.data()->m_layer->transform());
     }
 
     // the idea is that we let WebCore manage the transform-operations
@@ -963,11 +994,22 @@ public:
     {
         TransformationMatrix transformMatrix;
 
-        // this looks simple but is really tricky to get right. Use caution.
-        for (size_t i = 0; i < targetOperations.size(); ++i)
-            targetOperations.operations()[i]->blend(sourceOperations.at(i), progress)->apply(transformMatrix, m_boxSize);
-
-        m_layer.data()->setBaseTransform(QTransform(transformMatrix));
+        // sometimes the animation values from WebCore are misleading and we have to use the actual matrix as source
+        // The Mac implementation simply doesn't try to accelerate those (e.g. 360deg rotation), but we do.
+        if (progress == 1 || !targetOperations.size() || sourceOperations == targetOperations) {
+            TransformationMatrix sourceMatrix;
+            sourceOperations.apply(m_boxSize, sourceMatrix);
+            transformMatrix = m_sourceMatrix;
+            transformMatrix.blend(sourceMatrix, 1 - progress);
+        } else if (targetOperations.size() != sourceOperations.size()) {
+            transformMatrix = m_sourceMatrix;
+            targetOperations.apply(m_boxSize, transformMatrix);
+            transformMatrix.blend(m_sourceMatrix, progress);
+        } else {
+            for (size_t i = 0; i < targetOperations.size(); ++i)
+                targetOperations.operations()[i]->blend(sourceOperations.at(i), progress)->apply(transformMatrix, m_boxSize);
+        }
+        m_layer.data()->setBaseTransform(transformMatrix);
     }
 
     virtual void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
@@ -980,15 +1022,16 @@ public:
         // to increase FPS, we use a less accurate caching mechanism while animation is going on
         // this is a UX choice that should probably be customizable
         if (newState == QAbstractAnimation::Running) {
+            m_sourceMatrix = m_layer.data()->m_layer->transform();
             m_layer.data()->m_transformAnimationRunning = true;
-            if (m_layer.data()->cacheMode() == QGraphicsItem::DeviceCoordinateCache)
-                m_layer.data()->setCacheMode(QGraphicsItem::ItemCoordinateCache);
+            m_layer.data()->adjustCachingRecursively(true);
         } else {
             m_layer.data()->m_transformAnimationRunning = false;
-            if (m_layer.data()->cacheMode() == QGraphicsItem::ItemCoordinateCache)
-                m_layer.data()->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
+            m_layer.data()->adjustCachingRecursively(false);
         }
     }
+
+    TransformationMatrix m_sourceMatrix;
 };
 
 class OpacityAnimationQt : public AnimationQt<qreal> {
@@ -1006,6 +1049,7 @@ public:
     virtual void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
     {
         QAbstractAnimation::updateState(newState, oldState);
+
         if (m_layer)
             m_layer.data()->m_opacityAnimationRunning = (newState == QAbstractAnimation::Running);
     }
@@ -1079,11 +1123,12 @@ void GraphicsLayerQt::removeAnimationsForKeyframes(const String& name)
 void GraphicsLayerQt::pauseAnimation(const String& name, double timeOffset)
 {
     for (QList<QWeakPointer<QAbstractAnimation> >::iterator it = m_impl->m_animations.begin(); it != m_impl->m_animations.end(); ++it) {
-        if (*it) {
-            AnimationQtBase* anim = static_cast<AnimationQtBase*>((*it).data());
-            if (anim && anim->m_keyframesName == QString(name))
-                QTimer::singleShot(timeOffset * 1000, anim, SLOT(pause()));
-        }
+        if (!(*it))
+            continue;
+
+        AnimationQtBase* anim = static_cast<AnimationQtBase*>((*it).data());
+        if (anim && anim->m_keyframesName == QString(name))
+            QTimer::singleShot(timeOffset * 1000, anim, SLOT(pause()));
     }
 }
 

third_party/WebKit/WebKit/qt/Api/qgraphicswebview.cpp

@@ -27,6 +27,7 @@
 #include "qwebpage_p.h"
 #include "QWebPageClient.h"
 #include <FrameView.h>
+#include <QtCore/qmetaobject.h>
 #include <QtCore/qsharedpointer.h>
 #include <QtCore/qtimer.h>
 #include <QtGui/qapplication.h>
@@ -78,13 +79,14 @@ public:
         , page(0)
 #if USE(ACCELERATED_COMPOSITING)
         , rootGraphicsLayer(0)
-        , shouldSync(true)
+        , shouldSync(false)
 #endif
     {
 #if USE(ACCELERATED_COMPOSITING)
         // the overlay and stays alive for the lifetime of
         // this QGraphicsWebView as the scrollbars are needed when there's no compositing
         q->setFlag(QGraphicsItem::ItemUsesExtendedStyleOption);
+        syncMetaMethod = q->metaObject()->method(q->metaObject()->indexOfMethod("syncLayers()"));
 #endif
     }
 
@@ -131,6 +133,9 @@ public:
     // compositor telling us to do so. We'll get that call from ChromeClientQt
     bool shouldSync;
 
+    // we have to flush quite often, so we use a meta-method instead of QTimer::singleShot for putting the event in the queue
+    QMetaMethod syncMetaMethod;
+
     // we need to put the root graphics layer behind the overlay (which contains the scrollbar)
     enum { RootGraphicsLayerZValue, OverlayZValue };
 #endif
@@ -178,7 +183,7 @@ void QGraphicsWebViewPrivate::markForSync(bool scheduleSync)
 {
     shouldSync = true;
     if (scheduleSync)
-        QTimer::singleShot(0, q, SLOT(syncLayers()));
+        syncMetaMethod.invoke(q, Qt::QueuedConnection);
 }
 
 void QGraphicsWebViewPrivate::updateCompositingScrollPosition()
@@ -224,6 +229,7 @@ void QGraphicsWebViewPrivate::update(const QRect & dirtyRect)
 #if USE(ACCELERATED_COMPOSITING)
     if (overlay)
         overlay->update(QRectF(dirtyRect));
+    syncLayers();
 #endif
 }
 
@@ -442,7 +448,6 @@ void QGraphicsWebView::paint(QPainter* painter, const QStyleOptionGraphicsItem*
 {
 #if USE(ACCELERATED_COMPOSITING)
     page()->mainFrame()->render(painter, d->overlay ? QWebFrame::ContentsLayer : QWebFrame::AllLayers, option->exposedRect.toAlignedRect());
-    d->syncLayers();
 #else
     page()->mainFrame()->render(painter, QWebFrame::AllLayers, option->exposedRect.toRect());
 #endif

third_party/WebKit/WebKit/qt/ChangeLog

+2010-02-04  No'am Rosenthal  <noam.rosenthal@nokia.com>
+
+        Reviewed by Ariya Hidayat.
+
+        [Qt] Tuning and optimizations to GraphicsLayerQt. Mainly reduced usage
+        of QTimer::singleShot, and moved syncLayers() from paint() to update()
+        https://bugs.webkit.org/show_bug.cgi?id=34062
+
+        * Api/qgraphicswebview.cpp:
+        (QGraphicsWebViewPrivate::update): Moved the sync operation to update
+        (QGraphicsWebView::paint): Moved the sync operation to update
+
 2010-02-03  Andras Becsi  <abecsi@webkit.org>
 
         Unreviewed build fix.