Transfer canvas state to the next frame with noticable restrictions.

Source/platform/graphics/RecordingImageBufferSurface.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 
 #include "platform/graphics/RecordingImageBufferSurface.h"
 
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/ImageBuffer.h"
@@ skipping 100 matching lines @@
 
 void RecordingImageBufferSurface::didClearCanvas()
 {
     m_frameWasCleared = true;
 }
 
 bool RecordingImageBufferSurface::finalizeFrameInternal()
 {
     if (!m_imageBuffer->isDirty()) {
         if (m_currentFrame && !m_previousFrame) {
-            // Create an initial blank frame
             m_previousFrame = adoptRef(m_currentFrame->endRecording());
             initializeCurrentFrame();
         }
         return m_currentFrame;
     }
 
     if (!m_currentFrame) {
         return false;
     }
 
     IntRect canvasRect(IntPoint(0, 0), size());
     if (!m_frameWasCleared && !m_imageBuffer->context()->opaqueRegion().asRect().contains(canvasRect)) {
         return false;
     }
 
-    SkCanvas* oldCanvas = m_currentFrame->getRecordingCanvas(); // Could be raster or picture
+    StateStack stateStack;
 
-    // FIXME(crbug.com/392614): handle transferring complex state from the current picture to the new one.
-    if (oldCanvas->getSaveCount() > m_initialSaveCount)
+    if (!saveState(m_currentFrame->getRecordingCanvas(), &stateStack))

[zino, 2014/09/03 10:50:17]

How does it work in the following cases?
 - display list mode -> fallback mode
 - fallback mode -> display list mode

I'm not sure but I think you should apply this to m_rasterCanvas in
fallBackToRasterCanvas().

@junov, what do you think?

[Sergey, 2014/09/04 10:26:50]

First, right now there is no "fallback mode -> display list mode" option.

Second, as I understand it, transferring state of the canvas during "display
list mode -> fallback mode" is done, when we replay all the operations from
recording canvas into raster canvas. See function
RecordingImageBufferSurface::fallBackToRasterCanvas, lines 67 and 72.
@Junov, please, correct me, if I am wrong here.

         return false;
 
-    if (!oldCanvas->isClipRect())
-        return false;
-
-    SkMatrix ctm = oldCanvas->getTotalMatrix();
-    SkRect clip;
-    oldCanvas->getClipBounds(&clip);
-
     m_previousFrame = adoptRef(m_currentFrame->endRecording());
     initializeCurrentFrame();
 
-    SkCanvas* newCanvas = m_currentFrame->getRecordingCanvas();
-    newCanvas->concat(ctm);
-    newCanvas->clipRect(clip);
+    setCurrentState(m_currentFrame->getRecordingCanvas(), &stateStack);

[zino, 2014/09/03 10:50:17]

ditto

[Sergey, 2014/09/04 10:26:50]

It is not required at this point, as we are not going to fallback from here. The
idea is to identify our ability to transfer state at your previous comment point
and return from this function, saying that we were unable to finalize frame.
This will trigger a fallback to rasterizing canvas on main thread.

 
     m_frameWasCleared = false;
     return true;
 }
 
+bool RecordingImageBufferSurface::saveState(SkCanvas* srcCanvas, StateStack* stateStack)
+{
+    // FIXME(crbug.com/392614): handle transferring complex state from the current picture to the new one:
+    // - non-rectangular clip
+    // - non-invertible clip
+    if (!srcCanvas->isClipRect())
+        return false;
+
+    StateRec state;
+
+    // we will remove all the saved state stack in endRecording anyway, so it makes no difference
+    while (srcCanvas->getSaveCount() > m_initialSaveCount) {
+        state.m_ctm = srcCanvas->getTotalMatrix();
+        srcCanvas->getClipBounds(&state.m_clip);

[zino, 2014/09/03 10:50:17]

I think you should use getClipDeviceBounds() instead of getClipBounds().
getClipDeviceBounds() uses SkIRect instead of SkRect.

usage: Please refer to GraphicsContext::getTransformedClipBounds()

[Justin Novosad, 2014/09/03 15:24:39]

This is a good point. Using getDeviceClipBounds saves a matrix inversion. At the
other end, in setCurrentState you will have to apply the clip in device space
though.  You can do that by setting ctm to identity, set the clip, then
setMatrix.

[Sergey, 2014/09/11 12:58:52]

Probably not required here at all.

+        stateStack->append(state);
+        srcCanvas->restore();
+        // FIXME(crbug.com/408392): don't mess up the state in case we will have to fallback
+        if (!srcCanvas->isClipRect())
+            return false;
+    }
+
+    state.m_ctm = srcCanvas->getTotalMatrix();
+    srcCanvas->getClipBounds(&state.m_clip);
+    stateStack->append(state);
+
+    return true;
+}
+
+void RecordingImageBufferSurface::setCurrentState(SkCanvas* dstCanvas, StateStack* stateStack)
+{
+    while (stateStack->size() > 1) {
+        dstCanvas->setMatrix(stateStack->last().m_ctm);
+        dstCanvas->clipRect(stateStack->last().m_clip);
+        dstCanvas->save();
+        stateStack->removeLast();
+    }
+
+    dstCanvas->setMatrix(stateStack->last().m_ctm);
+    dstCanvas->clipRect(stateStack->last().m_clip);
+}
+
 } // namespace blink