Changeset 110388 in webkit


Ignore:
Timestamp:
Mar 11, 2012 12:26:07 AM (12 years ago)
Author:
ostapenko.viatcheslav@nokia.com
Message:

[Qt] [WK2] Support threaded renderer in WK2
​https://bugs.webkit.org/show_bug.cgi?id=76661

Source/WebCore:

Reviewed by Noam Rosenthal.

Add TransformationMatrix conversions from/to Qt QMatrix4x4. Used by Qt WebKit2
rendering and tested by Qt WebKit2 API tests.

  • platform/graphics/qt/TransformationMatrixQt.cpp:

(WebCore::TransformationMatrix::operator QMatrix4x4):
(WebCore):
(WebCore::TransformationMatrix::TransformationMatrix):

  • platform/graphics/transforms/TransformationMatrix.h:

(TransformationMatrix):

Source/WebKit2:

Reviewed by Noam Rosenthal.

Implement Qt5 threaded rendering support for Qt WebKit2.
Parts of LayerTreeHostProxy which contain layer tree and layer painting objects
are moved to separate class called WebLayerTreeRenderer. WebLayerTreeRenderer is
thread safe ref counted and referenced by LayerTreeHostProxy and paint node.
All layer tree and graphics objects are created, accessed and deallocated from Qt
Scenegraph's paint thread only.
Layer tree updates from render queue are fetched in updatePaintNode call stack when
main thread is locked.
Messages from paint thread to web process are passed through MainThreadGuardedInvoker
call gate (implemented by Noam Rosenthal and previously reviewed by Kenneth Rohde
Christiansen).

  • Target.pri:
  • UIProcess/API/qt/qquickwebpage.cpp:

(PageProxyNode::PageProxyNode):
(PageProxyNode::render):
(PageProxyNode::~PageProxyNode):
(PageProxyNode::layerTreeRenderer):
(PageProxyNode):
(PageProxyNode::setScale):
(QQuickWebPage::updatePaintNode):
(QQuickWebPagePrivate::~QQuickWebPagePrivate):

  • UIProcess/LayerTreeHostProxy.cpp: Added.

(WebKit):
(WebKit::LayerTreeHostProxy::LayerTreeHostProxy):
(WebKit::LayerTreeHostProxy::~LayerTreeHostProxy):
(WebKit::LayerTreeHostProxy::paintToCurrentGLContext):
(WebKit::LayerTreeHostProxy::paintToGraphicsContext):
(WebKit::LayerTreeHostProxy::updateViewport):
(WebKit::LayerTreeHostProxy::dispatchUpdate):
(WebKit::LayerTreeHostProxy::createTileForLayer):
(WebKit::LayerTreeHostProxy::updateTileForLayer):
(WebKit::LayerTreeHostProxy::removeTileForLayer):
(WebKit::LayerTreeHostProxy::deleteCompositingLayer):
(WebKit::LayerTreeHostProxy::setRootCompositingLayer):
(WebKit::LayerTreeHostProxy::syncCompositingLayerState):
(WebKit::LayerTreeHostProxy::didRenderFrame):
(WebKit::LayerTreeHostProxy::createDirectlyCompositedImage):
(WebKit::LayerTreeHostProxy::destroyDirectlyCompositedImage):
(WebKit::LayerTreeHostProxy::setVisibleContentsRectForPanning):
(WebKit::LayerTreeHostProxy::setVisibleContentsRectForScaling):
(WebKit::LayerTreeHostProxy::renderNextFrame):
(WebKit::LayerTreeHostProxy::purgeBackingStores):

  • UIProcess/LayerTreeHostProxy.h:

(WebKit):
(LayerTreeHostProxy):
(WebKit::LayerTreeHostProxy::layerTreeRenderer):

  • UIProcess/WebLayerTreeRenderer.cpp: Renamed from Source/WebKit2/UIProcess/qt/LayerTreeHostProxyQt.cpp.

(WebKit):
(MainThreadGuardedInvoker):
(WebKit::MainThreadGuardedInvoker::call):
(WebKit::MainThreadGuardedInvoker::MainThreadGuardedInvoker):
(WebKit::MainThreadGuardedInvoker::invoke):
(WebKit::WebLayerTreeRenderer::callOnMainTread):
(WebKit::WebLayerTreeRenderer::WebLayerTreeRenderer):
(WebKit::WebLayerTreeRenderer::~WebLayerTreeRenderer):
(WebKit::WebLayerTreeRenderer::createLayer):
(WebKit::WebLayerTreeRenderer::paintToCurrentGLContext):
(WebKit::WebLayerTreeRenderer::syncAnimations):
(WebKit::WebLayerTreeRenderer::paintToGraphicsContext):
(WebKit::WebLayerTreeRenderer::setVisibleContentsRectForScaling):
(WebKit::WebLayerTreeRenderer::updateViewport):
(WebKit::WebLayerTreeRenderer::syncLayerParameters):
(WebKit::WebLayerTreeRenderer::deleteLayer):
(WebKit::WebLayerTreeRenderer::ensureLayer):
(WebKit::WebLayerTreeRenderer::setRootLayerID):
(WebKit::WebLayerTreeRenderer::getBackingStore):
(WebKit::WebLayerTreeRenderer::createTile):
(WebKit::WebLayerTreeRenderer::removeTile):
(WebKit::WebLayerTreeRenderer::updateTile):
(WebKit::WebLayerTreeRenderer::createImage):
(WebKit::WebLayerTreeRenderer::destroyImage):
(WebKit::WebLayerTreeRenderer::assignImageToLayer):
(WebKit::WebLayerTreeRenderer::swapBuffers):
(WebKit::WebLayerTreeRenderer::flushLayerChanges):
(WebKit::WebLayerTreeRenderer::renderNextFrame):
(WebKit::WebLayerTreeRenderer::ensureRootLayer):
(WebKit::WebLayerTreeRenderer::syncRemoteContent):
(WebKit::WebLayerTreeRenderer::purgeGLResources):
(WebKit::WebLayerTreeRenderer::purgeBackingStores):
(WebKit::WebLayerTreeRenderer::detach):
(WebKit::WebLayerTreeRenderer::appendUpdate):

  • UIProcess/WebLayerTreeRenderer.h: Copied from Source/WebKit2/UIProcess/LayerTreeHostProxy.h.

