Remove GraphicsContext's deferred save mechanism.

Source/platform/graphics/GraphicsContext.cpp

 /*
  * Copyright (C) 2003, 2004, 2005, 2006, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 43 matching lines @@
 #include "third_party/skia/include/effects/SkLumaColorFilter.h"
 #include "third_party/skia/include/effects/SkMatrixImageFilter.h"
 #include "third_party/skia/include/effects/SkPictureImageFilter.h"
 #include "third_party/skia/include/gpu/GrRenderTarget.h"
 #include "third_party/skia/include/gpu/GrTexture.h"
 #include "wtf/Assertions.h"
 #include "wtf/MathExtras.h"
 
 namespace blink {
 
-struct GraphicsContext::CanvasSaveState {
-    CanvasSaveState(bool pendingSave, int count)
-        : m_pendingSave(pendingSave), m_restoreCount(count) { }
-
-    bool m_pendingSave;
-    int m_restoreCount;
-};
-
 struct GraphicsContext::RecordingState {
     RecordingState(SkPictureRecorder* recorder, SkCanvas* currentCanvas, const SkMatrix& currentMatrix, bool currentShouldSmoothFonts,
         PassRefPtr<DisplayList> displayList, RegionTrackingMode trackingMode)
         : m_displayList(displayList)
         , m_recorder(recorder)
         , m_savedCanvas(currentCanvas)
         , m_savedMatrix(currentMatrix)
         , m_savedShouldSmoothFonts(currentShouldSmoothFonts)
         , m_regionTrackingMode(trackingMode) { }
 
     ~RecordingState() { }
 
     RefPtr<DisplayList> m_displayList;
     SkPictureRecorder* m_recorder;
     SkCanvas* m_savedCanvas;
     const SkMatrix m_savedMatrix;
     bool m_savedShouldSmoothFonts;
     RegionTrackingMode m_regionTrackingMode;
 };
 
 GraphicsContext::GraphicsContext(SkCanvas* canvas, DisabledMode disableContextOrPainting)
     : m_canvas(canvas)
     , m_paintStateStack()
     , m_paintStateIndex(0)
-    , m_pendingCanvasSave(false)
     , m_annotationMode(0)
 #if ENABLE(ASSERT)
     , m_annotationCount(0)
     , m_layerCount(0)
     , m_disableDestructionChecks(false)
 #endif
     , m_disabledState(disableContextOrPainting)
     , m_deviceScaleFactor(1.0f)
     , m_regionTrackingMode(RegionTrackingDisabled)
     , m_trackTextRegion(false)
@@ skipping 11 matching lines @@
 
 GraphicsContext::~GraphicsContext()
 {
 #if ENABLE(ASSERT)
     if (!m_disableDestructionChecks) {
         ASSERT(!m_paintStateIndex);
         ASSERT(!m_paintState->saveCount());
         ASSERT(!m_annotationCount);
         ASSERT(!m_layerCount);
         ASSERT(m_recordingStateStack.isEmpty());
-        ASSERT(m_canvasStateStack.isEmpty());
+        ASSERT(!saveCount());
     }
 #endif
 }
 
 void GraphicsContext::resetCanvas(SkCanvas* canvas)
 {
     m_canvas = canvas;
     m_trackedRegion.reset();
 }
 
 void GraphicsContext::setRegionTrackingMode(RegionTrackingMode mode)
 {
     m_regionTrackingMode = mode;
     if (mode == RegionTrackingOpaque)
         m_trackedRegion.setTrackedRegionType(RegionTracker::Opaque);
     else if (mode == RegionTrackingOverwrite)
         m_trackedRegion.setTrackedRegionType(RegionTracker::Overwrite);
 }
 
 void GraphicsContext::save()
 {
     if (contextDisabled())
         return;
 
     m_paintState->incrementSaveCount();
 
-    if (m_canvas) {
-        m_canvasStateStack.append(CanvasSaveState(m_pendingCanvasSave, m_canvas->getSaveCount()));
-        m_pendingCanvasSave = true;
-    }
+    ASSERT(m_canvas);
+    m_canvas->save();
 }
 
 void GraphicsContext::restore()
 {
     if (contextDisabled())
         return;
 
     if (!m_paintStateIndex && !m_paintState->saveCount()) {
         WTF_LOG_ERROR("ERROR void GraphicsContext::restore() stack is empty");
         return;
     }
 
     if (m_paintState->saveCount()) {
         m_paintState->decrementSaveCount();
     } else {
         m_paintStateIndex--;
         m_paintState = m_paintStateStack[m_paintStateIndex].get();
     }
 
-    if (m_canvas) {
-        ASSERT(m_canvasStateStack.size() > 0);
-        CanvasSaveState savedState = m_canvasStateStack.last();
-        m_canvasStateStack.removeLast();
-        m_pendingCanvasSave = savedState.m_pendingSave;
-        m_canvas->restoreToCount(savedState.m_restoreCount);
-    }
+    ASSERT(m_canvas);
+    m_canvas->restore();
 }
 
+#if ENABLE(ASSERT)
+unsigned GraphicsContext::saveCount() const
+{
+    // Each m_paintStateStack entry implies an additional save op
+    // (on top of its own saveCount), except for the first frame.
+    unsigned count = m_paintStateIndex;
+    ASSERT(m_paintStateStack.size() > m_paintStateIndex);
+    for (unsigned i = 0; i <= m_paintStateIndex; ++i)
+        count += m_paintStateStack[i]->saveCount();
+
+    return count;
+}
+#endif
+
 void GraphicsContext::saveLayer(const SkRect* bounds, const SkPaint* paint)
 {
     if (contextDisabled())
         return;
 
     ASSERT(m_canvas);
 
-    realizeCanvasSave();
-
     m_canvas->saveLayer(bounds, paint);
     if (regionTrackingEnabled())
         m_trackedRegion.pushCanvasLayer(paint);
 }
 
 void GraphicsContext::restoreLayer()
 {
     if (contextDisabled())
         return;
 
@@ skipping 214 matching lines @@
     ASSERT(m_canvas);
     return m_canvas->readPixels(info, pixels, rowBytes, x, y);
 }
 
 void GraphicsContext::setMatrix(const SkMatrix& matrix)
 {
     if (contextDisabled())
         return;
 
     ASSERT(m_canvas);
-    realizeCanvasSave();
 
     m_canvas->setMatrix(matrix);
 }
 
 void GraphicsContext::concat(const SkMatrix& matrix)
 {
     if (contextDisabled())
         return;
 
     if (matrix.isIdentity())
         return;
 
     ASSERT(m_canvas);
-    realizeCanvasSave();
 
     m_canvas->concat(matrix);
 }
 
 void GraphicsContext::beginTransparencyLayer(float opacity, const FloatRect* bounds)
 {
     beginLayer(opacity, immutableState()->compositeOperator(), bounds);
 }
 
 void GraphicsContext::beginLayer(float opacity, CompositeOperator op, const FloatRect* bounds, ColorFilter colorFilter, ImageFilter* imageFilter)
@@ skipping 95 matching lines @@
     bool performClip = !displayList->clip().isEmpty();
     bool performTransform = !displayList->transform().isIdentity();
     if (performClip || performTransform) {
         save();
         if (performTransform)
             concat(displayList->transform());
         if (performClip)
             clipRect(displayList->clip());
     }
 
-    realizeCanvasSave();
-
     const FloatPoint& location = displayList->bounds().location();
     if (location.x() || location.y()) {
         SkMatrix m;
         m.setTranslate(location.x(), location.y());
         m_canvas->drawPicture(displayList->picture(), &m, 0);
     } else {
         m_canvas->drawPicture(displayList->picture());
     }
 
     if (regionTrackingEnabled()) {
@@ skipping 1004 matching lines @@
 
     path.setFillType(previousFillType);
 }
 
 void GraphicsContext::clipRect(const SkRect& rect, AntiAliasingMode aa, SkRegion::Op op)
 {
     ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
-    realizeCanvasSave();
-
     m_canvas->clipRect(rect, op, aa == AntiAliased);
 }
 
 void GraphicsContext::clipPath(const SkPath& path, AntiAliasingMode aa, SkRegion::Op op)
 {
     ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
-    realizeCanvasSave();
-
     m_canvas->clipPath(path, op, aa == AntiAliased);
 }
 
 void GraphicsContext::clipRRect(const SkRRect& rect, AntiAliasingMode aa, SkRegion::Op op)
 {
     ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
-    realizeCanvasSave();
-
     m_canvas->clipRRect(rect, op, aa == AntiAliased);
 }
 
 void GraphicsContext::beginCull(const FloatRect& rect)
 {
     ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
-    realizeCanvasSave();
     m_canvas->pushCull(rect);
 }
 
 void GraphicsContext::endCull()
 {
     ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
-    realizeCanvasSave();
-
     m_canvas->popCull();
 }
 
 void GraphicsContext::rotate(float angleInRadians)
 {
     ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
-    realizeCanvasSave();
-
     m_canvas->rotate(WebCoreFloatToSkScalar(angleInRadians * (180.0f / 3.14159265f)));
 }
 
 void GraphicsContext::translate(float x, float y)
 {
     ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
     if (!x && !y)
         return;
 
-    realizeCanvasSave();
-
     m_canvas->translate(WebCoreFloatToSkScalar(x), WebCoreFloatToSkScalar(y));
 }
 
 void GraphicsContext::scale(float x, float y)
 {
     ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
     if (x == 1.0f && y == 1.0f)
         return;
 
-    realizeCanvasSave();
-
     m_canvas->scale(WebCoreFloatToSkScalar(x), WebCoreFloatToSkScalar(y));
 }
 
 void GraphicsContext::setURLForRect(const KURL& link, const IntRect& destRect)
 {
     ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
     SkAutoDataUnref url(SkData::NewWithCString(link.string().utf8().data()));
@@ skipping 333 matching lines @@
         // FIXME: This is to not break tests (it results in the filter bitmap flag
         // being set to true). We need to decide if we respect InterpolationNone
         // being returned from computeInterpolationQuality.
         resampling = InterpolationLow;
     }
     resampling = limitInterpolationQuality(this, resampling);
     paint->setFilterLevel(static_cast<SkPaint::FilterLevel>(resampling));
 }
 
 } // namespace blink