Changeset 118699 in webkit


Ignore:
Timestamp:
May 28, 2012 11:29:29 AM (12 years ago)
Author:
commit-queue@webkit.org
Message:

[BlackBerry] Add an overlay layer
https://bugs.webkit.org/show_bug.cgi?id=87567

Patch by Arvid Nilsson <anilsson@rim.com> on 2012-05-28
Reviewed by Antonio Gomes.

The overlay layer allows us to have compositing layers even though the
web page is not currently using accelerated compositing.

These layers can be used to implement tap highlight, inspector overlay
and more.

Source/WebCore:

The WebCore changes support the overlay layer functionality in WebKit
by making it possible to add animations from the compositing thread
without them being instantly overwritten during the next commit.

Also a new custom layer type is added, which allow an overlay layer to
draw itself using raw OpenGL calls. An instance of a custom subclass of
LayerCompositingThread must be provided when creating the
LayerWebKitThread. Then, the custom layer can be used as the content
layer of a GraphicsLayer, or by itself.

Reviewed internally by Filip Spacek.

PR #154335

  • platform/graphics/blackberry/LayerCompositingThread.cpp:

(WebCore::LayerCompositingThread::~LayerCompositingThread):
(WebCore::LayerCompositingThread::deleteTextures):
(WebCore::LayerCompositingThread::drawTextures):
(WebCore::LayerCompositingThread::drawMissingTextures):
(WebCore::LayerCompositingThread::updateTextureContentsIfNeeded):
(WebCore::LayerCompositingThread::setVisible):
(WebCore::LayerCompositingThread::scheduleCommit):

  • platform/graphics/blackberry/LayerCompositingThread.h:

(WebCore::LayerCompositingThread::addAnimation):
(WebCore::LayerCompositingThread::setRunningAnimations):
(WebCore::LayerCompositingThread::setSuspendedAnimations):
(LayerCompositingThread):
(WebCore::LayerCompositingThread::drawCustom):

  • platform/graphics/blackberry/LayerData.h:

(LayerData):

  • platform/graphics/blackberry/LayerWebKitThread.cpp:

(WebCore::LayerWebKitThread::LayerWebKitThread):
(WebCore):
(WebCore::LayerWebKitThread::~LayerWebKitThread):
(WebCore::LayerWebKitThread::updateTextureContentsIfNeeded):
(WebCore::LayerWebKitThread::startAnimations):
(WebCore::LayerWebKitThread::commitOnCompositingThread):
(WebCore::LayerWebKitThread::setNeedsDisplayInRect):
(WebCore::LayerWebKitThread::setNeedsDisplay):
(WebCore::LayerWebKitThread::setIsMask):
(WebCore::LayerWebKitThread::setRunningAnimations):
(WebCore::LayerWebKitThread::setSuspendedAnimations):

  • platform/graphics/blackberry/LayerWebKitThread.h:

(LayerWebKitThread):

Source/WebKit/blackberry:

Reviewed internally by Filip Spacek.

PR #154335

  • Api/WebPage.cpp:

(BlackBerry::WebKit::WebPagePrivate::scheduleRootLayerCommit):
(BlackBerry::WebKit::WebPagePrivate::overlayLayer):
(WebKit):
(BlackBerry::WebKit::WebPagePrivate::commitRootLayer):
(BlackBerry::WebKit::WebPagePrivate::commitRootLayerIfNeeded):

  • Api/WebPageCompositor.cpp:

(BlackBerry::WebKit::WebPageCompositorPrivate::setOverlayLayer):
(WebKit):
(BlackBerry::WebKit::WebPageCompositorPrivate::prepareFrame):
(BlackBerry::WebKit::WebPageCompositorPrivate::render):
(BlackBerry::WebKit::WebPageCompositorPrivate::drawLayers):

  • Api/WebPageCompositor_p.h:

(BlackBerry::WebKit::WebPageCompositorPrivate::overlayLayer):
(WebPageCompositorPrivate):

  • Api/WebPage_p.h:

(WebPagePrivate):

