[SCM] WebKit Debian packaging branch, debian/experimental, updated. debian/1.3.8-1-1049-g2e11a8e

andersca at apple.com andersca at apple.com
Fri Jan 21 14:42:31 UTC 2011


The following commit has been merged in the debian/experimental branch:
commit 790af0ef0efbf86732ad79f397f46f3338981dcb
Author: andersca at apple.com <andersca at apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Date:   Sun Dec 26 19:41:17 2010 +0000

    Rename DrawingAreaMessage and DrawingAreaLegacyMessage and
    DrawingAreaProxyMessage to DrawingAreaProxyLegacyMessage.
    
    Reviewed by Dan Bernstein.
    
    * Platform/CoreIPC/MessageID.h:
    * Shared/CoreIPCSupport/DrawingAreaMessageKinds.h:
    * Shared/CoreIPCSupport/DrawingAreaProxyMessageKinds.h:
    * UIProcess/ChunkedUpdateDrawingAreaProxy.cpp:
    (WebKit::ChunkedUpdateDrawingAreaProxy::paint):
    (WebKit::ChunkedUpdateDrawingAreaProxy::setPageIsVisible):
    (WebKit::ChunkedUpdateDrawingAreaProxy::update):
    (WebKit::ChunkedUpdateDrawingAreaProxy::sendSetSize):
    (WebKit::ChunkedUpdateDrawingAreaProxy::didReceiveMessage):
    * UIProcess/LayerBackedDrawingAreaProxy.cpp:
    (WebKit::LayerBackedDrawingAreaProxy::sizeDidChange):
    (WebKit::LayerBackedDrawingAreaProxy::setPageIsVisible):
    (WebKit::LayerBackedDrawingAreaProxy::update):
    (WebKit::LayerBackedDrawingAreaProxy::didReceiveMessage):
    (WebKit::LayerBackedDrawingAreaProxy::didReceiveSyncMessage):
    * UIProcess/TiledDrawingAreaProxy.cpp:
    (WebKit::TiledDrawingAreaProxy::sizeDidChange):
    (WebKit::TiledDrawingAreaProxy::setPageIsVisible):
    (WebKit::TiledDrawingAreaProxy::didReceiveMessage):
    (WebKit::TiledDrawingAreaProxy::requestTileUpdate):
    (WebKit::TiledDrawingAreaProxy::waitUntilUpdatesComplete):
    (WebKit::TiledDrawingAreaProxy::takeSnapshot):
    (WebKit::TiledDrawingAreaProxy::removeTile):
    * UIProcess/WebPageProxy.cpp:
    (WebKit::WebPageProxy::didReceiveMessage):
    (WebKit::WebPageProxy::didReceiveSyncMessage):
    * WebProcess/WebPage/ChunkedUpdateDrawingArea.cpp:
    (WebKit::ChunkedUpdateDrawingArea::display):
    (WebKit::ChunkedUpdateDrawingArea::setSize):
    (WebKit::ChunkedUpdateDrawingArea::didReceiveMessage):
    * WebProcess/WebPage/LayerBackedDrawingArea.cpp:
    (WebKit::LayerBackedDrawingArea::setSize):
    (WebKit::LayerBackedDrawingArea::didReceiveMessage):
    * WebProcess/WebPage/TiledDrawingArea.cpp:
    (WebKit::TiledDrawingArea::display):
    (WebKit::TiledDrawingArea::setSize):
    (WebKit::TiledDrawingArea::updateTile):
    (WebKit::TiledDrawingArea::tileUpdateTimerFired):
    (WebKit::TiledDrawingArea::didReceiveMessage):
    * WebProcess/WebPage/WebPage.cpp:
    (WebKit::WebPage::didReceiveMessage):
    * WebProcess/WebPage/mac/LayerBackedDrawingAreaMac.mm:
    (WebKit::LayerBackedDrawingArea::attachCompositingContext):
    
    
    
    git-svn-id: http://svn.webkit.org/repository/webkit/trunk@74669 268f45cc-cd09-0410-ab3c-d52691b4dbfc

diff --git a/WebKit2/ChangeLog b/WebKit2/ChangeLog
index 88935a2..7e46e86 100644
--- a/WebKit2/ChangeLog
+++ b/WebKit2/ChangeLog
@@ -1,5 +1,56 @@
 2010-12-26  Anders Carlsson  <andersca at apple.com>
 
