Rename DrawingArea[Proxy]Impl's "sequence number" concept to "state ID".
authoraroben@apple.com <aroben@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 21 Feb 2011 23:20:35 +0000 (23:20 +0000)
committeraroben@apple.com <aroben@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 21 Feb 2011 23:20:35 +0000 (23:20 +0000)
As explained in r79251, DrawingAreaProxyImpl has some state that, when it changes, causes
all operations performed before that state change to become invalid. Currently, this state
consists of a single piece of data: the view's size. Eventually it will encompass more data
(e.g., the backing store we're drawing into; when we start throwing away the backing store
to save memory, our state will have changed, and any operations that were intended for the
old backing store will have become invalid). r79251 effectively transformed
DrawingArea[Proxy]Impl's "sequence number," which incremented every time DrawingAreaImpl
sent DrawingAreaProxyImpl a message, to a "state ID," which only increments when the view's
size changes.

This patch is just a set of simple renames to reflect the transformation that r79251
effected. It should not introduce any changes in behavior. The renames are:
  - Messages::DrawingArea::SetSize -> UpdateState
  - Messages::DrawingAreaProxy::DidSetSize -> DidUpdateState
  - DrawingAreaProxyImpl::m_lastDidSetSizeSequenceNumber -> m_currentStateID
  - DrawingAreaProxyImpl::m_isWaitingForDidSetSize -> m_isWaitingForDidUpdateState
  - DrawingAreaProxyImpl::waitForAndDispatchDidSetSize -> waitForAndDispatchDidUpdateState
  - DrawingAreaImpl::m_inSetSize -> m_inUpdateState
  - generateSequenceNumber -> generateStateID
  - sequenceNumber -> stateID

Fixes <http://webkit.org/b/54911> DrawingArea[Proxy]Impl's "sequence number" concept should
be renamed to "state ID"

Reviewed by Anders Carlsson.

* UIProcess/DrawingAreaProxy.h:
* UIProcess/DrawingAreaProxy.messages.in:
* UIProcess/DrawingAreaProxyImpl.cpp:
* UIProcess/DrawingAreaProxyImpl.h:
* WebProcess/WebPage/DrawingArea.h:
* WebProcess/WebPage/DrawingArea.messages.in:
* WebProcess/WebPage/DrawingAreaImpl.cpp:
* WebProcess/WebPage/DrawingAreaImpl.h:
Performed the renames described above.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@79254 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Source/WebKit2/ChangeLog
Source/WebKit2/UIProcess/DrawingAreaProxy.h
Source/WebKit2/UIProcess/DrawingAreaProxy.messages.in
Source/WebKit2/UIProcess/DrawingAreaProxyImpl.cpp
Source/WebKit2/UIProcess/DrawingAreaProxyImpl.h
Source/WebKit2/WebProcess/WebPage/DrawingArea.h
Source/WebKit2/WebProcess/WebPage/DrawingArea.messages.in
Source/WebKit2/WebProcess/WebPage/DrawingAreaImpl.cpp
Source/WebKit2/WebProcess/WebPage/DrawingAreaImpl.h

