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)
+PassRefPtr<DisplayList> GraphicsContext::beginRecording(const FloatRect& bounds, uint32_t recordFlags)
 {
-    RefPtr<DisplayList> displayList = adoptRef(new DisplayList(bounds));
+    RefPtr<DisplayList> displayList = DisplayList::create(bounds);
+
+    SkPictureRecorder* recorder = 0;
 
     SkCanvas* savedCanvas = m_canvas;
     SkMatrix savedMatrix = getTotalMatrix();
 
     if (!contextDisabled()) {
-        IntRect recordingRect = enclosingIntRect(bounds);
-        m_canvas = displayList->beginRecording(recordingRect.size());
+        FloatRect bounds = displayList->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, displayList));
+
+    return displayList;
 }
 
-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