Changeset 108951 in webkit


Ignore:
Timestamp:
Feb 26, 2012 8:13:32 PM (12 years ago)
Author:
commit-queue@webkit.org
Message:

Use Functional instead of a MessageQueue for messages to the LayerTreeHostProxy
renderer.
https://bugs.webkit.org/show_bug.cgi?id=79478

This makes a lot of the broilerplate code for message-passing unnecessary, and
results in a much more succinct implementation.

Patch by Huang Dongsung <luxtella@company100.net> on 2012-02-26
Reviewed by Noam Rosenthal.

  • UIProcess/LayerTreeHostProxy.h:

(WebKit):
(LayerTreeHostProxy):

  • UIProcess/qt/LayerTreeHostProxyQt.cpp:

(WebKit):
(WebKit::LayerTreeHostProxy::updateTile):
(WebKit::LayerTreeHostProxy::createImage):
(WebKit::LayerTreeHostProxy::syncRemoteContent):
(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):

Location:
trunk/Source/WebKit2
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebKit2/ChangeLog

    r108947 r108951  
     12012-02-26  Huang Dongsung  <luxtella@company100.net>
     2
     3        Use Functional instead of a MessageQueue for messages to the LayerTreeHostProxy
     4        renderer.
     5        https://bugs.webkit.org/show_bug.cgi?id=79478
     6
     7        This makes a lot of the broilerplate code for message-passing unnecessary, and
     8        results in a much more succinct implementation.
     9
     10        Reviewed by Noam Rosenthal.
     11
     12        * UIProcess/LayerTreeHostProxy.h:
     13        (WebKit):
     14        (LayerTreeHostProxy):
     15        * UIProcess/qt/LayerTreeHostProxyQt.cpp:
     16        (WebKit):
     17        (WebKit::LayerTreeHostProxy::updateTile):
     18        (WebKit::LayerTreeHostProxy::createImage):
     19        (WebKit::LayerTreeHostProxy::syncRemoteContent):
     20        (WebKit::LayerTreeHostProxy::dispatchUpdate):
     21        (WebKit::LayerTreeHostProxy::createTileForLayer):
     22        (WebKit::LayerTreeHostProxy::updateTileForLayer):
     23        (WebKit::LayerTreeHostProxy::removeTileForLayer):
     24        (WebKit::LayerTreeHostProxy::deleteCompositingLayer):
     25        (WebKit::LayerTreeHostProxy::setRootCompositingLayer):
     26        (WebKit::LayerTreeHostProxy::syncCompositingLayerState):
     27        (WebKit::LayerTreeHostProxy::didRenderFrame):
     28        (WebKit::LayerTreeHostProxy::createDirectlyCompositedImage):
     29        (WebKit::LayerTreeHostProxy::destroyDirectlyCompositedImage):
     30
    1312012-02-26  Filip Pizlo  <fpizlo@apple.com>
    232
  • trunk/Source/WebKit2/UIProcess/LayerTreeHostProxy.h

    r108771 r108951  
    2323#include "BackingStore.h"
    2424#include "DrawingAreaProxy.h"
    25 #include "MessageQueue.h"
    2625#include "Region.h"
    2726#include "WebLayerTreeInfo.h"
     
    3231#include <WebCore/RunLoop.h>
    3332#include <WebCore/Timer.h>
     33#include <wtf/Functional.h>
    3434#include <wtf/HashSet.h>
    3535
     
    4444class WebLayerInfo;
    4545class WebLayerUpdateInfo;
    46 
    47 class LayerTreeMessageToRenderer;
    4846
    4947class LayerTreeHostProxy : public WebCore::GraphicsLayerClient {
     
    9290    float m_contentsScale;
    9391
    94     MessageQueue<LayerTreeMessageToRenderer> m_messagesToRenderer;
    95     void pushUpdateToQueue(PassOwnPtr<LayerTreeMessageToRenderer>);
     92    Vector<Function<void()> > m_renderQueue;
     93    void dispatchUpdate(const Function<void()>&);
    9694
    9795#if USE(TEXTURE_MAPPER)
     
    107105    void createTile(WebLayerID, int, float scale);
    108106    void removeTile(WebLayerID, int);
    109     void updateTile(WebLayerID, int, const WebCore::IntRect&, const WebCore::IntRect&, ShareableBitmap*);
    110     void createImage(int64_t, ShareableBitmap*);
     107    void updateTile(WebLayerID, int, const WebCore::IntRect&, const WebCore::IntRect&, PassRefPtr<ShareableBitmap>);
     108    void createImage(int64_t, PassRefPtr<ShareableBitmap>);
    111109    void destroyImage(int64_t);
    112110    void assignImageToLayer(WebCore::GraphicsLayer*, int64_t imageID);
  • trunk/Source/WebKit2/UIProcess/qt/LayerTreeHostProxyQt.cpp

    r108771 r108951  
    4242namespace WebKit {
    4343
    44 class LayerTreeMessageToRenderer {
    45 public:
    46     enum Type {
    47         DeleteLayer,
    48         CreateTile,
    49         RemoveTile,
    50         UpdateTile,
    51         CreateImage,
    52         DestroyImage,
    53         SyncLayerParameters,
    54         FlushLayerChanges,
    55         SetRootLayer
    56     };
    57     virtual ~LayerTreeMessageToRenderer() { }
    58     virtual Type type() const = 0;
    59 };
    60 
    6144using namespace WebCore;
    62 
    63 template<class MessageData, LayerTreeMessageToRenderer::Type messageType>
    64 class LayerTreeMessageToRendererWithData : public LayerTreeMessageToRenderer {
    65 public:
    66     virtual Type type() const { return messageType; }
    67 
    68     static PassOwnPtr<LayerTreeMessageToRenderer> create(const MessageData& data = MessageData())
    69     {
    70         return adoptPtr(new LayerTreeMessageToRendererWithData(data));
    71     }
    72 
    73     const MessageData& data() const
    74     {
    75         return m_data;
    76     }
    77 
    78 private:
    79     LayerTreeMessageToRendererWithData(const MessageData& data)
    80         : m_data(data)
    81     {
    82     }
    83 
    84     MessageData m_data;
    85 };
    86 
    87 
    88 namespace {
    89 struct CreateTileMessageData {
    90     WebLayerID layerID;
    91     int remoteTileID;
    92     float scale;
    93 };
    94 
    95 struct UpdateTileMessageData {
    96     WebLayerID layerID;
    97     int remoteTileID;
    98     IntRect sourceRect;
    99     IntRect targetRect;
    100     RefPtr<ShareableBitmap> bitmap;
    101 };
    102 
    103 struct RemoveTileMessageData {
    104     WebLayerID layerID;
    105     int remoteTileID;
    106 };
    107 
    108 struct CreateImageMessageData {
    109     int64_t imageID;
    110     RefPtr<ShareableBitmap> bitmap;
    111 };
    112 
    113 struct DestroyImageMessageData {
    114     int64_t imageID;
    115 };
    116 
    117 struct SyncLayerParametersMessageData {
    118     WebLayerInfo layerInfo;
    119 };
    120 
    121 struct EmptyMessageData { };
    122 struct DeleteLayerMessageData {
    123     WebLayerID layerID;
    124 };
    125 struct SetRootLayerMessageData {
    126     WebLayerID layerID;
    127 };
    128 
    129 class CreateTileMessage
    130         : public LayerTreeMessageToRendererWithData<CreateTileMessageData, LayerTreeMessageToRenderer::CreateTile> { };
    131 class UpdateTileMessage
    132         : public LayerTreeMessageToRendererWithData<UpdateTileMessageData, LayerTreeMessageToRenderer::UpdateTile> { };
    133 class RemoveTileMessage
    134         : public LayerTreeMessageToRendererWithData<RemoveTileMessageData, LayerTreeMessageToRenderer::RemoveTile> { };
    135 class CreateImageMessage
    136         : public LayerTreeMessageToRendererWithData<CreateImageMessageData, LayerTreeMessageToRenderer::CreateImage> { };
    137 class DestroyImageMessage
    138         : public LayerTreeMessageToRendererWithData<DestroyImageMessageData, LayerTreeMessageToRenderer::DestroyImage> { };
    139 class FlushLayerChangesMessage
    140         : public LayerTreeMessageToRendererWithData<EmptyMessageData, LayerTreeMessageToRenderer::FlushLayerChanges> { };
    141 class SyncLayerParametersMessage
    142         : public LayerTreeMessageToRendererWithData<SyncLayerParametersMessageData, LayerTreeMessageToRenderer::SyncLayerParameters> { };
    143 class DeleteLayerMessage
    144         : public LayerTreeMessageToRendererWithData<DeleteLayerMessageData, LayerTreeMessageToRenderer::DeleteLayer> { };
    145 class SetRootLayerMessage
    146         : public LayerTreeMessageToRendererWithData<SetRootLayerMessageData, LayerTreeMessageToRenderer::SetRootLayer> { };
    147 }
    14845
    14946PassOwnPtr<GraphicsLayer> LayerTreeHostProxy::createLayer(WebLayerID layerID)
     
    363260}
    364261
    365 void LayerTreeHostProxy::updateTile(WebLayerID layerID, int tileID, const IntRect& sourceRect, const IntRect& targetRect, ShareableBitmap* bitmap)
    366 {
     262void LayerTreeHostProxy::updateTile(WebLayerID layerID, int tileID, const IntRect& sourceRect, const IntRect& targetRect, PassRefPtr<ShareableBitmap> weakBitmap)
     263{
     264    RefPtr<ShareableBitmap> bitmap = weakBitmap;
    367265    RefPtr<LayerBackingStore> backingStore = getBackingStore(layerID);
    368     backingStore->updateTile(tileID, sourceRect, targetRect, bitmap);
     266    backingStore->updateTile(tileID, sourceRect, targetRect, bitmap.get());
    369267    m_backingStoresWithPendingBuffers.add(backingStore);
    370268}
    371269
    372 void LayerTreeHostProxy::createImage(int64_t imageID, ShareableBitmap* bitmap)
    373 {
     270void LayerTreeHostProxy::createImage(int64_t imageID, PassRefPtr<ShareableBitmap> weakBitmap)
     271{
     272    RefPtr<ShareableBitmap> bitmap = weakBitmap;
    374273    RefPtr<TextureMapperTiledBackingStore> backingStore = TextureMapperTiledBackingStore::create();
    375274    backingStore->updateContents(m_textureMapper.get(), bitmap->createImage().get(), BitmapTexture::BGRAFormat);
     
    428327    ensureRootLayer();
    429328
    430     while (OwnPtr<LayerTreeMessageToRenderer> nextMessage = m_messagesToRenderer.tryGetMessage()) {
    431         switch (nextMessage->type()) {
    432         case LayerTreeMessageToRenderer::SetRootLayer: {
    433             const SetRootLayerMessageData& data = static_cast<SetRootLayerMessage*>(nextMessage.get())->data();
    434             setRootLayerID(data.layerID);
    435             break;
    436         }
    437 
    438         case LayerTreeMessageToRenderer::DeleteLayer: {
    439             const DeleteLayerMessageData& data = static_cast<DeleteLayerMessage*>(nextMessage.get())->data();
    440             deleteLayer(data.layerID);
    441             break;
    442         }
    443 
    444         case LayerTreeMessageToRenderer::SyncLayerParameters: {
    445             const SyncLayerParametersMessageData& data = static_cast<SyncLayerParametersMessage*>(nextMessage.get())->data();
    446             syncLayerParameters(data.layerInfo);
    447             break;
    448         }
    449 
    450         case LayerTreeMessageToRenderer::CreateTile: {
    451             const CreateTileMessageData& data = static_cast<CreateTileMessage*>(nextMessage.get())->data();
    452             createTile(data.layerID, data.remoteTileID, data.scale);
    453             break;
    454         }
    455 
    456         case LayerTreeMessageToRenderer::RemoveTile: {
    457             const RemoveTileMessageData& data = static_cast<RemoveTileMessage*>(nextMessage.get())->data();
    458             removeTile(data.layerID, data.remoteTileID);
    459             break;
    460         }
    461 
    462         case LayerTreeMessageToRenderer::UpdateTile: {
    463             const UpdateTileMessageData& data = static_cast<UpdateTileMessage*>(nextMessage.get())->data();
    464             updateTile(data.layerID, data.remoteTileID, data.sourceRect, data.targetRect, data.bitmap.get());
    465             break;
    466         }
    467 
    468         case LayerTreeMessageToRenderer::CreateImage: {
    469             const CreateImageMessageData& data = static_cast<CreateImageMessage*>(nextMessage.get())->data();
    470             createImage(data.imageID, data.bitmap.get());
    471             break;
    472         }
    473 
    474         case LayerTreeMessageToRenderer::DestroyImage: {
    475             const DestroyImageMessageData& data = static_cast<DestroyImageMessage*>(nextMessage.get())->data();
    476             destroyImage(data.imageID);
    477             break;
    478         }
    479 
    480         case LayerTreeMessageToRenderer::FlushLayerChanges:
    481             flushLayerChanges();
    482             break;
    483         }
    484     }
    485 }
    486 
    487 void LayerTreeHostProxy::pushUpdateToQueue(PassOwnPtr<LayerTreeMessageToRenderer> message)
    488 {
    489     m_messagesToRenderer.append(message);
     329    for (size_t i = 0; i < m_renderQueue.size(); ++i)
     330        m_renderQueue[i]();
     331
     332    m_renderQueue.clear();
     333}
     334
     335void LayerTreeHostProxy::dispatchUpdate(const Function<void()>& function)
     336{
     337    m_renderQueue.append(function);
    490338    updateViewport();
    491339}
     
    493341void LayerTreeHostProxy::createTileForLayer(int layerID, int tileID, const WebKit::UpdateInfo& updateInfo)
    494342{
    495     CreateTileMessageData data;
    496     data.layerID = layerID;
    497     data.remoteTileID = tileID;
    498     data.scale = updateInfo.updateScaleFactor;
    499     pushUpdateToQueue(CreateTileMessage::create(data));
     343    dispatchUpdate(bind(&LayerTreeHostProxy::createTile, this, layerID, tileID, updateInfo.updateScaleFactor));
    500344    updateTileForLayer(layerID, tileID, updateInfo);
    501345}
     
    503347void LayerTreeHostProxy::updateTileForLayer(int layerID, int tileID, const WebKit::UpdateInfo& updateInfo)
    504348{
    505     UpdateTileMessageData data;
    506     data.layerID = layerID;
    507     data.remoteTileID = tileID;
    508     data.bitmap = ShareableBitmap::create(updateInfo.bitmapHandle);
    509349    ASSERT(updateInfo.updateRects.size() == 1);
    510     data.sourceRect = updateInfo.updateRects.first();
    511     data.targetRect = updateInfo.updateRectBounds;
    512     pushUpdateToQueue(UpdateTileMessage::create(data));
     350    IntRect sourceRect = updateInfo.updateRects.first();
     351    IntRect targetRect = updateInfo.updateRectBounds;
     352    RefPtr<ShareableBitmap> bitmap = ShareableBitmap::create(updateInfo.bitmapHandle);
     353    dispatchUpdate(bind(&LayerTreeHostProxy::updateTile, this, layerID, tileID, sourceRect, targetRect, bitmap));
    513354}
    514355
    515356void LayerTreeHostProxy::removeTileForLayer(int layerID, int tileID)
    516357{
    517     RemoveTileMessageData data;
    518     data.layerID = layerID;
    519     data.remoteTileID = tileID;
    520     pushUpdateToQueue(RemoveTileMessage::create(data));
     358    dispatchUpdate(bind(&LayerTreeHostProxy::removeTile, this, layerID, tileID));
    521359}
    522360
     
    524362void LayerTreeHostProxy::deleteCompositingLayer(WebLayerID id)
    525363{
    526     DeleteLayerMessageData data;
    527     data.layerID = id;
    528     pushUpdateToQueue(DeleteLayerMessage::create(data));
     364    dispatchUpdate(bind(&LayerTreeHostProxy::deleteLayer, this, id));
    529365}
    530366
    531367void LayerTreeHostProxy::setRootCompositingLayer(WebLayerID id)
    532368{
    533     SetRootLayerMessageData data;
    534     data.layerID = id;
    535     pushUpdateToQueue(SetRootLayerMessage::create(data));
     369    dispatchUpdate(bind(&LayerTreeHostProxy::setRootLayerID, this, id));
    536370}
    537371
    538372void LayerTreeHostProxy::syncCompositingLayerState(const WebLayerInfo& info)
    539373{
    540     SyncLayerParametersMessageData data;
    541     data.layerInfo = info;
    542     pushUpdateToQueue(SyncLayerParametersMessage::create(data));
     374    dispatchUpdate(bind(&LayerTreeHostProxy::syncLayerParameters, this, info));
    543375}
    544376
    545377void LayerTreeHostProxy::didRenderFrame()
    546378{
    547     pushUpdateToQueue(FlushLayerChangesMessage::create());
    548     updateViewport();
     379    dispatchUpdate(bind(&LayerTreeHostProxy::flushLayerChanges, this));
    549380}
    550381
    551382void LayerTreeHostProxy::createDirectlyCompositedImage(int64_t key, const WebKit::ShareableBitmap::Handle& handle)
    552383{
    553     CreateImageMessageData data;
    554     data.imageID = key;
    555     data.bitmap = ShareableBitmap::create(handle);
    556     pushUpdateToQueue(CreateImageMessage::create(data));
     384    RefPtr<ShareableBitmap> bitmap = ShareableBitmap::create(handle);
     385    dispatchUpdate(bind(&LayerTreeHostProxy::createImage, this, key, bitmap));
    557386}
    558387
    559388void LayerTreeHostProxy::destroyDirectlyCompositedImage(int64_t key)
    560389{
    561     DestroyImageMessageData data;
    562     data.imageID = key;
    563     pushUpdateToQueue(DestroyImageMessage::create(data));
     390    dispatchUpdate(bind(&LayerTreeHostProxy::destroyImage, this, key));
    564391}
    565392
Note: See TracChangeset for help on using the changeset viewer.