index a5d4d44..0083f91 100644 (file)
@@ -1,3 +1,43 @@
+2011-02-21  Adam Roben  <aroben@apple.com>
+
+        Rename DrawingArea[Proxy]Impl's "sequence number" concept to "state ID".
+
+        As explained in r79251, DrawingAreaProxyImpl has some state that, when it changes, causes
+        all operations performed before that state change to become invalid. Currently, this state
+        consists of a single piece of data: the view's size. Eventually it will encompass more data
+        (e.g., the backing store we're drawing into; when we start throwing away the backing store
+        to save memory, our state will have changed, and any operations that were intended for the
+        old backing store will have become invalid). r79251 effectively transformed
+        DrawingArea[Proxy]Impl's "sequence number," which incremented every time DrawingAreaImpl
+        sent DrawingAreaProxyImpl a message, to a "state ID," which only increments when the view's
+        size changes.
+
+        This patch is just a set of simple renames to reflect the transformation that r79251
+        effected. It should not introduce any changes in behavior. The renames are:
+          - Messages::DrawingArea::SetSize -> UpdateState
+          - Messages::DrawingAreaProxy::DidSetSize -> DidUpdateState
+          - DrawingAreaProxyImpl::m_lastDidSetSizeSequenceNumber -> m_currentStateID
+          - DrawingAreaProxyImpl::m_isWaitingForDidSetSize -> m_isWaitingForDidUpdateState
+          - DrawingAreaProxyImpl::waitForAndDispatchDidSetSize -> waitForAndDispatchDidUpdateState
+          - DrawingAreaImpl::m_inSetSize -> m_inUpdateState
+          - generateSequenceNumber -> generateStateID
+          - sequenceNumber -> stateID
+
+        Fixes <http://webkit.org/b/54911> DrawingArea[Proxy]Impl's "sequence number" concept should
+        be renamed to "state ID"
+
+        Reviewed by Anders Carlsson.
+
+        * UIProcess/DrawingAreaProxy.h:
+        * UIProcess/DrawingAreaProxy.messages.in:
+        * UIProcess/DrawingAreaProxyImpl.cpp:
+        * UIProcess/DrawingAreaProxyImpl.h:
+        * WebProcess/WebPage/DrawingArea.h:
+        * WebProcess/WebPage/DrawingArea.messages.in:
+        * WebProcess/WebPage/DrawingAreaImpl.cpp:
+        * WebProcess/WebPage/DrawingAreaImpl.h:
+        Performed the renames described above.
+
 2011-02-21  Alexey Proskuryakov  <ap@apple.com>
 
         Reviewed by Adam Roben.
index f802241..fa372e8 100644 (file)
@@ -99,11 +99,11 @@ protected:
 private:
     // CoreIPC message handlers.
     // FIXME: These should be pure virtual.
-    virtual void update(uint64_t sequenceNumber, const UpdateInfo&) { }
-    virtual void didSetSize(uint64_t sequenceNumber, const UpdateInfo&, const LayerTreeContext&) { }
+    virtual void update(uint64_t stateID, const UpdateInfo&) { }
+    virtual void didUpdateState(uint64_t stateID, const UpdateInfo&, const LayerTreeContext&) { }
 #if USE(ACCELERATED_COMPOSITING)
-    virtual void enterAcceleratedCompositingMode(uint64_t sequenceNumber, const LayerTreeContext&) { }
-    virtual void exitAcceleratedCompositingMode(uint64_t sequenceNumber, const UpdateInfo&) { }
+    virtual void enterAcceleratedCompositingMode(uint64_t stateID, const LayerTreeContext&) { }
+    virtual void exitAcceleratedCompositingMode(uint64_t stateID, const UpdateInfo&) { }
 #endif
 };
 
index a2b5e26..3b95af9 100644 (file)
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 messages -> DrawingAreaProxy {
-    Update(uint64_t sequenceNumber, WebKit::UpdateInfo updateInfo)
-    DidSetSize(uint64_t sequenceNumber, WebKit::UpdateInfo updateInfo, WebKit::LayerTreeContext context)
+    Update(uint64_t stateID, WebKit::UpdateInfo updateInfo)
+    DidUpdateState(uint64_t stateID, WebKit::UpdateInfo updateInfo, WebKit::LayerTreeContext context)
 
 #if USE(ACCELERATED_COMPOSITING)
-    EnterAcceleratedCompositingMode(uint64_t sequenceNumber, WebKit::LayerTreeContext context)
-    ExitAcceleratedCompositingMode(uint64_t sequenceNumber, WebKit::UpdateInfo updateInfo)
+    EnterAcceleratedCompositingMode(uint64_t stateID, WebKit::LayerTreeContext context)
+    ExitAcceleratedCompositingMode(uint64_t stateID, WebKit::UpdateInfo updateInfo)
 #endif
 }