(WebKit):
(WebLayerTreeRenderer):
(WebKit::WebLayerTreeRenderer::layerByID):
(WebKit::WebLayerTreeRenderer::rootLayer):
(WebKit::WebLayerTreeRenderer::notifyAnimationStarted):
(WebKit::WebLayerTreeRenderer::notifySyncRequired):
(WebKit::WebLayerTreeRenderer::showDebugBorders):
(WebKit::WebLayerTreeRenderer::showRepaintCounter):
(WebKit::WebLayerTreeRenderer::paintContents):

Tools:

Remove disabling of threaded rendering.

Reviewed by Noam Rosenthal.

  • MiniBrowser/qt/main.cpp:

(main):

Location:
trunk
Files:
1 added
9 edited
1 copied
1 moved

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r110381 r110388  
     12012-03-11  Viatcheslav Ostapenko  <ostapenko.viatcheslav@nokia.com>
     2
     3        [Qt] [WK2] Support threaded renderer in WK2
     4        https://bugs.webkit.org/show_bug.cgi?id=76661
     5
     6        Reviewed by Noam Rosenthal.
     7
     8        Add TransformationMatrix conversions from/to Qt QMatrix4x4. Used by Qt WebKit2
     9        rendering and tested by Qt WebKit2 API tests.
     10
     11        * platform/graphics/qt/TransformationMatrixQt.cpp:
     12        (WebCore::TransformationMatrix::operator QMatrix4x4):
     13        (WebCore):
     14        (WebCore::TransformationMatrix::TransformationMatrix):
     15        * platform/graphics/transforms/TransformationMatrix.h:
     16        (TransformationMatrix):
     17
    1182012-03-09  Jon Lee  <jonlee@apple.com>
    219

  • trunk/Source/WebCore/platform/graphics/qt/TransformationMatrixQt.cpp

    r94188 r110388  
    5151}
    5252
     53TransformationMatrix::operator QMatrix4x4() const
     54{
     55    return QMatrix4x4(m11(), m12(), m13(), m14(),
     56                      m21(), m22(), m23(), m24(),
     57                      m31(), m32(), m33(), m34(),
     58                      m41(), m42(), m43(), m44());
     59}
     60
     61TransformationMatrix::TransformationMatrix(const QMatrix4x4& matrix)
     62{
     63    setMatrix(matrix(0, 0), matrix(1, 0), matrix(2, 0), matrix(3, 0),
     64              matrix(0, 1), matrix(1, 1), matrix(2, 1), matrix(3, 1),
     65              matrix(0, 2), matrix(1, 2), matrix(2, 2), matrix(3, 2),
     66              matrix(0, 3), matrix(1, 3), matrix(2, 3), matrix(3, 3));
     67}
     68
    5369}
    5470

  • trunk/Source/WebCore/platform/graphics/transforms/TransformationMatrix.h

    r110322 r110388  
    4343#include "VGUtils.h"
    4444#elif PLATFORM(QT)
     45#include <QMatrix4x4>
    4546#include <QTransform>
    4647#elif USE(SKIA)
    … …  
    8586#if PLATFORM(QT)
    8687    TransformationMatrix(const QTransform&);
     88    TransformationMatrix(const QMatrix4x4&);
    8789#endif
    8890
    … …  
    332334#elif PLATFORM(QT)
    333335    operator QTransform() const;
     336    operator QMatrix4x4() const;
    334337#elif USE(SKIA)
    335338    operator SkMatrix() const;

  • trunk/Source/WebKit2/ChangeLog

    r110381 r110388  
     12012-03-11  Viatcheslav Ostapenko  <ostapenko.viatcheslav@nokia.com>
     2
     3        [Qt] [WK2] Support threaded renderer in WK2
     4        https://bugs.webkit.org/show_bug.cgi?id=76661
     5
     6        Reviewed by Noam Rosenthal.
     7
     8        Implement Qt5 threaded rendering support for Qt WebKit2.
     9        Parts of LayerTreeHostProxy which contain layer tree and layer painting objects
     10        are moved to separate class called WebLayerTreeRenderer. WebLayerTreeRenderer is
     11        thread safe ref counted and referenced by LayerTreeHostProxy and paint node.
     12        All layer tree and graphics objects are created, accessed and deallocated from Qt
     13        Scenegraph's paint thread only.
     14        Layer tree updates from render queue are fetched in updatePaintNode call stack when
     15        main thread is locked.
     16        Messages from paint thread to web process are passed through MainThreadGuardedInvoker
     17        call gate (implemented by Noam Rosenthal and previously reviewed by Kenneth Rohde
     18        Christiansen).
     19
     20        * Target.pri:
     21        * UIProcess/API/qt/qquickwebpage.cpp:
     22        (PageProxyNode::PageProxyNode):
     23        (PageProxyNode::render):
     24        (PageProxyNode::~PageProxyNode):
     25        (PageProxyNode::layerTreeRenderer):
     26        (PageProxyNode):
     27        (PageProxyNode::setScale):
     28        (QQuickWebPage::updatePaintNode):
     29        (QQuickWebPagePrivate::~QQuickWebPagePrivate):
     30        * UIProcess/LayerTreeHostProxy.cpp: Added.
     31        (WebKit):
     32        (WebKit::LayerTreeHostProxy::LayerTreeHostProxy):
     33        (WebKit::LayerTreeHostProxy::~LayerTreeHostProxy):
     34        (WebKit::LayerTreeHostProxy::paintToCurrentGLContext):
     35        (WebKit::LayerTreeHostProxy::paintToGraphicsContext):
     36        (WebKit::LayerTreeHostProxy::updateViewport):
     37        (WebKit::LayerTreeHostProxy::dispatchUpdate):
     38        (WebKit::LayerTreeHostProxy::createTileForLayer):
     39        (WebKit::LayerTreeHostProxy::updateTileForLayer):
     40        (WebKit::LayerTreeHostProxy::removeTileForLayer):
     41        (WebKit::LayerTreeHostProxy::deleteCompositingLayer):
     42        (WebKit::LayerTreeHostProxy::setRootCompositingLayer):
     43        (WebKit::LayerTreeHostProxy::syncCompositingLayerState):
     44        (WebKit::LayerTreeHostProxy::didRenderFrame):
     45        (WebKit::LayerTreeHostProxy::createDirectlyCompositedImage):
     46        (WebKit::LayerTreeHostProxy::destroyDirectlyCompositedImage):
     47        (WebKit::LayerTreeHostProxy::setVisibleContentsRectForPanning):
     48        (WebKit::LayerTreeHostProxy::setVisibleContentsRectForScaling):
     49        (WebKit::LayerTreeHostProxy::renderNextFrame):
     50        (WebKit::LayerTreeHostProxy::purgeBackingStores):
     51        * UIProcess/LayerTreeHostProxy.h:
     52        (WebKit):
     53        (LayerTreeHostProxy):
     54        (WebKit::LayerTreeHostProxy::layerTreeRenderer):
     55        * UIProcess/WebLayerTreeRenderer.cpp: Renamed from Source/WebKit2/UIProcess/qt/LayerTreeHostProxyQt.cpp.
     56        (WebKit):
     57        (MainThreadGuardedInvoker):
     58        (WebKit::MainThreadGuardedInvoker::call):
     59        (WebKit::MainThreadGuardedInvoker::MainThreadGuardedInvoker):
     60        (WebKit::MainThreadGuardedInvoker::invoke):
     61        (WebKit::WebLayerTreeRenderer::callOnMainTread):
     62        (WebKit::WebLayerTreeRenderer::WebLayerTreeRenderer):
     63        (WebKit::WebLayerTreeRenderer::~WebLayerTreeRenderer):
     64        (WebKit::WebLayerTreeRenderer::createLayer):
     65        (WebKit::WebLayerTreeRenderer::paintToCurrentGLContext):
     66        (WebKit::WebLayerTreeRenderer::syncAnimations):
     67        (WebKit::WebLayerTreeRenderer::paintToGraphicsContext):
     68        (WebKit::WebLayerTreeRenderer::setVisibleContentsRectForScaling):
     69        (WebKit::WebLayerTreeRenderer::updateViewport):
     70        (WebKit::WebLayerTreeRenderer::syncLayerParameters):
     71        (WebKit::WebLayerTreeRenderer::deleteLayer):
     72        (WebKit::WebLayerTreeRenderer::ensureLayer):
     73        (WebKit::WebLayerTreeRenderer::setRootLayerID):
     74        (WebKit::WebLayerTreeRenderer::getBackingStore):
     75        (WebKit::WebLayerTreeRenderer::createTile):
     76        (WebKit::WebLayerTreeRenderer::removeTile):
     77        (WebKit::WebLayerTreeRenderer::updateTile):
     78        (WebKit::WebLayerTreeRenderer::createImage):
     79        (WebKit::WebLayerTreeRenderer::destroyImage):
     80        (WebKit::WebLayerTreeRenderer::assignImageToLayer):
     81        (WebKit::WebLayerTreeRenderer::swapBuffers):
     82        (WebKit::WebLayerTreeRenderer::flushLayerChanges):
     83        (WebKit::WebLayerTreeRenderer::renderNextFrame):
     84        (WebKit::WebLayerTreeRenderer::ensureRootLayer):
     85        (WebKit::WebLayerTreeRenderer::syncRemoteContent):
     86        (WebKit::WebLayerTreeRenderer::purgeGLResources):
     87        (WebKit::WebLayerTreeRenderer::purgeBackingStores):
     88        (WebKit::WebLayerTreeRenderer::detach):
     89        (WebKit::WebLayerTreeRenderer::appendUpdate):
     90        * UIProcess/WebLayerTreeRenderer.h: Copied from Source/WebKit2/UIProcess/LayerTreeHostProxy.h.
     91        (WebKit):
     92        (WebLayerTreeRenderer):
     93        (WebKit::WebLayerTreeRenderer::layerByID):
     94        (WebKit::WebLayerTreeRenderer::rootLayer):
     95        (WebKit::WebLayerTreeRenderer::notifyAnimationStarted):
     96        (WebKit::WebLayerTreeRenderer::notifySyncRequired):
     97        (WebKit::WebLayerTreeRenderer::showDebugBorders):
     98        (WebKit::WebLayerTreeRenderer::showRepaintCounter):
     99        (WebKit::WebLayerTreeRenderer::paintContents):
     100
    11012012-03-09  Jon Lee  <jonlee@apple.com>
    2102

  • trunk/Source/WebKit2/Target.pri

    r110214 r110388  
    245245    UIProcess/WebInspectorProxy.h \
    246246    UIProcess/WebKeyValueStorageManagerProxy.h \
     247    UIProcess/WebLayerTreeRenderer.h \
    247248    UIProcess/WebLoaderClient.h \
    248249    UIProcess/WebMediaCacheManagerProxy.h \
    … …  
    536537    UIProcess/Launcher/qt/ProcessLauncherQt.cpp \
    537538    UIProcess/Launcher/qt/ThreadLauncherQt.cpp \
     539    UIProcess/LayerTreeHostProxy.cpp \
    538540    UIProcess/Notifications/NotificationPermissionRequest.cpp \
    539541    UIProcess/Notifications/NotificationPermissionRequestManagerProxy.cpp \
    … …  
    576578    UIProcess/WebInspectorProxy.cpp \
    577579    UIProcess/WebKeyValueStorageManagerProxy.cpp \
     580    UIProcess/WebLayerTreeRenderer.cpp \
    578581    UIProcess/WebLoaderClient.cpp \
    579582    UIProcess/WebMediaCacheManagerProxy.cpp \
    … …  
    591594    UIProcess/qt/QtWebContext.cpp \
    592595    UIProcess/qt/LayerBackingStore.cpp \
    593     UIProcess/qt/LayerTreeHostProxyQt.cpp \
    594596    UIProcess/qt/QtWebPageEventHandler.cpp \
    595597    UIProcess/qt/QtGestureRecognizer.cpp \

  • trunk/Source/WebKit2/UIProcess/API/qt/qquickwebpage.cpp

    r110368 r110388  
    2525#include "QtWebPageEventHandler.h"
    2626#include "TransformationMatrix.h"
     27#include "WebLayerTreeRenderer.h"
    2728#include "qquickwebpage_p_p.h"
    2829#include "qquickwebview_p.h"
    … …  
    8081}
    8182
    82 void QQuickWebPagePrivate::paintToCurrentGLContext(const QTransform& transform, float opacity, const QRectF& clipRect)
    83 {
    84     if (!q->isVisible())
    85         return;
    86 
    87     if (!clipRect.isValid())
    88         return;
    89 
    90     DrawingAreaProxy* drawingArea = webPageProxy->drawingArea();
    91     if (!drawingArea)
    92         return;
    93 
    94     drawingArea->paintToCurrentGLContext(QTransform(transform).scale(contentsScale, contentsScale), opacity, clipRect);
    95 }
    96 
    9783struct PageProxyNode : public QSGRenderNode {
    98     PageProxyNode(QQuickWebPagePrivate* page)
    99         : m_pagePrivate(page)
     84    PageProxyNode(PassRefPtr<WebLayerTreeRenderer> renderer)
     85        : m_renderer(renderer)
     86        , m_scale(1)
    10087    {
    10188    }
    … …  
    10895    virtual void render(const RenderState&)
    10996    {
    110         if (!m_pagePrivate)
    111             return;
    112         QTransform transform = matrix() ? matrix()->toTransform() : QTransform();
     97        QMatrix4x4 renderMatrix = matrix() ? *matrix() : QMatrix4x4();
     98
     99        // Have to apply render scale manualy because it is not applied on page item.
     100        // http://trac.webkit.org/changeset/104450
     101        renderMatrix.scale(m_scale);
    113102
    114103        // FIXME: Support non-rectangular clippings.
    115         m_pagePrivate->paintToCurrentGLContext(transform, inheritedOpacity(), clipRect());
     104        layerTreeRenderer()->paintToCurrentGLContext(renderMatrix, inheritedOpacity(), clipRect());
    116105    }
    117106
    118107    ~PageProxyNode()
    119108    {
    120         if (m_pagePrivate)
    121             m_pagePrivate->resetPaintNode();
    122     }
    123 
     109        layerTreeRenderer()->purgeGLResources();
     110    }
     111
     112    WebLayerTreeRenderer* layerTreeRenderer() const { return m_renderer.get(); }
     113    void setScale(float scale) { m_scale = scale; }
     114
     115private:
    124116    QRectF clipRect() const
    125117    {
    … …  
    163155    }
    164156
    165     QQuickWebPagePrivate* m_pagePrivate;
     157    RefPtr<WebLayerTreeRenderer> m_renderer;
     158    float m_scale;
    166159};
    167160
    168161QSGNode* QQuickWebPage::updatePaintNode(QSGNode* oldNode, UpdatePaintNodeData*)
    169162{
    170     if (!(flags() & ItemHasContents)) {
    171         if (oldNode)
    172             delete oldNode;
    173         return 0;
    174     }
    175 
    176     PageProxyNode* proxyNode = static_cast<PageProxyNode*>(oldNode);
    177     if (!proxyNode) {
    178         proxyNode = new PageProxyNode(d);
    179         d->m_paintNode = proxyNode;
    180     }
    181 
    182     return proxyNode;
     163    if (!d->webPageProxy->drawingArea())
     164        return oldNode;
     165
     166    LayerTreeHostProxy* layerTreeHostProxy = d->webPageProxy->drawingArea()->layerTreeHostProxy();
     167    WebLayerTreeRenderer* renderer = layerTreeHostProxy->layerTreeRenderer();
     168
     169    PageProxyNode* node = static_cast<PageProxyNode*>(oldNode);
     170
     171    if (node && node->layerTreeRenderer() != renderer) {
     172        // This means that LayerTreeHostProxy was deleted and recreated while old paint node survived.
     173        // This could happen if web process have crashed. In this case we have to recreate paint node.
     174        delete node;
     175        node = 0;
     176    }
     177
     178    renderer->syncRemoteContent();
     179
     180    if (!node)
     181        node = new PageProxyNode(renderer);
     182
     183    node->setScale(d->contentsScale);
     184
     185    return node;
    183186}
    184187
    … …  
    234237}
    235238
    236 void QQuickWebPagePrivate::resetPaintNode()
    237 {
    238     m_paintNode = 0;
    239     DrawingAreaProxy* drawingArea = webPageProxy->drawingArea();
    240     if (drawingArea && drawingArea->layerTreeHostProxy())
    241         drawingArea->layerTreeHostProxy()->purgeGLResources();
    242 }
    243 
    244239QQuickWebPagePrivate::~QQuickWebPagePrivate()
    245240{
    246     if (m_paintNode)
    247         static_cast<PageProxyNode*>(m_paintNode)->m_pagePrivate = 0;
    248241}
    249242

  • trunk/Source/WebKit2/UIProcess/LayerTreeHostProxy.h

    r109755 r110388  
    2626#include "DrawingAreaProxy.h"
    2727#include "Region.h"
    28 #include "TextureMapper.h"
    29 #include "TextureMapperBackingStore.h"
    3028#include "WebLayerTreeInfo.h"
    3129#include <WebCore/GraphicsContext.h>
    … …  
    3836#include <wtf/HashSet.h>
    3937
     38class QSGNode;
    4039
    4140namespace WebKit {
    4241
    43 class LayerBackingStore;
    4442class WebLayerInfo;
     43class WebLayerTreeRenderer;
    4544class WebLayerUpdateInfo;
    4645
    47 class LayerTreeHostProxy : public WebCore::GraphicsLayerClient {
     46class LayerTreeHostProxy {
    4847public:
    4948    LayerTreeHostProxy(DrawingAreaProxy*);
    … …  
    5352    void setRootCompositingLayer(WebLayerID);
    5453    void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*);
    55     void paintToCurrentGLContext(const WebCore::TransformationMatrix&, float, const WebCore::FloatRect&);
     54    void paintToCurrentGLContext(const WebCore::TransformationMatrix&, float opacity, const WebCore::FloatRect& clip);
    5655    void paintToGraphicsContext(BackingStore::PlatformGraphicsContext);
    5756    void purgeGLResources();
    5857    void setVisibleContentsRectForScaling(const WebCore::IntRect&, float);
    5958    void setVisibleContentsRectForPanning(const WebCore::IntRect&, const WebCore::FloatPoint&);
    60     void syncRemoteContent();
    61     void swapContentBuffers();
    6259    void didRenderFrame();
    6360    void createTileForLayer(int layerID, int tileID, const WebKit::UpdateInfo&);
    … …  
    6865    void didReceiveLayerTreeHostProxyMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*);
    6966    void updateViewport();
     67    void renderNextFrame();
     68    void purgeBackingStores();
     69    WebLayerTreeRenderer* layerTreeRenderer() const { return m_renderer.get(); }
    7070
    7171protected:
    72     PassOwnPtr<WebCore::GraphicsLayer> createLayer(WebLayerID);
    73 
    74     WebCore::GraphicsLayer* layerByID(WebLayerID id) { return (id == InvalidWebLayerID) ? 0 : m_layers.get(id); }
    75     WebCore::GraphicsLayer* rootLayer() { return m_rootLayer.get(); }
    76 
    77     // Reimplementations from WebCore::GraphicsLayerClient.
    78     virtual void notifyAnimationStarted(const WebCore::GraphicsLayer*, double) { }
    79     virtual void notifySyncRequired(const WebCore::GraphicsLayer*) { }
    80     virtual bool showDebugBorders(const WebCore::GraphicsLayer*) const { return false; }
    81     virtual bool showRepaintCounter(const WebCore::GraphicsLayer*) const { return false; }
    82     void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::IntRect&) { }
     72    void dispatchUpdate(const Function<void()>&);
    8373
    8474    DrawingAreaProxy* m_drawingAreaProxy;
    85 
    86     typedef HashMap<WebLayerID, WebCore::GraphicsLayer*> LayerMap;
    87     WebCore::IntRect m_visibleContentsRect;
    88     float m_contentsScale;
    89 
    90     Vector<Function<void()> > m_renderQueue;
    91     void dispatchUpdate(const Function<void()>&);
    92 
    93 #if USE(TEXTURE_MAPPER)
    94     OwnPtr<WebCore::TextureMapper> m_textureMapper;
    95     PassRefPtr<LayerBackingStore> getBackingStore(WebLayerID);
    96     HashMap<int64_t, RefPtr<WebCore::TextureMapperBackingStore> > m_directlyCompositedImages;
    97     HashSet<RefPtr<LayerBackingStore> > m_backingStoresWithPendingBuffers;
    98 #endif
    99 
    100     void scheduleWebViewUpdate();
    101     void synchronizeViewport();
    102     void deleteLayer(WebLayerID);
    103     void setRootLayerID(WebLayerID);
    104     void syncLayerParameters(const WebLayerInfo&);
    105     void createTile(WebLayerID, int, float scale);
    106     void removeTile(WebLayerID, int);
    107     void updateTile(WebLayerID, int, const WebCore::IntRect&, const WebCore::IntRect&, PassRefPtr<ShareableBitmap>);
    108     void createImage(int64_t, PassRefPtr<ShareableBitmap>);
    109     void destroyImage(int64_t);
    110     void assignImageToLayer(WebCore::GraphicsLayer*, int64_t imageID);
    111     void flushLayerChanges();
    112     void ensureRootLayer();
    113     void ensureLayer(WebLayerID);
    114     void swapBuffers();
    115     void syncAnimations();
    116 
    117     OwnPtr<WebCore::GraphicsLayer> m_rootLayer;
    118     Vector<WebLayerID> m_layersToDelete;
    119 
    120     LayerMap m_layers;
    121     WebLayerID m_rootLayerID;
    122     int m_id;
     75    RefPtr<WebLayerTreeRenderer> m_renderer;
    12376};
    12477

  • trunk/Source/WebKit2/UIProcess/WebLayerTreeRenderer.cpp

    r110387 r110388  
    11/*
    2     Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies)
     2    Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies)
    33
    44    This library is free software; you can redistribute it and/or
    … …  
    2020#include "config.h"
    2121
    22 #include "LayerTreeHostProxy.h"
     22#if USE(UI_SIDE_COMPOSITING)
     23
     24#include "WebLayerTreeRenderer.h"
    2325
    2426#include "GraphicsLayerTextureMapper.h"
    2527#include "LayerBackingStore.h"
    26 #include "LayerTreeHostMessages.h"
     28#include "LayerTreeHostProxy.h"
    2729#include "MainThread.h"
    2830#include "MessageID.h"
    … …  
    3234#include "TextureMapperLayer.h"
    3335#include "UpdateInfo.h"
    34 #include "WebCoreArgumentCoders.h"
    35 #include "WebLayerTreeInfo.h"
    36 #include "WebPageProxy.h"
    37 #include "WebProcessProxy.h"
    3836#include <OpenGLShims.h>
    39 #include <QDateTime>
     37#include <wtf/Atomics.h>
    4038
    4139namespace WebKit {
    … …  
    4341using namespace WebCore;
    4442
    45 PassOwnPtr<GraphicsLayer> LayerTreeHostProxy::createLayer(WebLayerID layerID)
     43template<class T> class MainThreadGuardedInvoker {
     44public:
     45    static void call(PassRefPtr<T> objectToGuard, const Function<void()>& function)
     46    {
     47        MainThreadGuardedInvoker<T>* invoker = new MainThreadGuardedInvoker<T>(objectToGuard, function);
     48        callOnMainThread(invoke, invoker);
     49    }
     50
     51private:
     52    MainThreadGuardedInvoker(PassRefPtr<T> object, const Function<void()>& newFunction)
     53        : objectToGuard(object)
     54        , function(newFunction)
     55    {
     56    }
     57
     58    RefPtr<T> objectToGuard;
     59    Function<void()> function;
     60    static void invoke(void* data)
     61    {
     62        MainThreadGuardedInvoker<T>* invoker = static_cast<MainThreadGuardedInvoker<T>*>(data);
     63        invoker->function();
     64        delete invoker;
     65    }
     66};
     67
     68void WebLayerTreeRenderer::callOnMainTread(const Function<void()>& function)
     69{
     70    if (isMainThread())
     71        function();
     72    else
     73        MainThreadGuardedInvoker<WebLayerTreeRenderer>::call(this, function);
     74}
     75
     76WebLayerTreeRenderer::WebLayerTreeRenderer(LayerTreeHostProxy* layerTreeHostProxy)
     77    : m_layerTreeHostProxy(layerTreeHostProxy)
     78    , m_rootLayerID(0)
     79{
     80}
     81
     82WebLayerTreeRenderer::~WebLayerTreeRenderer()
     83{
     84}
     85
     86PassOwnPtr<GraphicsLayer> WebLayerTreeRenderer::createLayer(WebLayerID layerID)
    4687{
    4788    GraphicsLayer* newLayer = new GraphicsLayerTextureMapper(this);
    … …  
    5192}
    5293
    53 LayerTreeHostProxy::LayerTreeHostProxy(DrawingAreaProxy* drawingAreaProxy)
    54     : m_drawingAreaProxy(drawingAreaProxy)
    55     , m_rootLayerID(0)
    56 {
    57 }
    58 
    59 LayerTreeHostProxy::~LayerTreeHostProxy()
    60 {
    61 }
    62 
    63 // This function needs to be reentrant.
    64 void LayerTreeHostProxy::paintToCurrentGLContext(const TransformationMatrix& matrix, float opacity, const FloatRect& clipRect)
     94void WebLayerTreeRenderer::paintToCurrentGLContext(const TransformationMatrix& matrix, float opacity, const FloatRect& clipRect)
    6595{
    6696    if (!m_textureMapper)
    … …  
    96126}
    97127
    98 void LayerTreeHostProxy::syncAnimations()
     128void WebLayerTreeRenderer::syncAnimations()
    99129{
    100130    TextureMapperLayer* layer = toTextureMapperLayer(rootLayer());
    … …  
    103133    layer->syncAnimationsRecursively();
    104134    if (layer->descendantsOrSelfHaveRunningAnimations())
    105         updateViewport();
    106 }
    107 
    108 void LayerTreeHostProxy::paintToGraphicsContext(QPainter* painter)
     135        callOnMainThread(bind(&WebLayerTreeRenderer::updateViewport, this));
     136}
     137
     138void WebLayerTreeRenderer::paintToGraphicsContext(QPainter* painter)
    109139{
    110140    if (!m_textureMapper)
    … …  
    126156}
    127157
    128 void LayerTreeHostProxy::updateViewport()
    129 {
    130     m_drawingAreaProxy->updateViewport();
    131 }
    132 
    133 void LayerTreeHostProxy::syncLayerParameters(const WebLayerInfo& layerInfo)
     158void WebLayerTreeRenderer::setVisibleContentsRectForScaling(const IntRect& rect, float scale)
     159{
     160    m_visibleContentsRect = rect;
     161    m_contentsScale = scale;
     162}
     163
     164void WebLayerTreeRenderer::updateViewport()
     165{
     166    if (m_layerTreeHostProxy)
     167        m_layerTreeHostProxy->updateViewport();
     168}
     169
     170void WebLayerTreeRenderer::syncLayerParameters(const WebLayerInfo& layerInfo)
    134171{
    135172    WebLayerID id = layerInfo.id;
    … …  
    197234}
    198235
    199 void LayerTreeHostProxy::deleteLayer(WebLayerID layerID)
     236void WebLayerTreeRenderer::deleteLayer(WebLayerID layerID)
    200237{
    201238    GraphicsLayer* layer = layerByID(layerID);
    … …  
    209246
    210247
    211 void LayerTreeHostProxy::ensureLayer(WebLayerID id)
     248void WebLayerTreeRenderer::ensureLayer(WebLayerID id)
    212249{
    213250    // We have to leak the new layer's pointer and manage it ourselves,
    … …  
    217254}
    218255
    219 void LayerTreeHostProxy::setRootLayerID(WebLayerID layerID)
     256void WebLayerTreeRenderer::setRootLayerID(WebLayerID layerID)
    220257{
    221258    if (layerID == m_rootLayerID)
    … …  
    236273}
    237274
    238 PassRefPtr<LayerBackingStore> LayerTreeHostProxy::getBackingStore(WebLayerID id)
     275PassRefPtr<LayerBackingStore> WebLayerTreeRenderer::getBackingStore(WebLayerID id)
    239276{
    240277    ensureLayer(id);
    … …  
    249286}
    250287
    251 void LayerTreeHostProxy::createTile(WebLayerID layerID, int tileID, float scale)
     288void WebLayerTreeRenderer::createTile(WebLayerID layerID, int tileID, float scale)
    252289{
    253290    getBackingStore(layerID)->createTile(tileID, scale);
    254291}
    255292
    256 void LayerTreeHostProxy::removeTile(WebLayerID layerID, int tileID)
     293void WebLayerTreeRenderer::removeTile(WebLayerID layerID, int tileID)
    257294{
    258295    getBackingStore(layerID)->removeTile(tileID);
    259296}
    260297
    261 void LayerTreeHostProxy::updateTile(WebLayerID layerID, int tileID, const IntRect& sourceRect, const IntRect& targetRect, PassRefPtr<ShareableBitmap> weakBitmap)
     298void WebLayerTreeRenderer::updateTile(WebLayerID layerID, int tileID, const IntRect& sourceRect, const IntRect& targetRect, PassRefPtr<ShareableBitmap> weakBitmap)
    262299{
    263300    RefPtr<ShareableBitmap> bitmap = weakBitmap;
    … …  
    267304}
    268305
    269 void LayerTreeHostProxy::createImage(int64_t imageID, PassRefPtr<ShareableBitmap> weakBitmap)
     306void WebLayerTreeRenderer::createImage(int64_t imageID, PassRefPtr<ShareableBitmap> weakBitmap)
    270307{
    271308    RefPtr<ShareableBitmap> bitmap = weakBitmap;
    … …  
    275312}
    276313
    277 void LayerTreeHostProxy::destroyImage(int64_t imageID)
     314void WebLayerTreeRenderer::destroyImage(int64_t imageID)
    278315{
    279316    m_directlyCompositedImages.remove(imageID);
    280317}
    281318
    282 void LayerTreeHostProxy::assignImageToLayer(GraphicsLayer* layer, int64_t imageID)
     319void WebLayerTreeRenderer::assignImageToLayer(GraphicsLayer* layer, int64_t imageID)
    283320{
    284321    HashMap<int64_t, RefPtr<TextureMapperBackingStore> >::iterator it = m_directlyCompositedImages.find(imageID);
    … …  
    287324}
    288325
    289 void LayerTreeHostProxy::swapBuffers()
     326void WebLayerTreeRenderer::swapBuffers()
    290327{
    291328    HashSet<RefPtr<LayerBackingStore> >::iterator end = m_backingStoresWithPendingBuffers.end();
    … …  
    296333}
    297334
    298 void LayerTreeHostProxy::flushLayerChanges()
     335void WebLayerTreeRenderer::flushLayerChanges()
    299336{
    300337    m_rootLayer->syncCompositingState(FloatRect());
    … …  
    302339
    303340    // The pending tiles state is on its way for the screen, tell the web process to render the next one.
    304     m_drawingAreaProxy->page()->process()->send(Messages::LayerTreeHost::RenderNextFrame(), m_drawingAreaProxy->page()->pageID());
    305 }
    306 
    307 void LayerTreeHostProxy::ensureRootLayer()
     341    callOnMainThread(bind(&WebLayerTreeRenderer::renderNextFrame, this));
     342}
     343
     344void WebLayerTreeRenderer::renderNextFrame()
     345{
     346    if (m_layerTreeHostProxy)
     347        m_layerTreeHostProxy->renderNextFrame();
     348}
     349
     350void WebLayerTreeRenderer::ensureRootLayer()
    308351{
    309352    if (m_rootLayer)
    310353        return;
     354    if (!m_textureMapper)
     355        m_textureMapper = TextureMapper::create(TextureMapper::OpenGLMode);
     356
    311357    m_rootLayer = createLayer(InvalidWebLayerID);
    312358    m_rootLayer->setMasksToBounds(false);
    … …  
    316362    // The root layer should not have zero size, or it would be optimized out.
    317363    m_rootLayer->setSize(FloatSize(1.0, 1.0));
    318     if (!m_textureMapper)
    319         m_textureMapper = TextureMapper::create(TextureMapper::OpenGLMode);
    320364    toTextureMapperLayer(m_rootLayer.get())->setTextureMapper(m_textureMapper.get());
    321365}
    322366
    323 void LayerTreeHostProxy::syncRemoteContent()
     367void WebLayerTreeRenderer::syncRemoteContent()
    324368{
    325369    // We enqueue messages and execute them during paint, as they require an active GL context.
    … …  
    332376}
    333377
    334 void LayerTreeHostProxy::dispatchUpdate(const Function<void()>& function)
    335 {
    336     m_renderQueue.append(function);
    337     updateViewport();
    338 }
    339 
    340 void LayerTreeHostProxy::createTileForLayer(int layerID, int tileID, const WebKit::UpdateInfo& updateInfo)
    341 {
    342     dispatchUpdate(bind(&LayerTreeHostProxy::createTile, this, layerID, tileID, updateInfo.updateScaleFactor));
    343     updateTileForLayer(layerID, tileID, updateInfo);
    344 }
    345 
    346 void LayerTreeHostProxy::updateTileForLayer(int layerID, int tileID, const WebKit::UpdateInfo& updateInfo)
    347 {
    348     ASSERT(updateInfo.updateRects.size() == 1);
    349     IntRect sourceRect = updateInfo.updateRects.first();
    350     IntRect targetRect = updateInfo.updateRectBounds;
    351     RefPtr<ShareableBitmap> bitmap = ShareableBitmap::create(updateInfo.bitmapHandle);
    352     dispatchUpdate(bind(&LayerTreeHostProxy::updateTile, this, layerID, tileID, sourceRect, targetRect, bitmap));
    353 }
    354 
    355 void LayerTreeHostProxy::removeTileForLayer(int layerID, int tileID)
    356 {
    357     dispatchUpdate(bind(&LayerTreeHostProxy::removeTile, this, layerID, tileID));
    358 }
    359 
    360 
    361 void LayerTreeHostProxy::deleteCompositingLayer(WebLayerID id)
    362 {
    363     dispatchUpdate(bind(&LayerTreeHostProxy::deleteLayer, this, id));
    364 }
    365 
    366 void LayerTreeHostProxy::setRootCompositingLayer(WebLayerID id)
    367 {
    368     dispatchUpdate(bind(&LayerTreeHostProxy::setRootLayerID, this, id));
    369 }
    370 
    371 void LayerTreeHostProxy::syncCompositingLayerState(const WebLayerInfo& info)
    372 {
    373     dispatchUpdate(bind(&LayerTreeHostProxy::syncLayerParameters, this, info));
    374 }
    375 
    376 void LayerTreeHostProxy::didRenderFrame()
    377 {
    378     dispatchUpdate(bind(&LayerTreeHostProxy::flushLayerChanges, this));
    379 }
    380 
    381 void LayerTreeHostProxy::createDirectlyCompositedImage(int64_t key, const WebKit::ShareableBitmap::Handle& handle)
    382 {
    383     RefPtr<ShareableBitmap> bitmap = ShareableBitmap::create(handle);
    384     dispatchUpdate(bind(&LayerTreeHostProxy::createImage, this, key, bitmap));
    385 }
    386 
    387 void LayerTreeHostProxy::destroyDirectlyCompositedImage(int64_t key)
    388 {
    389     dispatchUpdate(bind(&LayerTreeHostProxy::destroyImage, this, key));
    390 }
    391 
    392 void LayerTreeHostProxy::setVisibleContentsRectForPanning(const IntRect& rect, const FloatPoint& trajectoryVector)
    393 {
    394     m_drawingAreaProxy->page()->process()->send(Messages::LayerTreeHost::SetVisibleContentsRectForPanning(rect, trajectoryVector), m_drawingAreaProxy->page()->pageID());
    395 }
    396 
    397 void LayerTreeHostProxy::setVisibleContentsRectForScaling(const IntRect& rect, float scale)
    398 {
    399     m_visibleContentsRect = rect;
    400     m_contentsScale = scale;
    401     m_drawingAreaProxy->page()->process()->send(Messages::LayerTreeHost::SetVisibleContentsRectForScaling(rect, scale), m_drawingAreaProxy->page()->pageID());
    402 }
    403 
    404 void LayerTreeHostProxy::purgeGLResources()
     378void WebLayerTreeRenderer::purgeGLResources()
    405379{
    406380    TextureMapperLayer* layer = toTextureMapperLayer(rootLayer());
    … …  
    412386    m_textureMapper.clear();
    413387    m_backingStoresWithPendingBuffers.clear();
    414     m_drawingAreaProxy->page()->process()->send(Messages::LayerTreeHost::PurgeBackingStores(), m_drawingAreaProxy->page()->pageID());
    415 }
    416 
    417 }
     388
     389    callOnMainThread(bind(&WebLayerTreeRenderer::purgeBackingStores, this));
     390}
     391
     392void WebLayerTreeRenderer::purgeBackingStores()
     393{
     394    if (m_layerTreeHostProxy)
     395        m_layerTreeHostProxy->purgeBackingStores();
     396}
     397
     398void WebLayerTreeRenderer::detach()
     399{
     400    m_layerTreeHostProxy = 0;
     401}
     402
     403void WebLayerTreeRenderer::appendUpdate(const Function<void()>& function)
     404{
     405    m_renderQueue.append(function);
     406}
     407
     408} // namespace WebKit
     409
     410#endif // USE(UI_SIDE_COMPOSITING)

  • trunk/Source/WebKit2/UIProcess/WebLayerTreeRenderer.h

    r110387 r110388  
    11/*
    2     Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies)
     2    Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies)
    33
    44    This library is free software; you can redistribute it and/or
    … …  
    1818*/
    1919
    20 #ifndef LayerTreeHostProxy_h
    21 #define LayerTreeHostProxy_h
     20#ifndef WebLayerTreeRenderer_h
     21#define WebLayerTreeRenderer_h
    2222
    2323#if USE(UI_SIDE_COMPOSITING)
    2424
    2525#include "BackingStore.h"
    26 #include "DrawingAreaProxy.h"
    27 #include "Region.h"
    2826#include "TextureMapper.h"
    2927#include "TextureMapperBackingStore.h"
    … …  
    3735#include <wtf/Functional.h>
    3836#include <wtf/HashSet.h>
    39 
     37#include <wtf/ThreadingPrimitives.h>
    4038
    4139namespace WebKit {
    4240
    4341class LayerBackingStore;
     42class LayerTreeHostProxy;
    4443class WebLayerInfo;
    4544class WebLayerUpdateInfo;
    4645
    47 class LayerTreeHostProxy : public WebCore::GraphicsLayerClient {
     46class WebLayerTreeRenderer : public ThreadSafeRefCounted<WebLayerTreeRenderer>, public WebCore::GraphicsLayerClient {
    4847public:
    49     LayerTreeHostProxy(DrawingAreaProxy*);
    50     virtual ~LayerTreeHostProxy();
    51     void syncCompositingLayerState(const WebLayerInfo&);
    52     void deleteCompositingLayer(WebLayerID);
    53     void setRootCompositingLayer(WebLayerID);
    54     void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*);
     48    WebLayerTreeRenderer(LayerTreeHostProxy*);
     49    virtual ~WebLayerTreeRenderer();
     50    void purgeGLResources();
    5551    void paintToCurrentGLContext(const WebCore::TransformationMatrix&, float, const WebCore::FloatRect&);
    5652    void paintToGraphicsContext(BackingStore::PlatformGraphicsContext);
    57     void purgeGLResources();
     53    void syncRemoteContent();
    5854    void setVisibleContentsRectForScaling(const WebCore::IntRect&, float);
    59     void setVisibleContentsRectForPanning(const WebCore::IntRect&, const WebCore::FloatPoint&);
    60     void syncRemoteContent();
    61     void swapContentBuffers();
    62     void didRenderFrame();
    63     void createTileForLayer(int layerID, int tileID, const WebKit::UpdateInfo&);
    64     void updateTileForLayer(int layerID, int tileID, const WebKit::UpdateInfo&);
    65     void removeTileForLayer(int layerID, int tileID);
    66     void createDirectlyCompositedImage(int64_t, const WebKit::ShareableBitmap::Handle&);
    67     void destroyDirectlyCompositedImage(int64_t);
    68     void didReceiveLayerTreeHostProxyMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*);
     55
     56    void detach();
     57    void appendUpdate(const Function<void()>&);
    6958    void updateViewport();
    7059
    71 protected:
     60    void deleteLayer(WebLayerID);
     61    void setRootLayerID(WebLayerID);
     62    void syncLayerParameters(const WebLayerInfo&);
     63    void createTile(WebLayerID, int, float scale);
     64    void removeTile(WebLayerID, int);
     65    void updateTile(WebLayerID, int, const WebCore::IntRect&, const WebCore::IntRect&, PassRefPtr<ShareableBitmap>);
     66    void flushLayerChanges();
     67    void createImage(int64_t, PassRefPtr<ShareableBitmap>);
     68    void destroyImage(int64_t);
     69
     70private:
    7271    PassOwnPtr<WebCore::GraphicsLayer> createLayer(WebLayerID);
    7372
    … …  
    8180    virtual bool showRepaintCounter(const WebCore::GraphicsLayer*) const { return false; }
    8281    void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::IntRect&) { }
    83 
    84     DrawingAreaProxy* m_drawingAreaProxy;
     82    void callOnMainTread(const Function<void()>&);
    8583
    8684    typedef HashMap<WebLayerID, WebCore::GraphicsLayer*> LayerMap;
    … …  
    8886    float m_contentsScale;
    8987
     88    // Render queue can be accessed ony from main thread or updatePaintNode call stack!
    9089    Vector<Function<void()> > m_renderQueue;
    91     void dispatchUpdate(const Function<void()>&);
    9290
    9391#if USE(TEXTURE_MAPPER)
    … …  
    10098    void scheduleWebViewUpdate();
    10199    void synchronizeViewport();
    102     void deleteLayer(WebLayerID);
    103     void setRootLayerID(WebLayerID);
    104     void syncLayerParameters(const WebLayerInfo&);
    105     void createTile(WebLayerID, int, float scale);
    106     void removeTile(WebLayerID, int);
    107     void updateTile(WebLayerID, int, const WebCore::IntRect&, const WebCore::IntRect&, PassRefPtr<ShareableBitmap>);
    108     void createImage(int64_t, PassRefPtr<ShareableBitmap>);
    109     void destroyImage(int64_t);
    110100    void assignImageToLayer(WebCore::GraphicsLayer*, int64_t imageID);
    111     void flushLayerChanges();
    112101    void ensureRootLayer();
    113102    void ensureLayer(WebLayerID);
    114103    void swapBuffers();
    115104    void syncAnimations();
     105    void renderNextFrame();
     106    void purgeBackingStores();
    116107
     108    LayerTreeHostProxy* m_layerTreeHostProxy;
    117109    OwnPtr<WebCore::GraphicsLayer> m_rootLayer;
    118110    Vector<WebLayerID> m_layersToDelete;
    … …  
    120112    LayerMap m_layers;
    121113    WebLayerID m_rootLayerID;
    122     int m_id;
    123114};
    124115
    125 }
     116};
    126117
    127 #endif
     118#endif // USE(UI_SIDE_COMPOSITING)
    128119
    129 #endif // LayerTreeHostProxy_h
     120#endif // WebLayerTreeRenderer_h
     121
     122

  • trunk/Tools/ChangeLog

    r110382 r110388  
     12012-03-11  Viatcheslav Ostapenko  <ostapenko.viatcheslav@nokia.com>
     2
     3        [Qt] [WK2] Support threaded renderer in WK2
     4        https://bugs.webkit.org/show_bug.cgi?id=76661
     5
     6        Remove disabling of threaded rendering.
     7
     8        Reviewed by Noam Rosenthal.
     9
     10        * MiniBrowser/qt/main.cpp:
     11        (main):
     12
    1132012-03-09  Zan Dobersek  <zandobersek@gmail.com>
    214

  • trunk/Tools/MiniBrowser/qt/main.cpp

    r109755 r110388  
    4040int main(int argc, char** argv)
    4141{
    42     // FIXME: We must add support for the threaded rendering as it is the default.
    43     qputenv("QML_NO_THREADED_RENDERER", QByteArray("1"));
    44 
    4542    MiniBrowserApplication app(argc, argv);
    4643
Note: See TracChangeset for help on using the changeset viewer.