Modifications to DisplayList for better Slimming Paint

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 26 matching lines @@
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "platform/text/BidiResolver.h"
 #include "platform/text/TextRunIterator.h"
 #include "platform/weborigin/KURL.h"
 #include "third_party/skia/include/core/SkAnnotation.h"
 #include "third_party/skia/include/core/SkClipStack.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkDevice.h"
 #include "third_party/skia/include/core/SkPicture.h"
+#include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/core/SkRRect.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/effects/SkBlurMaskFilter.h"
 #include "third_party/skia/include/effects/SkCornerPathEffect.h"
 #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"
@@ skipping 35 matching lines @@
 
 struct GraphicsContext::CanvasSaveState {
     CanvasSaveState(bool pendingSave, int count)
         : m_pendingSave(pendingSave), m_restoreCount(count) { }
 
     bool m_pendingSave;
     int m_restoreCount;
 };
 
 struct GraphicsContext::RecordingState {
-    RecordingState(SkCanvas* currentCanvas, const SkMatrix& currentMatrix, PassRefPtr<DisplayList> displayList)
-        : m_savedCanvas(currentCanvas)
-        , m_displayList(displayList)
-        , m_savedMatrix(currentMatrix)
-    {
-    }
+    RecordingState(SkPictureRecorder* recorder, SkCanvas* currentCanvas, const SkMatrix& currentMatrix, PassRefPtr<DisplayList> displayList)
+        : m_displayList(displayList)
+        , m_recorder(recorder)
+        , m_savedCanvas(currentCanvas)
+        , m_savedMatrix(currentMatrix) { }
 
+    ~RecordingState() { }
+
+    RefPtr<DisplayList> m_displayList;
+    SkPictureRecorder* m_recorder;
     SkCanvas* m_savedCanvas;
-    RefPtr<DisplayList> m_displayList;
     const SkMatrix m_savedMatrix;
 };
 
 GraphicsContext::GraphicsContext(SkCanvas* canvas, DisabledMode disableContextOrPainting)
     : m_canvas(canvas)
     , m_paintStateStack()
     , m_paintStateIndex(0)
     , m_pendingCanvasSave(false)
     , m_annotationMode(0)
 #if ENABLE(ASSERT)
@@ skipping 364 matching lines @@
         return;
 
     restoreLayer();
 
     ASSERT(m_layerCount > 0);
 #if ENABLE(ASSERT)
     --m_layerCount;
 #endif
 }
 
-void GraphicsContext::beginRecording(const FloatRect& bounds)
+void GraphicsContext::beginRecording(PassRefPtr<DisplayList> displayList, uint32_t recordFlags)
 {
-    RefPtr<DisplayList> displayList = adoptRef(new DisplayList(bounds));
+    RefPtr<DisplayList> pDisplayList = displayList;
+
+    pDisplayList->clearPicture();

[chrishtr, 2014/09/02 22:05:58]

What's the use case of beginning a recording of a display list that is not
created from scratch just before?
Are you just changing this around to make clear the ownership of the pointer?

If it's always from scratch, we can change beginRecording() to return a fresh
PasRefPtr<DisplayList> that the caller can keep.
This simplifies the DisplayList API.

[Stephen Chennney, 2014/09/03 14:19:37]

If the display list is invalidated we should be able to just re-record it
without creating another. Now that I think about it I don't think we take
advantage of this. I also want to clear the picture to maintain the invariant
stated in DisplayList: that the picture will be null when recording.
And that too.

[chrishtr, 2014/09/03 16:56:11]

What's the performance advantage of this though? There is a code correctness
downside risk to reusing.
If we don't take advantage of it, then beginRecording could return a new display
list rather than
using an existing one.

+    SkPictureRecorder* recorder = 0;
 
     SkCanvas* savedCanvas = m_canvas;
     SkMatrix savedMatrix = getTotalMatrix();
 
     if (!contextDisabled()) {
-        IntRect recordingRect = enclosingIntRect(bounds);
-        m_canvas = displayList->beginRecording(recordingRect.size());
+        FloatRect bounds = pDisplayList->bounds();
+        IntSize recordingSize = enclosingIntRect(bounds).size();
+        recorder = new SkPictureRecorder;
+        m_canvas = recorder->beginRecording(recordingSize.width(), recordingSize.height(), 0, recordFlags);
 
         // We want the bounds offset mapped to (0, 0), such that the display list content
         // is fully contained within the SkPictureRecord's bounds.
         if (!toFloatSize(bounds.location()).isZero()) {
             m_canvas->translate(-bounds.x(), -bounds.y());
             // To avoid applying the offset repeatedly in getTotalMatrix(), we pre-apply it here.
             savedMatrix.preTranslate(bounds.x(), bounds.y());
         }
     }
 
-    m_recordingStateStack.append(RecordingState(savedCanvas, savedMatrix, displayList));
+    m_recordingStateStack.append(RecordingState(recorder, savedCanvas, savedMatrix, pDisplayList));
 }
 
-PassRefPtr<DisplayList> GraphicsContext::endRecording()
+void GraphicsContext::endRecording()
 {
     ASSERT(!m_recordingStateStack.isEmpty());
 
     RecordingState recording = m_recordingStateStack.last();
-    if (!contextDisabled()) {
-        ASSERT(recording.m_displayList->isRecording());
-        recording.m_displayList->endRecording();
-    }
+    if (!contextDisabled())
+        recording.m_displayList->setPicture(recording.m_recorder->endRecording());
 
+    m_canvas = recording.m_savedCanvas;
+    delete recording.m_recorder;
     m_recordingStateStack.removeLast();
-    m_canvas = recording.m_savedCanvas;
-
-    return recording.m_displayList.release();
 }
 
 bool GraphicsContext::isRecording() const
 {
     return !m_recordingStateStack.isEmpty();
 }
 
 void GraphicsContext::drawDisplayList(DisplayList* displayList)
 {
     ASSERT(displayList);
-    ASSERT(!displayList->isRecording());
 
     if (contextDisabled() || displayList->bounds().isEmpty())
         return;
 
+    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 FloatRect& bounds = displayList->bounds();
-    if (bounds.x() || bounds.y()) {
+    const FloatPoint& location = displayList->bounds().location();
+    if (location.x() || location.y()) {
         SkMatrix m;
-        m.setTranslate(bounds.x(), bounds.y());
+        m.setTranslate(location.x(), location.y());
         m_canvas->drawPicture(displayList->picture(), &m, 0);
     } else {
         m_canvas->drawPicture(displayList->picture());
     }
+
+    if (performClip || performTransform)
+        restore();
 }
 
 void GraphicsContext::drawConvexPolygon(size_t numPoints, const FloatPoint* points, bool shouldAntialias)
 {
     if (contextDisabled())
         return;
 
     if (numPoints <= 1)
         return;
 
@@ skipping 1394 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