+        Reviewed by Dan Bernstein.
+
+        Rename DrawingAreaMessage and DrawingAreaLegacyMessage and
+        DrawingAreaProxyMessage to DrawingAreaProxyLegacyMessage.
+
+        * Platform/CoreIPC/MessageID.h:
+        * Shared/CoreIPCSupport/DrawingAreaMessageKinds.h:
+        * Shared/CoreIPCSupport/DrawingAreaProxyMessageKinds.h:
+        * UIProcess/ChunkedUpdateDrawingAreaProxy.cpp:
+        (WebKit::ChunkedUpdateDrawingAreaProxy::paint):
+        (WebKit::ChunkedUpdateDrawingAreaProxy::setPageIsVisible):
+        (WebKit::ChunkedUpdateDrawingAreaProxy::update):
+        (WebKit::ChunkedUpdateDrawingAreaProxy::sendSetSize):
+        (WebKit::ChunkedUpdateDrawingAreaProxy::didReceiveMessage):
+        * UIProcess/LayerBackedDrawingAreaProxy.cpp:
+        (WebKit::LayerBackedDrawingAreaProxy::sizeDidChange):
+        (WebKit::LayerBackedDrawingAreaProxy::setPageIsVisible):
+        (WebKit::LayerBackedDrawingAreaProxy::update):
+        (WebKit::LayerBackedDrawingAreaProxy::didReceiveMessage):
+        (WebKit::LayerBackedDrawingAreaProxy::didReceiveSyncMessage):
+        * UIProcess/TiledDrawingAreaProxy.cpp:
+        (WebKit::TiledDrawingAreaProxy::sizeDidChange):
+        (WebKit::TiledDrawingAreaProxy::setPageIsVisible):
+        (WebKit::TiledDrawingAreaProxy::didReceiveMessage):
+        (WebKit::TiledDrawingAreaProxy::requestTileUpdate):
+        (WebKit::TiledDrawingAreaProxy::waitUntilUpdatesComplete):
+        (WebKit::TiledDrawingAreaProxy::takeSnapshot):
+        (WebKit::TiledDrawingAreaProxy::removeTile):
+        * UIProcess/WebPageProxy.cpp:
+        (WebKit::WebPageProxy::didReceiveMessage):
+        (WebKit::WebPageProxy::didReceiveSyncMessage):
+        * WebProcess/WebPage/ChunkedUpdateDrawingArea.cpp:
+        (WebKit::ChunkedUpdateDrawingArea::display):
+        (WebKit::ChunkedUpdateDrawingArea::setSize):
+        (WebKit::ChunkedUpdateDrawingArea::didReceiveMessage):
+        * WebProcess/WebPage/LayerBackedDrawingArea.cpp:
+        (WebKit::LayerBackedDrawingArea::setSize):
+        (WebKit::LayerBackedDrawingArea::didReceiveMessage):
+        * WebProcess/WebPage/TiledDrawingArea.cpp:
+        (WebKit::TiledDrawingArea::display):
+        (WebKit::TiledDrawingArea::setSize):
+        (WebKit::TiledDrawingArea::updateTile):
+        (WebKit::TiledDrawingArea::tileUpdateTimerFired):
+        (WebKit::TiledDrawingArea::didReceiveMessage):
+        * WebProcess/WebPage/WebPage.cpp:
+        (WebKit::WebPage::didReceiveMessage):
+        * WebProcess/WebPage/mac/LayerBackedDrawingAreaMac.mm:
+        (WebKit::LayerBackedDrawingArea::attachCompositingContext):
+
+2010-12-26  Anders Carlsson  <andersca at apple.com>
+
         Reviewed by Sam Weinig.
 
         Drawing area cleanup. Remove a bunch of redundant functions that just ended