Location:
trunk/Source
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r118698 r118699  
     12012-05-28  Arvid Nilsson  <anilsson@rim.com>
     2
     3        [BlackBerry] Add an overlay layer
     4        https://bugs.webkit.org/show_bug.cgi?id=87567
     5
     6        Reviewed by Antonio Gomes.
     7
     8        The overlay layer allows us to have compositing layers even though the
     9        web page is not currently using accelerated compositing.
     10
     11        These layers can be used to implement tap highlight, inspector overlay
     12        and more.
     13
     14        The WebCore changes support the overlay layer functionality in WebKit
     15        by making it possible to add animations from the compositing thread
     16        without them being instantly overwritten during the next commit.
     17
     18        Also a new custom layer type is added, which allow an overlay layer to
     19        draw itself using raw OpenGL calls. An instance of a custom subclass of
     20        LayerCompositingThread must be provided when creating the
     21        LayerWebKitThread. Then, the custom layer can be used as the content
     22        layer of a GraphicsLayer, or by itself.
     23
     24        Reviewed internally by Filip Spacek.
     25
     26        PR #154335
     27
     28        * platform/graphics/blackberry/LayerCompositingThread.cpp:
     29        (WebCore::LayerCompositingThread::~LayerCompositingThread):
     30        (WebCore::LayerCompositingThread::deleteTextures):
     31        (WebCore::LayerCompositingThread::drawTextures):
     32        (WebCore::LayerCompositingThread::drawMissingTextures):
     33        (WebCore::LayerCompositingThread::updateTextureContentsIfNeeded):
     34        (WebCore::LayerCompositingThread::setVisible):
     35        (WebCore::LayerCompositingThread::scheduleCommit):
     36        * platform/graphics/blackberry/LayerCompositingThread.h:
     37        (WebCore::LayerCompositingThread::addAnimation):
     38        (WebCore::LayerCompositingThread::setRunningAnimations):
     39        (WebCore::LayerCompositingThread::setSuspendedAnimations):
     40        (LayerCompositingThread):
     41        (WebCore::LayerCompositingThread::drawCustom):
     42        * platform/graphics/blackberry/LayerData.h:
     43        (LayerData):
     44        * platform/graphics/blackberry/LayerWebKitThread.cpp:
     45        (WebCore::LayerWebKitThread::LayerWebKitThread):
     46        (WebCore):
     47        (WebCore::LayerWebKitThread::~LayerWebKitThread):
     48        (WebCore::LayerWebKitThread::updateTextureContentsIfNeeded):
     49        (WebCore::LayerWebKitThread::startAnimations):
     50        (WebCore::LayerWebKitThread::commitOnCompositingThread):
     51        (WebCore::LayerWebKitThread::setNeedsDisplayInRect):
     52        (WebCore::LayerWebKitThread::setNeedsDisplay):
     53        (WebCore::LayerWebKitThread::setIsMask):
     54        (WebCore::LayerWebKitThread::setRunningAnimations):
     55        (WebCore::LayerWebKitThread::setSuspendedAnimations):
     56        * platform/graphics/blackberry/LayerWebKitThread.h:
     57        (LayerWebKitThread):
     58
    1592012-05-28  Leo Yang  <leo.yang@torchmobile.com.cn>
    260
  • trunk/Source/WebCore/platform/graphics/blackberry/LayerCompositingThread.cpp

    r118696 r118699  
    7676    ASSERT(isCompositingThread());
    7777
    78     m_tiler->layerCompositingThreadDestroyed();
     78    if (m_tiler)
     79        m_tiler->layerCompositingThreadDestroyed();
    7980
    8081    ASSERT(!superlayer());
     
    107108    releaseTextureResources();
    108109
    109     m_tiler->deleteTextures();
     110    if (m_tiler)
     111        m_tiler->deleteTextures();
    110112}
    111113
     
    257259    }
    258260
    259     m_tiler->drawTextures(this, positionLocation, texCoordLocation);
     261    if (m_layerType == CustomLayer) {
     262        // Custom layers don't have a LayerTiler, so they either have to set
     263        // m_texID or implement drawCustom.
     264        drawCustom(positionLocation, texCoordLocation);
     265        return;
     266    }
     267
     268    if (m_tiler)
     269        m_tiler->drawTextures(this, positionLocation, texCoordLocation);
    260270}
    261271
     
    296306#endif
    297307
    298     m_tiler->drawMissingTextures(this, positionLocation, texCoordLocation);
     308    if (m_tiler)
     309        m_tiler->drawMissingTextures(this, positionLocation, texCoordLocation);
    299310}
    300311
     
    419430#endif
    420431
    421     m_tiler->uploadTexturesIfNeeded();
     432    if (m_tiler)
     433        m_tiler->uploadTexturesIfNeeded();
    422434}
    423435
     
    437449#endif
    438450
    439     m_tiler->layerVisibilityChanged(visible);
     451    if (m_tiler)
     452        m_tiler->layerVisibilityChanged(visible);
    440453}
    441454
     
    448461void LayerCompositingThread::scheduleCommit()
    449462{
     463    if (!m_tiler)
     464        return;
     465
    450466    if (!isWebKitThread()) {
    451467        if (m_commitScheduled)
  • trunk/Source/WebCore/platform/graphics/blackberry/LayerCompositingThread.h

    r113868 r118699  
    3737
    3838#include "FloatQuad.h"
     39#include "LayerAnimation.h"
    3940#include "LayerData.h"
    4041#include "LayerRendererSurface.h"
     
    140141    bool hasVisibleHolePunchRect() const;
    141142
     143    void addAnimation(LayerAnimation* animation) { m_runningAnimations.append(animation); }
     144    void setRunningAnimations(const Vector<RefPtr<LayerAnimation> >& animations) { m_runningAnimations = animations; }
     145    void setSuspendedAnimations(const Vector<RefPtr<LayerAnimation> >& animations) { m_suspendedAnimations = animations; }
     146
    142147protected:
    143148    virtual ~LayerCompositingThread();
     149
     150    virtual void drawCustom(int positionLocation, int texCoordLocation) { }
    144151
    145152private:
     
    184191
    185192    RefPtr<LayerTiler> m_tiler;
     193    Vector<RefPtr<LayerAnimation> > m_runningAnimations;
     194    Vector<RefPtr<LayerAnimation> > m_suspendedAnimations;
    186195};
    187196
  • trunk/Source/WebCore/platform/graphics/blackberry/LayerData.h

    r112407 r118699  
    3838#include "FloatRect.h"
    3939#include "IntRect.h"
    40 #include "LayerAnimation.h"
    4140#include "PlatformString.h"
    4241#include "TransformationMatrix.h"
     
    5554class LayerData {
    5655public:
    57     enum LayerType { Layer, TransformLayer, WebGLLayer, CanvasLayer };
     56    enum LayerType { Layer, TransformLayer, WebGLLayer, CanvasLayer, CustomLayer };
    5857    enum FilterType { Linear, Nearest, Trilinear, Lanczos };
    5958    enum LayerProgramShader { LayerProgramShaderRGBA = 0,
     
    192191    pthread_mutex_t* m_frontBufferLock;
    193192
    194     Vector<RefPtr<LayerAnimation> > m_runningAnimations;
    195     Vector<RefPtr<LayerAnimation> > m_suspendedAnimations;
    196193    double m_suspendTime;
    197194
  • trunk/Source/WebCore/platform/graphics/blackberry/LayerWebKitThread.cpp

    r112124 r118699  
    6464    , m_isDrawable(false)
    6565    , m_isMask(false)
    66 {
    67     m_tiler = LayerTiler::create(this);
     66    , m_animationsChanged(false)
     67{
     68    if (type == Layer)
     69        m_tiler = LayerTiler::create(this);
    6870    m_layerCompositingThread = LayerCompositingThread::create(type, m_tiler);
     71}
     72
     73LayerWebKitThread::LayerWebKitThread(PassRefPtr<LayerCompositingThread> layerCompositingThread, GraphicsLayerBlackBerry* owner)
     74    : LayerData(CustomLayer)
     75    , m_owner(owner)
     76    , m_superlayer(0)
     77    , m_contents(0)
     78    , m_scale(1.0)
     79    , m_isDrawable(false)
     80    , m_isMask(false)
     81{
     82    m_layerCompositingThread = layerCompositingThread;
    6983}
    7084
     
    7690        pthread_mutex_destroy(m_frontBufferLock);
    7791
    78     m_tiler->layerWebKitThreadDestroyed();
     92    if (m_tiler)
     93        m_tiler->layerWebKitThreadDestroyed();
    7994
    8095    // Our superlayer should be holding a reference to us so there should be no
     
    168183void LayerWebKitThread::updateTextureContentsIfNeeded()
    169184{
    170     m_tiler->updateTextureContentsIfNeeded(m_isMask ? 1.0 : contentsScale());
     185    if (m_tiler)
     186        m_tiler->updateTextureContentsIfNeeded(m_isMask ? 1.0 : contentsScale());
    171187}
    172188
     
    227243    for (size_t i = 0; i < m_runningAnimations.size(); ++i) {
    228244        if (!m_runningAnimations[i]->startTime()) {
     245            m_animationsChanged = true;
    229246            m_runningAnimations[i]->setStartTime(time);
    230247            notifyAnimationStarted(time);
     
    279296    // Copy the base variables from this object into m_layerCompositingThread
    280297    replicate(m_layerCompositingThread.get());
     298    if (m_animationsChanged) {
     299        m_layerCompositingThread->setRunningAnimations(m_runningAnimations);
     300        m_layerCompositingThread->setSuspendedAnimations(m_suspendedAnimations);
     301        m_animationsChanged = false;
     302    }
    281303    m_position = oldPosition;
    282304    updateLayerHierarchy();
    283     m_tiler->commitPendingTextureUploads();
     305    if (m_tiler)
     306        m_tiler->commitPendingTextureUploads();
    284307
    285308    size_t listSize = m_sublayers.size();
     
    425448void LayerWebKitThread::setNeedsDisplayInRect(const FloatRect& dirtyRect)
    426449{
    427     m_tiler->setNeedsDisplay(dirtyRect);
     450    if (m_tiler)
     451        m_tiler->setNeedsDisplay(dirtyRect);
    428452    setNeedsCommit(); // FIXME: Replace this with a more targeted message for dirty rect handling with plugin content?
    429453}
     
    431455void LayerWebKitThread::setNeedsDisplay()
    432456{
    433     m_tiler->setNeedsDisplay();
     457    if (m_tiler)
     458        m_tiler->setNeedsDisplay();
    434459    setNeedsCommit(); // FIXME: Replace this with a more targeted message for dirty rect handling with plugin content?
    435460}
     
    449474{
    450475    m_isMask = isMask;
    451     if (isMask)
     476    if (isMask && m_tiler)
    452477        m_tiler->disableTiling(true);
    453478}
    454479
     480void LayerWebKitThread::setRunningAnimations(const Vector<RefPtr<LayerAnimation> >& animations)
     481{
     482    m_runningAnimations = animations;
     483    m_animationsChanged = true;
     484    setNeedsCommit();
     485}
     486
     487void LayerWebKitThread::setSuspendedAnimations(const Vector<RefPtr<LayerAnimation> >& animations)
     488{
     489    m_suspendedAnimations = animations;
     490    m_animationsChanged = true;
     491    setNeedsCommit();
     492}
     493
    455494}
    456495
  • trunk/Source/WebCore/platform/graphics/blackberry/LayerWebKitThread.h

    r112407 r118699  
    3737
    3838#include "GraphicsLayerBlackBerry.h"
     39#include "LayerAnimation.h"
    3940#include "LayerData.h"
    4041#include "LayerTiler.h"
     
    143144    void notifyAnimationStarted(double time);
    144145
    145     void setRunningAnimations(const Vector<RefPtr<LayerAnimation> >& animations) { m_runningAnimations = animations; setNeedsCommit(); }
    146     void setSuspendedAnimations(const Vector<RefPtr<LayerAnimation> >& animations) { m_suspendedAnimations = animations; setNeedsCommit(); }
     146    void setRunningAnimations(const Vector<RefPtr<LayerAnimation> >&);
     147    void setSuspendedAnimations(const Vector<RefPtr<LayerAnimation> >&);
    147148
    148149protected:
    149150    LayerWebKitThread(LayerType, GraphicsLayerBlackBerry* owner);
     151
     152    // Create a custom Layer{WebKitThread, CompositingThread} pair, used when you need to subclass both.
     153    LayerWebKitThread(PassRefPtr<LayerCompositingThread>, GraphicsLayerBlackBerry* owner);
    150154
    151155    void setNeedsTexture(bool needsTexture) { m_needsTexture = needsTexture; }
     
    179183    GraphicsLayerBlackBerry* m_owner;
    180184
     185    Vector<RefPtr<LayerAnimation> > m_runningAnimations;
     186    Vector<RefPtr<LayerAnimation> > m_suspendedAnimations;
     187
    181188    Vector<RefPtr<LayerWebKitThread> > m_sublayers;
    182189    LayerWebKitThread* m_superlayer;
     
    190197    FloatSize m_absoluteOffset;
    191198    double m_scale; // Scale applies only to content layers
    192     bool m_isDrawable;
    193     bool m_isMask;
     199    unsigned m_isDrawable : 1;
     200    unsigned m_isMask : 1;
     201    unsigned m_animationsChanged : 1;
    194202};
    195203
  • trunk/Source/WebKit/blackberry/Api/WebPage.cpp

    r118627 r118699  
    55835583void WebPagePrivate::scheduleRootLayerCommit()
    55845584{
    5585     if (!m_frameLayers || !m_frameLayers->hasLayer())
     5585    if (!(m_frameLayers && m_frameLayers->hasLayer()) && !m_overlayLayer)
    55865586        return;
    55875587
     
    56195619}
    56205620
     5621GraphicsLayer* WebPagePrivate::overlayLayer()
     5622{
     5623    // The overlay layer has no GraphicsLayerClient, it's just a container
     5624    // for various overlays.
     5625    if (!m_overlayLayer)
     5626        m_overlayLayer = GraphicsLayer::create(0);
     5627
     5628    return m_overlayLayer.get();
     5629}
     5630
    56215631void WebPagePrivate::setCompositor(PassRefPtr<WebPageCompositorPrivate> compositor)
    56225632{
     
    56485658#endif
    56495659
    5650     if (!m_frameLayers || !m_compositor)
    5651         return;
    5652 
    5653     if (m_frameLayers->rootLayer() && m_frameLayers->rootLayer()->layerCompositingThread() != m_compositor->rootLayer())
    5654         m_compositor->setRootLayer(m_frameLayers->rootLayer()->layerCompositingThread());
     5660    if (!m_compositor)
     5661        return;
     5662
     5663    // Frame layers
     5664    LayerWebKitThread* rootLayer = 0;
     5665    if (m_frameLayers)
     5666        rootLayer = m_frameLayers->rootLayer();
     5667
     5668    if (rootLayer && rootLayer->layerCompositingThread() != m_compositor->rootLayer())
     5669        m_compositor->setRootLayer(rootLayer->layerCompositingThread());
     5670
     5671    // Overlay layers
     5672    LayerWebKitThread* overlayLayer = 0;
     5673    if (m_overlayLayer)
     5674        overlayLayer = m_overlayLayer->platformLayer();
     5675
     5676    if (overlayLayer && overlayLayer->layerCompositingThread() != m_compositor->overlayLayer())
     5677        m_compositor->setOverlayLayer(overlayLayer->layerCompositingThread());
    56555678
    56565679    m_compositor->setLayoutRectForCompositing(layoutRectForCompositing);
    56575680    m_compositor->setContentsSizeForCompositing(contentsSizeForCompositing);
    56585681    m_compositor->setDrawsRootLayer(drawsRootLayer);
    5659     m_compositor->commit(m_frameLayers->rootLayer());
     5682
     5683    if (rootLayer)
     5684        rootLayer->commitOnCompositingThread();
     5685
     5686    if (overlayLayer)
     5687        overlayLayer->commitOnCompositingThread();
    56605688}
    56615689
     
    56785706        return false;
    56795707
    5680     if (!m_frameLayers || !m_frameLayers->hasLayer())
     5708    if (!(m_frameLayers && m_frameLayers->hasLayer()) && !m_overlayLayer)
    56815709        return false;
    56825710
     
    57035731        m_rootLayerCommitTimer->stop();
    57045732
    5705     m_frameLayers->commitOnWebKitThread(currentScale());
     5733    double scale = currentScale();
     5734    if (m_frameLayers && m_frameLayers->hasLayer())
     5735        m_frameLayers->commitOnWebKitThread(scale);
    57065736    updateDelegatedOverlays();
     5737    if (m_overlayLayer)
     5738        m_overlayLayer->platformLayer()->commitOnWebKitThread(scale);
    57075739
    57085740    // Stash the visible content rect according to webkit thread
  • trunk/Source/WebKit/blackberry/Api/WebPageCompositor.cpp

    r118696 r118699  
    7979}
    8080
     81void WebPageCompositorPrivate::setOverlayLayer(LayerCompositingThread* overlayLayer)
     82{
     83    m_overlayLayer = overlayLayer;
     84}
     85
    8186void WebPageCompositorPrivate::prepareFrame(double animationTime)
    8287{
     
    8994    if (m_rootLayer)
    9095        m_layerRenderer->prepareFrame(animationTime, m_rootLayer.get());
     96    if (m_overlayLayer)
     97        m_layerRenderer->prepareFrame(animationTime, m_overlayLayer.get());
    9198}
    9299
     
    121128    if (m_rootLayer)
    122129        m_layerRenderer->compositeLayers(transform, m_rootLayer.get());
     130    if (m_overlayLayer)
     131        m_layerRenderer->compositeLayers(transform, m_overlayLayer.get());
    123132
    124133    m_lastCompositingResults = m_layerRenderer->lastRenderingResults();
     
    163172    if (m_rootLayer)
    164173        m_layerRenderer->compositeLayers(transform, m_rootLayer.get());
     174    if (m_overlayLayer)
     175        m_layerRenderer->compositeLayers(transform, m_overlayLayer.get());
    165176
    166177    m_lastCompositingResults = m_layerRenderer->lastRenderingResults();
  • trunk/Source/WebKit/blackberry/Api/WebPageCompositor_p.h

    r118696 r118699  
    6868    void setRootLayer(WebCore::LayerCompositingThread*);
    6969
     70    WebCore::LayerCompositingThread* overlayLayer() const { return m_overlayLayer.get(); }
     71    void setOverlayLayer(WebCore::LayerCompositingThread*);
     72
    7073    bool drawsRootLayer() const;
    7174    void setDrawsRootLayer(bool drawsRootLayer) { m_drawsRootLayer = drawsRootLayer; }
     
    101104    OwnPtr<WebCore::LayerRenderer> m_layerRenderer;
    102105    RefPtr<WebCore::LayerCompositingThread> m_rootLayer;
     106    RefPtr<WebCore::LayerCompositingThread> m_overlayLayer;
    103107    WebCore::IntRect m_layoutRectForCompositing;
    104108    WebCore::IntSize m_contentsSizeForCompositing;
  • trunk/Source/WebKit/blackberry/Api/WebPage_p.h

    r116603 r118699  
    369369    bool commitRootLayerIfNeeded();
    370370    WebCore::LayerRenderingResults lastCompositingResults() const;
     371    WebCore::GraphicsLayer* overlayLayer();
    371372
    372373    // WebKit thread, plumbed through from ChromeClientBlackBerry.
     
    517518    bool m_isAcceleratedCompositingActive;
    518519    OwnPtr<FrameLayers> m_frameLayers; // WebKit thread only.
     520    OwnPtr<WebCore::GraphicsLayer> m_overlayLayer;
    519521
    520522    // Compositing thread only, used only when the WebKit layer created the context.
  • trunk/Source/WebKit/blackberry/ChangeLog

    r118696 r118699  
     12012-05-28  Arvid Nilsson  <anilsson@rim.com>
     2
     3        [BlackBerry] Add an overlay layer
     4        https://bugs.webkit.org/show_bug.cgi?id=87567
     5
     6        Reviewed by Antonio Gomes.
     7
     8        The overlay layer allows us to have compositing layers even though the
     9        web page is not currently using accelerated compositing.
     10
     11        These layers can be used to implement tap highlight, inspector overlay
     12        and more.
     13
     14        Reviewed internally by Filip Spacek.
     15
     16        PR #154335
     17
     18        * Api/WebPage.cpp:
     19        (BlackBerry::WebKit::WebPagePrivate::scheduleRootLayerCommit):
     20        (BlackBerry::WebKit::WebPagePrivate::overlayLayer):
     21        (WebKit):
     22        (BlackBerry::WebKit::WebPagePrivate::commitRootLayer):
     23        (BlackBerry::WebKit::WebPagePrivate::commitRootLayerIfNeeded):
     24        * Api/WebPageCompositor.cpp:
     25        (BlackBerry::WebKit::WebPageCompositorPrivate::setOverlayLayer):
     26        (WebKit):
     27        (BlackBerry::WebKit::WebPageCompositorPrivate::prepareFrame):
     28        (BlackBerry::WebKit::WebPageCompositorPrivate::render):
     29        (BlackBerry::WebKit::WebPageCompositorPrivate::drawLayers):
     30        * Api/WebPageCompositor_p.h:
     31        (BlackBerry::WebKit::WebPageCompositorPrivate::overlayLayer):
     32        (WebPageCompositorPrivate):
     33        * Api/WebPage_p.h:
     34        (WebPagePrivate):
     35
    1362012-05-28  Arvid Nilsson  <anilsson@rim.com>
    237
Note: See TracChangeset for help on using the changeset viewer.