index d93eb09..7c2605e 100644 (file)
@@ -42,10 +42,10 @@ using namespace WebCore;
 
 namespace WebKit {
 
-static uint64_t generateSequenceNumber()
+static uint64_t generateStateID()
 {
-    static uint64_t sequenceNumber;
-    return ++sequenceNumber;
+    static uint64_t stateID;
+    return ++stateID;
 }
 
 PassOwnPtr<DrawingAreaProxyImpl> DrawingAreaProxyImpl::create(WebPageProxy* webPageProxy)
@@ -55,8 +55,8 @@ PassOwnPtr<DrawingAreaProxyImpl> DrawingAreaProxyImpl::create(WebPageProxy* webP
 
 DrawingAreaProxyImpl::DrawingAreaProxyImpl(WebPageProxy* webPageProxy)
     : DrawingAreaProxy(DrawingAreaInfo::Impl, webPageProxy)
-    , m_isWaitingForDidSetSize(false)
-    , m_lastDidSetSizeSequenceNumber(0)
+    , m_isWaitingForDidUpdateState(false)
+    , m_currentStateID(0)
 {
 }
 
@@ -76,12 +76,12 @@ void DrawingAreaProxyImpl::paint(BackingStore::PlatformGraphicsContext context,
 
     ASSERT(!isInAcceleratedCompositingMode());
 
-    if (m_isWaitingForDidSetSize) {
-        // Wait for a DidSetSize message that contains the new bits before we paint
+    if (m_isWaitingForDidUpdateState) {
+        // Wait for a DidUpdateState message that contains the new bits before we paint
         // what's currently in the backing store.
-        waitForAndDispatchDidSetSize();
+        waitForAndDispatchDidUpdateState();
 
-        // Dispatching DidSetSize could destroy our backing store or change the compositing mode.
+        // Dispatching DidUpdateState could destroy our backing store or change the compositing mode.
         if (!m_backingStore || isInAcceleratedCompositingMode())
             return;
     }
@@ -108,7 +108,7 @@ bool DrawingAreaProxyImpl::paint(const WebCore::IntRect&, PlatformDrawingContext
 
 void DrawingAreaProxyImpl::sizeDidChange()
 {
-    sendSetSize();
+    sendUpdateState();
 }
 
 void DrawingAreaProxyImpl::visibilityDidChange()
@@ -137,9 +137,9 @@ void DrawingAreaProxyImpl::detachCompositingContext()
     ASSERT_NOT_REACHED();
 }
 
-void DrawingAreaProxyImpl::update(uint64_t sequenceNumber, const UpdateInfo& updateInfo)
+void DrawingAreaProxyImpl::update(uint64_t stateID, const UpdateInfo& updateInfo)
 {
-    if (sequenceNumber < m_lastDidSetSizeSequenceNumber)
+    if (stateID < m_currentStateID)
         return;
 
     // FIXME: Handle the case where the view is hidden.
@@ -148,16 +148,16 @@ void DrawingAreaProxyImpl::update(uint64_t sequenceNumber, const UpdateInfo& upd
     m_webPageProxy->process()->send(Messages::DrawingArea::DidUpdate(), m_webPageProxy->pageID());
 }
 
-void DrawingAreaProxyImpl::didSetSize(uint64_t sequenceNumber, const UpdateInfo& updateInfo, const LayerTreeContext& layerTreeContext)
+void DrawingAreaProxyImpl::didUpdateState(uint64_t stateID, const UpdateInfo& updateInfo, const LayerTreeContext& layerTreeContext)
 {
-    ASSERT(sequenceNumber > m_lastDidSetSizeSequenceNumber);
-    m_lastDidSetSizeSequenceNumber = sequenceNumber;
+    ASSERT(stateID > m_currentStateID);
+    m_currentStateID = stateID;
 
-    ASSERT(m_isWaitingForDidSetSize);
-    m_isWaitingForDidSetSize = false;
+    ASSERT(m_isWaitingForDidUpdateState);
+    m_isWaitingForDidUpdateState = false;
 
     if (m_size != updateInfo.viewSize)
-        sendSetSize();
+        sendUpdateState();
 
     if (layerTreeContext != m_layerTreeContext) {
         if (!m_layerTreeContext.isEmpty()) {
@@ -180,17 +180,17 @@ void DrawingAreaProxyImpl::didSetSize(uint64_t sequenceNumber, const UpdateInfo&
     incorporateUpdate(updateInfo);
 }
 
-void DrawingAreaProxyImpl::enterAcceleratedCompositingMode(uint64_t sequenceNumber, const LayerTreeContext& layerTreeContext)
+void DrawingAreaProxyImpl::enterAcceleratedCompositingMode(uint64_t stateID, const LayerTreeContext& layerTreeContext)
 {
-    if (sequenceNumber < m_lastDidSetSizeSequenceNumber)
+    if (stateID < m_currentStateID)
         return;
 
     enterAcceleratedCompositingMode(layerTreeContext);
 }
 
-void DrawingAreaProxyImpl::exitAcceleratedCompositingMode(uint64_t sequenceNumber, const UpdateInfo& updateInfo)
+void DrawingAreaProxyImpl::exitAcceleratedCompositingMode(uint64_t stateID, const UpdateInfo& updateInfo)
 {
-    if (sequenceNumber < m_lastDidSetSizeSequenceNumber)
+    if (stateID < m_currentStateID)
         return;
 
     exitAcceleratedCompositingMode();
@@ -225,42 +225,42 @@ void DrawingAreaProxyImpl::incorporateUpdate(const UpdateInfo& updateInfo)
         m_webPageProxy->displayView();
 }
 
-void DrawingAreaProxyImpl::sendSetSize()
+void DrawingAreaProxyImpl::sendUpdateState()
 {
     if (!m_webPageProxy->isValid())
         return;
 
-    if (m_isWaitingForDidSetSize)
+    if (m_isWaitingForDidUpdateState)
         return;
 
-    m_isWaitingForDidSetSize = true;
-    m_webPageProxy->process()->send(Messages::DrawingArea::SetSize(generateSequenceNumber(), m_size, m_scrollOffset), m_webPageProxy->pageID());
+    m_isWaitingForDidUpdateState = true;
+    m_webPageProxy->process()->send(Messages::DrawingArea::UpdateState(generateStateID(), m_size, m_scrollOffset), m_webPageProxy->pageID());
     m_scrollOffset = IntSize();
 
     if (!m_layerTreeContext.isEmpty()) {
-        // Wait for the DidSetSize message. Normally we don this in DrawingAreaProxyImpl::paint, but that
+        // Wait for the DidUpdateState message. Normally we don this in DrawingAreaProxyImpl::paint, but that
         // function is never called when in accelerated compositing mode.
-        waitForAndDispatchDidSetSize();
+        waitForAndDispatchDidUpdateState();
     }
 }
 
-void DrawingAreaProxyImpl::waitForAndDispatchDidSetSize()
+void DrawingAreaProxyImpl::waitForAndDispatchDidUpdateState()
 {
-    ASSERT(m_isWaitingForDidSetSize);
+    ASSERT(m_isWaitingForDidUpdateState);
 
     if (!m_webPageProxy->isValid())
         return;
     if (m_webPageProxy->process()->isLaunching())
         return;
     
-    // FIXME: waitForAndDispatchImmediately will always return the oldest DidSetSize message that
-    // hasn't yet been processed. But it might be better to skip ahead to some other DidSetSize
-    // message, if multiple DidSetSize messages are waiting to be processed. For instance, we could
+    // FIXME: waitForAndDispatchImmediately will always return the oldest DidUpdateState message that
+    // hasn't yet been processed. But it might be better to skip ahead to some other DidUpdateState
+    // message, if multiple DidUpdateState messages are waiting to be processed. For instance, we could
     // choose the most recent one, or the one that is closest to our current size.
 
-    // The timeout, in seconds, we use when waiting for a DidSetSize message when we're asked to paint.
-    static const double didSetSizeTimeout = 0.5;
-    m_webPageProxy->process()->connection()->waitForAndDispatchImmediately<Messages::DrawingAreaProxy::DidSetSize>(m_webPageProxy->pageID(), didSetSizeTimeout);
+    // The timeout, in seconds, we use when waiting for a DidUpdateState message when we're asked to paint.
+    static const double didUpdateStateTimeout = 0.5;
+    m_webPageProxy->process()->connection()->waitForAndDispatchImmediately<Messages::DrawingAreaProxy::DidUpdateState>(m_webPageProxy->pageID(), didUpdateStateTimeout);
 }
 
 void DrawingAreaProxyImpl::enterAcceleratedCompositingMode(const LayerTreeContext& layerTreeContext)
index f776b09..379d74a 100644 (file)
@@ -55,14 +55,14 @@ private:
     virtual void detachCompositingContext();
 
     // CoreIPC message handlers
-    virtual void update(uint64_t sequenceNumber, const UpdateInfo&);
-    virtual void didSetSize(uint64_t sequenceNumber, const UpdateInfo&, const LayerTreeContext&);
-    virtual void enterAcceleratedCompositingMode(uint64_t sequenceNumber, const LayerTreeContext&);
-    virtual void exitAcceleratedCompositingMode(uint64_t sequenceNumber, const UpdateInfo&);
+    virtual void update(uint64_t stateID, const UpdateInfo&);
+    virtual void didUpdateState(uint64_t stateID, const UpdateInfo&, const LayerTreeContext&);
+    virtual void enterAcceleratedCompositingMode(uint64_t stateID, const LayerTreeContext&);
+    virtual void exitAcceleratedCompositingMode(uint64_t stateID, const UpdateInfo&);
 
     void incorporateUpdate(const UpdateInfo&);
-    void sendSetSize();
-    void waitForAndDispatchDidSetSize();
+    void sendUpdateState();
+    void waitForAndDispatchDidUpdateState();
 
     void enterAcceleratedCompositingMode(const LayerTreeContext&);
     void exitAcceleratedCompositingMode();
@@ -72,12 +72,12 @@ private:
     // The current layer tree context.
     LayerTreeContext m_layerTreeContext;
     
-    // Whether we've sent a SetSize message and are now waiting for a DidSetSize message.
-    // Used to throttle SetSize messages so we don't send them faster than the Web process can handle.
-    bool m_isWaitingForDidSetSize;
+    // Whether we've sent a UpdateState message and are now waiting for a DidUpdateState message.
+    // Used to throttle UpdateState messages so we don't send them faster than the Web process can handle.
+    bool m_isWaitingForDidUpdateState;
 
-    // The sequence number of the last DidSetSize message
-    uint64_t m_lastDidSetSizeSequenceNumber;
+    // The state ID of the last DidUpdateState message
+    uint64_t m_currentStateID;
 
     OwnPtr<BackingStore> m_backingStore;
 };
index 686725e..44f75f7 100644 (file)
@@ -85,7 +85,7 @@ protected:
 private:
     // CoreIPC message handlers.
     // FIXME: These should be pure virtual.
-    virtual void setSize(uint64_t sequenceNumber, const WebCore::IntSize& size, const WebCore::IntSize& scrollOffset) { }
+    virtual void updateState(uint64_t stateID, const WebCore::IntSize& size, const WebCore::IntSize& scrollOffset) { }
     virtual void didUpdate() { }
     virtual void suspendPainting() { }
     virtual void resumePainting() { }
index 21d1bfb..6804606 100644 (file)
@@ -21,7 +21,7 @@
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 messages -> DrawingArea {
-    SetSize(uint64_t sequenceNumber, WebCore::IntSize size, WebCore::IntSize scrollOffset)
+    UpdateState(uint64_t stateID, WebCore::IntSize size, WebCore::IntSize scrollOffset)
     DidUpdate()
     SuspendPainting()
     ResumePainting()
index 3397189..ec5f2ec 100644 (file)
@@ -58,8 +58,8 @@ DrawingAreaImpl::~DrawingAreaImpl()
 
 DrawingAreaImpl::DrawingAreaImpl(WebPage* webPage, const WebPageCreationParameters& parameters)
     : DrawingArea(DrawingAreaInfo::Impl, parameters.drawingAreaInfo.identifier, webPage)
-    , m_sequenceNumber(0)
-    , m_inSetSize(false)
+    , m_stateID(0)
+    , m_inUpdateState(false)
     , m_isWaitingForDidUpdate(false)
     , m_isPaintingSuspended(!parameters.isVisible)
     , m_alwaysUseCompositing(false)
@@ -189,7 +189,7 @@ void DrawingAreaImpl::layerHostDidFlushLayers()
     if (!m_layerTreeHost)
         return;
 
-    m_webPage->send(Messages::DrawingAreaProxy::EnterAcceleratedCompositingMode(m_sequenceNumber, m_layerTreeHost->layerTreeContext()));
+    m_webPage->send(Messages::DrawingAreaProxy::EnterAcceleratedCompositingMode(m_stateID, m_layerTreeHost->layerTreeContext()));
 }
 
 void DrawingAreaImpl::attachCompositingContext()
@@ -219,7 +219,7 @@ void DrawingAreaImpl::setRootCompositingLayer(GraphicsLayer* graphicsLayer)
                 // compositing code via display() and layout.
                 // If we're leaving compositing mode because of a setSize, it is safe to
                 // exit accelerated compositing mode right away.
-                if (m_inSetSize)
+                if (m_inUpdateState)
                     exitAcceleratedCompositingMode();
                 else
                     exitAcceleratedCompositingModeSoon();
@@ -243,13 +243,13 @@ void DrawingAreaImpl::didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID
 {
 }
 
-void DrawingAreaImpl::setSize(uint64_t sequenceNumber, const WebCore::IntSize& size, const WebCore::IntSize& scrollOffset)
+void DrawingAreaImpl::updateState(uint64_t stateID, const WebCore::IntSize& size, const WebCore::IntSize& scrollOffset)
 {
-    ASSERT(!m_inSetSize);
-    m_inSetSize = true;
+    ASSERT(!m_inUpdateState);
+    m_inUpdateState = true;
 
-    ASSERT_ARG(sequenceNumber, sequenceNumber > m_sequenceNumber);
-    m_sequenceNumber = sequenceNumber;
+    ASSERT_ARG(stateID, stateID > m_stateID);
+    m_stateID = stateID;
 
     // Set this to false since we're about to call display().
     m_isWaitingForDidUpdate = false;
@@ -276,9 +276,9 @@ void DrawingAreaImpl::setSize(uint64_t sequenceNumber, const WebCore::IntSize& s
         ASSERT(!m_layerTreeHost);
     }
 
-    m_webPage->send(Messages::DrawingAreaProxy::DidSetSize(m_sequenceNumber, updateInfo, layerTreeContext));
+    m_webPage->send(Messages::DrawingAreaProxy::DidUpdateState(m_stateID, updateInfo, layerTreeContext));
 
-    m_inSetSize = false;
+    m_inUpdateState = false;
 }
 
 void DrawingAreaImpl::didUpdate()
@@ -319,7 +319,7 @@ void DrawingAreaImpl::enterAcceleratedCompositingMode(GraphicsLayer* graphicsLay
     ASSERT(!m_layerTreeHost);
 
     m_layerTreeHost = LayerTreeHost::create(m_webPage);
-    if (!m_inSetSize)
+    if (!m_inUpdateState)
         m_layerTreeHost->setShouldNotifyAfterNextScheduledLayerFlush();
 
     m_layerTreeHost->setRootCompositingLayer(graphicsLayer);
@@ -344,7 +344,7 @@ void DrawingAreaImpl::exitAcceleratedCompositingMode()
     m_layerTreeHost->invalidate();
     m_layerTreeHost = nullptr;
 
-    if (m_inSetSize)
+    if (m_inUpdateState)
         return;
 
     UpdateInfo updateInfo;
@@ -357,8 +357,8 @@ void DrawingAreaImpl::exitAcceleratedCompositingMode()
 
     // Send along a complete update of the page so we can paint the contents right after we exit the
     // accelerated compositing mode, eliminiating flicker.
-    if (!m_inSetSize)
-        m_webPage->send(Messages::DrawingAreaProxy::ExitAcceleratedCompositingMode(m_sequenceNumber, updateInfo));
+    if (!m_inUpdateState)
+        m_webPage->send(Messages::DrawingAreaProxy::ExitAcceleratedCompositingMode(m_stateID, updateInfo));
 }
 
 void DrawingAreaImpl::exitAcceleratedCompositingModeSoon()
@@ -406,7 +406,7 @@ void DrawingAreaImpl::display()
         return;
     }
 
-    m_webPage->send(Messages::DrawingAreaProxy::Update(m_sequenceNumber, updateInfo));
+    m_webPage->send(Messages::DrawingAreaProxy::Update(m_stateID, updateInfo));
     m_isWaitingForDidUpdate = true;
 }
 
index 2625d7e..7a0d536 100644 (file)
@@ -62,7 +62,7 @@ private:
     virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*);
 
     // CoreIPC message handlers.
-    virtual void setSize(uint64_t sequenceNumber, const WebCore::IntSize&, const WebCore::IntSize& scrollOffset);
+    virtual void updateState(uint64_t stateID, const WebCore::IntSize&, const WebCore::IntSize& scrollOffset);
     virtual void didUpdate();
     virtual void suspendPainting();
     virtual void resumePainting();
@@ -75,14 +75,14 @@ private:
     void display();
     void display(UpdateInfo&);
 
-    uint64_t m_sequenceNumber;
+    uint64_t m_stateID;
 
     Region m_dirtyRegion;
     WebCore::IntRect m_scrollRect;
     WebCore::IntSize m_scrollOffset;
 
     // Whether we're currently processing a setSize message.
-    bool m_inSetSize;
+    bool m_inUpdateState;
 
     // Whether we're waiting for a DidUpdate message. Used for throttling paints so that the 
     // web process won't paint more frequent than the UI process can handle.