diff --git a/WebKit2/Platform/CoreIPC/MessageID.h b/WebKit2/Platform/CoreIPC/MessageID.h
index 3ba6297..fbcc733 100644
--- a/WebKit2/Platform/CoreIPC/MessageID.h
+++ b/WebKit2/Platform/CoreIPC/MessageID.h
@@ -36,7 +36,7 @@ enum MessageClass {
 
     // Messages sent by the UI process to the web process.
     MessageClassAuthenticationManager,
-    MessageClassDrawingArea,
+    MessageClassDrawingAreaLegacy,
     MessageClassInjectedBundle,
     MessageClassWebDatabaseManager,
     MessageClassWebInspector,
@@ -44,7 +44,7 @@ enum MessageClass {
     MessageClassWebProcess,
 
     // Messages sent by the web process to the UI process.
-    MessageClassDrawingAreaProxy,
+    MessageClassDrawingAreaProxyLegacy,
     MessageClassDownloadProxy,
     MessageClassWebContext,
     MessageClassWebContextLegacy,
diff --git a/WebKit2/Shared/CoreIPCSupport/DrawingAreaMessageKinds.h b/WebKit2/Shared/CoreIPCSupport/DrawingAreaMessageKinds.h
index e88e0cd..1976888 100644
--- a/WebKit2/Shared/CoreIPCSupport/DrawingAreaMessageKinds.h
+++ b/WebKit2/Shared/CoreIPCSupport/DrawingAreaMessageKinds.h
@@ -30,7 +30,7 @@
 
 // Messages sent from the web process to the UI process.
 
-namespace DrawingAreaMessage {
+namespace DrawingAreaLegacyMessage {
 
 enum Kind {
     // Called whenever the size of the drawing area needs to be updated.
@@ -62,8 +62,8 @@ enum Kind {
 
 namespace CoreIPC {
 
-template<> struct MessageKindTraits<DrawingAreaMessage::Kind> { 
-    static const MessageClass messageClass = MessageClassDrawingArea;
+template<> struct MessageKindTraits<DrawingAreaLegacyMessage::Kind> { 
+    static const MessageClass messageClass = MessageClassDrawingAreaLegacy;
 };
 
 }
diff --git a/WebKit2/Shared/CoreIPCSupport/DrawingAreaProxyMessageKinds.h b/WebKit2/Shared/CoreIPCSupport/DrawingAreaProxyMessageKinds.h
index dfba437..c5ab54b 100644
--- a/WebKit2/Shared/CoreIPCSupport/DrawingAreaProxyMessageKinds.h
+++ b/WebKit2/Shared/CoreIPCSupport/DrawingAreaProxyMessageKinds.h
@@ -30,7 +30,7 @@
 
 // Messages sent from the web process to the WebPageProxy.
 
-namespace DrawingAreaProxyMessage {
+namespace DrawingAreaProxyLegacyMessage {
 
 enum Kind {
     Update,
@@ -50,8 +50,8 @@ enum Kind {
 
 namespace CoreIPC {
 
-template<> struct MessageKindTraits<DrawingAreaProxyMessage::Kind> { 
-    static const MessageClass messageClass = MessageClassDrawingAreaProxy;
+template<> struct MessageKindTraits<DrawingAreaProxyLegacyMessage::Kind> { 
+    static const MessageClass messageClass = MessageClassDrawingAreaProxyLegacy;
 };
 
 }
diff --git a/WebKit2/UIProcess/ChunkedUpdateDrawingAreaProxy.cpp b/WebKit2/UIProcess/ChunkedUpdateDrawingAreaProxy.cpp
index a019bde..3ac4db2 100644
--- a/WebKit2/UIProcess/ChunkedUpdateDrawingAreaProxy.cpp
+++ b/WebKit2/UIProcess/ChunkedUpdateDrawingAreaProxy.cpp
@@ -65,9 +65,9 @@ void ChunkedUpdateDrawingAreaProxy::paint(const IntRect& rect, PlatformDrawingCo
         if (page->process()->isLaunching())
             return;
 
-        OwnPtr<CoreIPC::ArgumentDecoder> arguments = page->process()->connection()->waitFor(DrawingAreaProxyMessage::DidSetSize, page->pageID(), 0.04);
+        OwnPtr<CoreIPC::ArgumentDecoder> arguments = page->process()->connection()->waitFor(DrawingAreaProxyLegacyMessage::DidSetSize, page->pageID(), 0.04);
         if (arguments)
-            didReceiveMessage(page->process()->connection(), CoreIPC::MessageID(DrawingAreaProxyMessage::DidSetSize), arguments.get());
+            didReceiveMessage(page->process()->connection(), CoreIPC::MessageID(DrawingAreaProxyLegacyMessage::DidSetSize), arguments.get());
     }
 
     platformPaint(rect, context);
@@ -91,12 +91,12 @@ void ChunkedUpdateDrawingAreaProxy::setPageIsVisible(bool isVisible)
 
     if (!m_isVisible) {
         // Tell the web process that it doesn't need to paint anything for now.
-        page->process()->send(DrawingAreaMessage::SuspendPainting, page->pageID(), CoreIPC::In(info().identifier));
+        page->process()->send(DrawingAreaLegacyMessage::SuspendPainting, page->pageID(), CoreIPC::In(info().identifier));
         return;
     }
     
     // The page is now visible, resume painting.
-    page->process()->send(DrawingAreaMessage::ResumePainting, page->pageID(), CoreIPC::In(info().identifier, m_forceRepaintWhenResumingPainting));
+    page->process()->send(DrawingAreaLegacyMessage::ResumePainting, page->pageID(), CoreIPC::In(info().identifier, m_forceRepaintWhenResumingPainting));
     m_forceRepaintWhenResumingPainting = false;
 }
     
@@ -131,7 +131,7 @@ void ChunkedUpdateDrawingAreaProxy::update(UpdateChunk* updateChunk)
     }
 
     WebPageProxy* page = this->page();
-    page->process()->send(DrawingAreaMessage::DidUpdate, page->pageID(), CoreIPC::In(info().identifier));
+    page->process()->send(DrawingAreaLegacyMessage::DidUpdate, page->pageID(), CoreIPC::In(info().identifier));
 }
 
 void ChunkedUpdateDrawingAreaProxy::sendSetSize()
@@ -144,13 +144,13 @@ void ChunkedUpdateDrawingAreaProxy::sendSetSize()
     m_isWaitingForDidSetFrameNotification = true;
     
     m_webPageProxy->process()->responsivenessTimer()->start();
-    m_webPageProxy->process()->send(DrawingAreaMessage::SetSize, m_webPageProxy->pageID(), CoreIPC::In(info().identifier, m_size));
+    m_webPageProxy->process()->send(DrawingAreaLegacyMessage::SetSize, m_webPageProxy->pageID(), CoreIPC::In(info().identifier, m_size));
 }
     
 void ChunkedUpdateDrawingAreaProxy::didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments)
 {
-    switch (messageID.get<DrawingAreaProxyMessage::Kind>()) {
-        case DrawingAreaProxyMessage::Update: {
+    switch (messageID.get<DrawingAreaProxyLegacyMessage::Kind>()) {
+        case DrawingAreaProxyLegacyMessage::Update: {
             UpdateChunk updateChunk;
             if (!arguments->decode(updateChunk))
                 return;
@@ -158,7 +158,7 @@ void ChunkedUpdateDrawingAreaProxy::didReceiveMessage(CoreIPC::Connection*, Core
             update(&updateChunk);
             break;
         }
-        case DrawingAreaProxyMessage::DidSetSize: {
+        case DrawingAreaProxyLegacyMessage::DidSetSize: {
             UpdateChunk updateChunk;
             if (!arguments->decode(CoreIPC::Out(updateChunk)))
                 return;
diff --git a/WebKit2/UIProcess/LayerBackedDrawingAreaProxy.cpp b/WebKit2/UIProcess/LayerBackedDrawingAreaProxy.cpp
index 0f8f7d3..af11ee8 100644
--- a/WebKit2/UIProcess/LayerBackedDrawingAreaProxy.cpp
+++ b/WebKit2/UIProcess/LayerBackedDrawingAreaProxy.cpp
@@ -80,7 +80,7 @@ void LayerBackedDrawingAreaProxy::sizeDidChange()
     m_isWaitingForDidSetFrameNotification = true;
 
     page->process()->responsivenessTimer()->start();
-    page->process()->send(DrawingAreaMessage::SetSize, page->pageID(), CoreIPC::In(info().identifier, m_size));
+    page->process()->send(DrawingAreaLegacyMessage::SetSize, page->pageID(), CoreIPC::In(info().identifier, m_size));
 }
 
 #if !PLATFORM(MAC) && !PLATFORM(WIN)
@@ -102,12 +102,12 @@ void LayerBackedDrawingAreaProxy::setPageIsVisible(bool isVisible)
 
     if (!m_isVisible) {
         // Tell the web process that it doesn't need to paint anything for now.
-        page->process()->send(DrawingAreaMessage::SuspendPainting, page->pageID(), CoreIPC::In(info().identifier));
+        page->process()->send(DrawingAreaLegacyMessage::SuspendPainting, page->pageID(), CoreIPC::In(info().identifier));
         return;
     }
     
     // The page is now visible.
-    page->process()->send(DrawingAreaMessage::ResumePainting, page->pageID(), CoreIPC::In(info().identifier));
+    page->process()->send(DrawingAreaLegacyMessage::ResumePainting, page->pageID(), CoreIPC::In(info().identifier));
     
     // FIXME: We should request a full repaint here if needed.
 }
@@ -126,17 +126,17 @@ void LayerBackedDrawingAreaProxy::didSetSize(const IntSize& size)
 void LayerBackedDrawingAreaProxy::update()
 {
     WebPageProxy* page = this->page();
-    page->process()->send(DrawingAreaMessage::DidUpdate, page->pageID(), CoreIPC::In(info().identifier));
+    page->process()->send(DrawingAreaLegacyMessage::DidUpdate, page->pageID(), CoreIPC::In(info().identifier));
 }
 
 void LayerBackedDrawingAreaProxy::didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments)
 {
-    switch (messageID.get<DrawingAreaProxyMessage::Kind>()) {
-        case DrawingAreaProxyMessage::Update: {
+    switch (messageID.get<DrawingAreaProxyLegacyMessage::Kind>()) {
+        case DrawingAreaProxyLegacyMessage::Update: {
             update();
             break;
         }
-        case DrawingAreaProxyMessage::DidSetSize: {
+        case DrawingAreaProxyLegacyMessage::DidSetSize: {
             IntSize size;
             if (!arguments->decode(CoreIPC::Out(size)))
                 return;
@@ -150,9 +150,9 @@ void LayerBackedDrawingAreaProxy::didReceiveMessage(CoreIPC::Connection*, CoreIP
 
 void LayerBackedDrawingAreaProxy::didReceiveSyncMessage(CoreIPC::Connection*, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments, CoreIPC::ArgumentEncoder*)
 {
-    switch (messageID.get<DrawingAreaProxyMessage::Kind>()) {
+    switch (messageID.get<DrawingAreaProxyLegacyMessage::Kind>()) {
 #if USE(ACCELERATED_COMPOSITING)
-        case DrawingAreaProxyMessage::AttachCompositingContext: {
+        case DrawingAreaProxyLegacyMessage::AttachCompositingContext: {
             uint32_t contextID;
             if (!arguments->decode(CoreIPC::Out(contextID)))
                 return;
diff --git a/WebKit2/UIProcess/TiledDrawingAreaProxy.cpp b/WebKit2/UIProcess/TiledDrawingAreaProxy.cpp
index 1958f8d..55b0159 100644
--- a/WebKit2/UIProcess/TiledDrawingAreaProxy.cpp
+++ b/WebKit2/UIProcess/TiledDrawingAreaProxy.cpp
@@ -82,7 +82,7 @@ void TiledDrawingAreaProxy::sizeDidChange()
     m_isWaitingForDidSetFrameNotification = true;
 
     page->process()->responsivenessTimer()->start();
-    page->process()->send(DrawingAreaMessage::SetSize, page->pageID(), CoreIPC::In(m_size));
+    page->process()->send(DrawingAreaLegacyMessage::SetSize, page->pageID(), CoreIPC::In(m_size));
 }
 
 void TiledDrawingAreaProxy::setPageIsVisible(bool isVisible)
@@ -98,12 +98,12 @@ void TiledDrawingAreaProxy::setPageIsVisible(bool isVisible)
 
     if (!m_isVisible) {
         // Tell the web process that it doesn't need to paint anything for now.
-        page->process()->send(DrawingAreaMessage::SuspendPainting, page->pageID(), CoreIPC::In());
+        page->process()->send(DrawingAreaLegacyMessage::SuspendPainting, page->pageID(), CoreIPC::In());
         return;
     }
 
     // The page is now visible.
-    page->process()->send(DrawingAreaMessage::ResumePainting, page->pageID(), CoreIPC::In());
+    page->process()->send(DrawingAreaLegacyMessage::ResumePainting, page->pageID(), CoreIPC::In());
 
     // FIXME: We should request a full repaint here if needed.
 }
@@ -122,8 +122,8 @@ void TiledDrawingAreaProxy::didSetSize(const IntSize& viewSize)
 
 void TiledDrawingAreaProxy::didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments)
 {
-    switch (messageID.get<DrawingAreaProxyMessage::Kind>()) {
-    case DrawingAreaProxyMessage::TileUpdated: {
+    switch (messageID.get<DrawingAreaProxyLegacyMessage::Kind>()) {
+    case DrawingAreaProxyLegacyMessage::TileUpdated: {
         int tileID;
         UpdateChunk updateChunk;
         float scale;
@@ -138,7 +138,7 @@ void TiledDrawingAreaProxy::didReceiveMessage(CoreIPC::Connection*, CoreIPC::Mes
         tileBufferUpdateComplete();
         break;
     }
-    case DrawingAreaProxyMessage::DidSetSize: {
+    case DrawingAreaProxyLegacyMessage::DidSetSize: {
         IntSize size;
         if (!arguments->decode(CoreIPC::Out(size)))
             return;
@@ -146,7 +146,7 @@ void TiledDrawingAreaProxy::didReceiveMessage(CoreIPC::Connection*, CoreIPC::Mes
         didSetSize(size);
         break;
     }
-    case DrawingAreaProxyMessage::Invalidate: {
+    case DrawingAreaProxyLegacyMessage::Invalidate: {
         IntRect rect;
         if (!arguments->decode(CoreIPC::Out(rect)))
             return;
@@ -154,11 +154,11 @@ void TiledDrawingAreaProxy::didReceiveMessage(CoreIPC::Connection*, CoreIPC::Mes
         invalidate(rect);
         break;
     }
-    case DrawingAreaProxyMessage::AllTileUpdatesProcessed: {
+    case DrawingAreaProxyLegacyMessage::AllTileUpdatesProcessed: {
         tileBufferUpdateComplete();
         break;
     }
-    case DrawingAreaProxyMessage::SnapshotTaken: {
+    case DrawingAreaProxyLegacyMessage::SnapshotTaken: {
         UpdateChunk chunk;
         if (!arguments->decode(CoreIPC::Out(chunk)))
             return;
@@ -177,7 +177,7 @@ void TiledDrawingAreaProxy::didReceiveSyncMessage(CoreIPC::Connection*, CoreIPC:
 
 void TiledDrawingAreaProxy::requestTileUpdate(int tileID, const IntRect& dirtyRect)
 {
-    page()->process()->connection()->send(DrawingAreaMessage::RequestTileUpdate, page()->pageID(), CoreIPC::In(tileID, dirtyRect, contentsScale()));
+    page()->process()->connection()->send(DrawingAreaLegacyMessage::RequestTileUpdate, page()->pageID(), CoreIPC::In(tileID, dirtyRect, contentsScale()));
 }
 
 void TiledDrawingAreaProxy::waitUntilUpdatesComplete()
@@ -188,7 +188,7 @@ void TiledDrawingAreaProxy::waitUntilUpdatesComplete()
         float scale;
         unsigned pendingUpdateCount;
         static const double tileUpdateTimeout = 10.0;
-        OwnPtr<CoreIPC::ArgumentDecoder> arguments = page()->process()->connection()->waitFor(DrawingAreaProxyMessage::TileUpdated, page()->pageID(), tileUpdateTimeout);
+        OwnPtr<CoreIPC::ArgumentDecoder> arguments = page()->process()->connection()->waitFor(DrawingAreaProxyLegacyMessage::TileUpdated, page()->pageID(), tileUpdateTimeout);
         if (!arguments)
             break;
         if (!arguments->decode(CoreIPC::Out(tileID, updateChunk, scale, pendingUpdateCount)))
@@ -232,7 +232,7 @@ void TiledDrawingAreaProxy::setKeepAndCoverAreaMultipliers(const FloatSize& keep
 void TiledDrawingAreaProxy::takeSnapshot(const IntSize& size, const IntRect& contentsRect)
 {
     WebPageProxy* page = this->page();
-    page->process()->send(DrawingAreaMessage::TakeSnapshot, page->pageID(), CoreIPC::Out(size, contentsRect));
+    page->process()->send(DrawingAreaLegacyMessage::TakeSnapshot, page->pageID(), CoreIPC::Out(size, contentsRect));
 }
 
 void TiledDrawingAreaProxy::invalidate(const IntRect& contentsDirtyRect)
@@ -539,7 +539,7 @@ void TiledDrawingAreaProxy::removeTile(const TiledDrawingAreaTile::Coordinate& c
     if (!tile->hasBackBufferUpdatePending())
         return;
     WebPageProxy* page = this->page();
-    page->process()->send(DrawingAreaMessage::CancelTileUpdate, page->pageID(), CoreIPC::In(tile->ID()));
+    page->process()->send(DrawingAreaLegacyMessage::CancelTileUpdate, page->pageID(), CoreIPC::In(tile->ID()));
 }
 
 IntRect TiledDrawingAreaProxy::mapToContents(const IntRect& rect) const
diff --git a/WebKit2/UIProcess/WebPageProxy.cpp b/WebKit2/UIProcess/WebPageProxy.cpp
index dbc9170..c005ec3 100644
--- a/WebKit2/UIProcess/WebPageProxy.cpp
+++ b/WebKit2/UIProcess/WebPageProxy.cpp
@@ -869,7 +869,7 @@ void WebPageProxy::setResizesToContentsUsingLayoutSize(const WebCore::IntSize& t
 
 void WebPageProxy::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments)
 {
-    if (messageID.is<CoreIPC::MessageClassDrawingAreaProxy>()) {
+    if (messageID.is<CoreIPC::MessageClassDrawingAreaProxyLegacy>()) {
         m_drawingArea->didReceiveMessage(connection, messageID, arguments);
         return;
     }
@@ -887,7 +887,7 @@ void WebPageProxy::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::M
 
 void WebPageProxy::didReceiveSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments, CoreIPC::ArgumentEncoder* reply)
 {
-    if (messageID.is<CoreIPC::MessageClassDrawingAreaProxy>()) {
+    if (messageID.is<CoreIPC::MessageClassDrawingAreaProxyLegacy>()) {
         m_drawingArea->didReceiveSyncMessage(connection, messageID, arguments, reply);
         return;
     }
diff --git a/WebKit2/WebProcess/WebPage/ChunkedUpdateDrawingArea.cpp b/WebKit2/WebProcess/WebPage/ChunkedUpdateDrawingArea.cpp
index 309b2e1..1cce5d0 100644
--- a/WebKit2/WebProcess/WebPage/ChunkedUpdateDrawingArea.cpp
+++ b/WebKit2/WebProcess/WebPage/ChunkedUpdateDrawingArea.cpp
@@ -89,7 +89,7 @@ void ChunkedUpdateDrawingArea::display()
     UpdateChunk updateChunk(dirtyRect);
     paintIntoUpdateChunk(&updateChunk);
 
-    WebProcess::shared().connection()->send(DrawingAreaProxyMessage::Update, m_webPage->pageID(), CoreIPC::In(updateChunk));
+    WebProcess::shared().connection()->send(DrawingAreaProxyLegacyMessage::Update, m_webPage->pageID(), CoreIPC::In(updateChunk));
 
     m_isWaitingForUpdate = true;
     m_displayTimer.stop();
@@ -132,7 +132,7 @@ void ChunkedUpdateDrawingArea::setSize(const IntSize& viewSize)
         ASSERT(!m_displayTimer.isActive());
 
         // Painting is suspended, just send back an empty update chunk.
-        WebProcess::shared().connection()->send(DrawingAreaProxyMessage::DidSetSize, m_webPage->pageID(), CoreIPC::In(UpdateChunk()));
+        WebProcess::shared().connection()->send(DrawingAreaProxyLegacyMessage::DidSetSize, m_webPage->pageID(), CoreIPC::In(UpdateChunk()));
         return;
     }
 
@@ -142,7 +142,7 @@ void ChunkedUpdateDrawingArea::setSize(const IntSize& viewSize)
 
     m_displayTimer.stop();
 
-    WebProcess::shared().connection()->send(DrawingAreaProxyMessage::DidSetSize, m_webPage->pageID(), CoreIPC::In(updateChunk));
+    WebProcess::shared().connection()->send(DrawingAreaProxyLegacyMessage::DidSetSize, m_webPage->pageID(), CoreIPC::In(updateChunk));
 }
 
 void ChunkedUpdateDrawingArea::suspendPainting()
@@ -186,8 +186,8 @@ void ChunkedUpdateDrawingArea::didReceiveMessage(CoreIPC::Connection*, CoreIPC::
     if (targetIdentifier != info().identifier)
         return;
 
-    switch (messageID.get<DrawingAreaMessage::Kind>()) {
-        case DrawingAreaMessage::SetSize: {
+    switch (messageID.get<DrawingAreaLegacyMessage::Kind>()) {
+        case DrawingAreaLegacyMessage::SetSize: {
             IntSize size;
             if (!arguments->decode(CoreIPC::Out(size)))
                 return;
@@ -196,11 +196,11 @@ void ChunkedUpdateDrawingArea::didReceiveMessage(CoreIPC::Connection*, CoreIPC::
             break;
         }
         
-        case DrawingAreaMessage::SuspendPainting:
+        case DrawingAreaLegacyMessage::SuspendPainting:
             suspendPainting();
             break;
 
-        case DrawingAreaMessage::ResumePainting: {
+        case DrawingAreaLegacyMessage::ResumePainting: {
             bool forceRepaint;
             if (!arguments->decode(CoreIPC::Out(forceRepaint)))
                 return;
@@ -208,7 +208,7 @@ void ChunkedUpdateDrawingArea::didReceiveMessage(CoreIPC::Connection*, CoreIPC::
             resumePainting(forceRepaint);
             break;
         }
-        case DrawingAreaMessage::DidUpdate:
+        case DrawingAreaLegacyMessage::DidUpdate:
             didUpdate();
             break;
 
diff --git a/WebKit2/WebProcess/WebPage/LayerBackedDrawingArea.cpp b/WebKit2/WebProcess/WebPage/LayerBackedDrawingArea.cpp
index 6bf62af..d367f8e 100644
--- a/WebKit2/WebProcess/WebPage/LayerBackedDrawingArea.cpp
+++ b/WebKit2/WebProcess/WebPage/LayerBackedDrawingArea.cpp
@@ -111,7 +111,7 @@ void LayerBackedDrawingArea::setSize(const IntSize& viewSize)
     if (m_webPage->drawingArea() != this)
         return;
     
-    WebProcess::shared().connection()->send(DrawingAreaProxyMessage::DidSetSize, m_webPage->pageID(), CoreIPC::In(viewSize));
+    WebProcess::shared().connection()->send(DrawingAreaProxyLegacyMessage::DidSetSize, m_webPage->pageID(), CoreIPC::In(viewSize));
 }
 
 void LayerBackedDrawingArea::suspendPainting()
@@ -147,8 +147,8 @@ void LayerBackedDrawingArea::didReceiveMessage(CoreIPC::Connection*, CoreIPC::Me
     if (targetIdentifier != info().identifier)
         return;
 
-    switch (messageID.get<DrawingAreaMessage::Kind>()) {
-        case DrawingAreaMessage::SetSize: {
+    switch (messageID.get<DrawingAreaLegacyMessage::Kind>()) {
+        case DrawingAreaLegacyMessage::SetSize: {
             IntSize size;
             if (!arguments->decode(CoreIPC::Out(size)))
                 return;
@@ -157,15 +157,15 @@ void LayerBackedDrawingArea::didReceiveMessage(CoreIPC::Connection*, CoreIPC::Me
             break;
         }
         
-        case DrawingAreaMessage::SuspendPainting:
+        case DrawingAreaLegacyMessage::SuspendPainting:
             suspendPainting();
             break;
 
-        case DrawingAreaMessage::ResumePainting:
+        case DrawingAreaLegacyMessage::ResumePainting:
             resumePainting();
             break;
 
-        case DrawingAreaMessage::DidUpdate:
+        case DrawingAreaLegacyMessage::DidUpdate:
             didUpdate();
             break;
 
diff --git a/WebKit2/WebProcess/WebPage/TiledDrawingArea.cpp b/WebKit2/WebProcess/WebPage/TiledDrawingArea.cpp
index c0e9d0d..4e58a7e 100644
--- a/WebKit2/WebProcess/WebPage/TiledDrawingArea.cpp
+++ b/WebKit2/WebProcess/WebPage/TiledDrawingArea.cpp
@@ -81,7 +81,7 @@ void TiledDrawingArea::display()
     IntRect dirtyRect = m_dirtyRect;
     m_dirtyRect = IntRect();
 
-    WebProcess::shared().connection()->send(DrawingAreaProxyMessage::Invalidate, m_webPage->pageID(), CoreIPC::In(dirtyRect));
+    WebProcess::shared().connection()->send(DrawingAreaProxyLegacyMessage::Invalidate, m_webPage->pageID(), CoreIPC::In(dirtyRect));
 
     m_displayTimer.stop();
 }
@@ -106,7 +106,7 @@ void TiledDrawingArea::setSize(const IntSize& viewSize)
 
     scheduleDisplay();
 
-    WebProcess::shared().connection()->send(DrawingAreaProxyMessage::DidSetSize, m_webPage->pageID(), CoreIPC::In(viewSize));
+    WebProcess::shared().connection()->send(DrawingAreaProxyLegacyMessage::DidSetSize, m_webPage->pageID(), CoreIPC::In(viewSize));
 }
 
 void TiledDrawingArea::suspendPainting()
@@ -141,7 +141,7 @@ void TiledDrawingArea::updateTile(int tileID, const IntRect& dirtyRect, float sc
     paintIntoUpdateChunk(&updateChunk, scale);
 
     unsigned pendingUpdateCount = m_pendingUpdates.size();
-    WebProcess::shared().connection()->send(DrawingAreaProxyMessage::TileUpdated, m_webPage->pageID(), CoreIPC::In(tileID, updateChunk, scale, pendingUpdateCount));
+    WebProcess::shared().connection()->send(DrawingAreaProxyLegacyMessage::TileUpdated, m_webPage->pageID(), CoreIPC::In(tileID, updateChunk, scale, pendingUpdateCount));
 }
 
 void TiledDrawingArea::tileUpdateTimerFired()
@@ -155,15 +155,15 @@ void TiledDrawingArea::tileUpdateTimerFired()
     updateTile(update.tileID, update.dirtyRect, update.scale);
 
     if (m_pendingUpdates.isEmpty())
-        WebProcess::shared().connection()->send(DrawingAreaProxyMessage::AllTileUpdatesProcessed, m_webPage->pageID(), CoreIPC::In());
+        WebProcess::shared().connection()->send(DrawingAreaProxyLegacyMessage::AllTileUpdatesProcessed, m_webPage->pageID(), CoreIPC::In());
     else
         m_tileUpdateTimer.startOneShot(0.001);
 }
 
 void TiledDrawingArea::didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments)
 {
-    switch (messageID.get<DrawingAreaMessage::Kind>()) {
-    case DrawingAreaMessage::SetSize: {
+    switch (messageID.get<DrawingAreaLegacyMessage::Kind>()) {
+    case DrawingAreaLegacyMessage::SetSize: {
         IntSize size;
         if (!arguments->decode(CoreIPC::Out(size)))
             return;
@@ -171,13 +171,13 @@ void TiledDrawingArea::didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageI
         setSize(size);
         break;
     }
-    case DrawingAreaMessage::SuspendPainting:
+    case DrawingAreaLegacyMessage::SuspendPainting:
         suspendPainting();
         break;
-    case DrawingAreaMessage::ResumePainting:
+    case DrawingAreaLegacyMessage::ResumePainting:
         resumePainting();
         break;
-    case DrawingAreaMessage::CancelTileUpdate: {
+    case DrawingAreaLegacyMessage::CancelTileUpdate: {
         int tileID;
         if (!arguments->decode(CoreIPC::Out(tileID)))
             return;
@@ -185,13 +185,13 @@ void TiledDrawingArea::didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageI
         if (it != m_pendingUpdates.end()) {
             m_pendingUpdates.remove(it);
             if (m_pendingUpdates.isEmpty()) {
-                WebProcess::shared().connection()->send(DrawingAreaProxyMessage::AllTileUpdatesProcessed, m_webPage->pageID(), CoreIPC::In());
+                WebProcess::shared().connection()->send(DrawingAreaProxyLegacyMessage::AllTileUpdatesProcessed, m_webPage->pageID(), CoreIPC::In());
                 m_tileUpdateTimer.stop();
             }
         }
         break;
     }
-    case DrawingAreaMessage::RequestTileUpdate: {
+    case DrawingAreaLegacyMessage::RequestTileUpdate: {
         TileUpdate update;
         if (!arguments->decode(CoreIPC::Out(update.tileID, update.dirtyRect, update.scale)))
             return;
@@ -205,7 +205,7 @@ void TiledDrawingArea::didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageI
         }
         break;
     }
-    case DrawingAreaMessage::TakeSnapshot: {
+    case DrawingAreaLegacyMessage::TakeSnapshot: {
         IntSize targetSize;
         IntRect contentsRect;
 
@@ -221,7 +221,7 @@ void TiledDrawingArea::didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageI
         UpdateChunk updateChunk(IntRect(IntPoint(contentsRect.x() * targetScale, contentsRect.y() * targetScale), targetSize));
         paintIntoUpdateChunk(&updateChunk, targetScale);
 
-        WebProcess::shared().connection()->send(DrawingAreaProxyMessage::SnapshotTaken, m_webPage->pageID(), CoreIPC::In(updateChunk));
+        WebProcess::shared().connection()->send(DrawingAreaProxyLegacyMessage::SnapshotTaken, m_webPage->pageID(), CoreIPC::In(updateChunk));
         break;
     }
     default:
diff --git a/WebKit2/WebProcess/WebPage/WebPage.cpp b/WebKit2/WebProcess/WebPage/WebPage.cpp
index c55a32e..4df97f1 100644
--- a/WebKit2/WebProcess/WebPage/WebPage.cpp
+++ b/WebKit2/WebProcess/WebPage/WebPage.cpp
@@ -1281,7 +1281,7 @@ bool WebPage::windowIsFocused() const
 
 void WebPage::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments)
 {
-    if (messageID.is<CoreIPC::MessageClassDrawingArea>()) {
+    if (messageID.is<CoreIPC::MessageClassDrawingAreaLegacy>()) {
         if (m_drawingArea)
             m_drawingArea->didReceiveMessage(connection, messageID, arguments);
         return;
diff --git a/WebKit2/WebProcess/WebPage/mac/LayerBackedDrawingAreaMac.mm b/WebKit2/WebProcess/WebPage/mac/LayerBackedDrawingAreaMac.mm
index 1a6b0f1..f8b7e71 100644
--- a/WebKit2/WebProcess/WebPage/mac/LayerBackedDrawingAreaMac.mm
+++ b/WebKit2/WebProcess/WebPage/mac/LayerBackedDrawingAreaMac.mm
@@ -83,7 +83,7 @@ void LayerBackedDrawingArea::attachCompositingContext()
     WKCARemoteLayerClientSetLayer(m_remoteLayerRef.get(), m_backingLayer->platformLayer());
     
     uint32_t contextID = WKCARemoteLayerClientGetClientId(m_remoteLayerRef.get());
-    WebProcess::shared().connection()->sendSync(DrawingAreaProxyMessage::AttachCompositingContext, m_webPage->pageID(), CoreIPC::In(contextID), CoreIPC::Out());
+    WebProcess::shared().connection()->sendSync(DrawingAreaProxyLegacyMessage::AttachCompositingContext, m_webPage->pageID(), CoreIPC::In(contextID), CoreIPC::Out());
 #endif
 }
 

-- 
WebKit Debian packaging



More information about the Pkg-webkit-commits mailing list