[SP] Allocate an SkPictureRecorder only once per GraphicsContext instantiation

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 38 matching lines @@
 #include "wtf/MathExtras.h"
 
 namespace blink {
 
 class GraphicsContext::RecordingState {
     WTF_MAKE_FAST_ALLOCATED(GraphicsContext::RecordingState);
     WTF_MAKE_NONCOPYABLE(RecordingState);
 public:
     static PassOwnPtr<RecordingState> Create(SkCanvas* canvas, const SkMatrix& matrix)
     {
+        // Slimmming Paint uses m_pictureRecorder on GraphicsContext instead.
+        ASSERT(!RuntimeEnabledFeatures::slimmingPaintEnabled());
         return adoptPtr(new RecordingState(canvas, matrix));
     }
 
     SkPictureRecorder& recorder() { return m_recorder; }
     SkCanvas* canvas() const { return m_savedCanvas; }
     const SkMatrix& matrix() const { return m_savedMatrix; }
 
 private:
     explicit RecordingState(SkCanvas* canvas, const SkMatrix& matrix)
         : m_savedCanvas(canvas)
         , m_savedMatrix(matrix)
     { }
 
     SkPictureRecorder m_recorder;
     SkCanvas* m_savedCanvas;
     const SkMatrix m_savedMatrix;
 };
 
 GraphicsContext::GraphicsContext(DisplayItemList* displayItemList, DisabledMode disableContextOrPainting)
     : GraphicsContext(nullptr, displayItemList, disableContextOrPainting)
-{ }
+{
+    // TODO(chrishtr): switch the type of the parameter to DisplayItemList&.
+    ASSERT(displayItemList);
+}
 
 PassOwnPtr<GraphicsContext> GraphicsContext::deprecatedCreateWithCanvas(SkCanvas* canvas, DisabledMode disableContextOrPainting)
 {
     return adoptPtr(new GraphicsContext(canvas, nullptr, disableContextOrPainting));
 }
 
 GraphicsContext::GraphicsContext(SkCanvas* canvas, DisplayItemList* displayItemList, DisabledMode disableContextOrPainting)
     : m_canvas(canvas)
+    , m_originalCanvas(canvas)
     , m_displayItemList(displayItemList)
     , m_clipRecorderStack(0)
     , m_paintStateStack()
     , m_paintStateIndex(0)
     , m_annotationMode(0)
 #if ENABLE(ASSERT)
     , m_layerCount(0)
     , m_annotationCount(0)
     , m_disableDestructionChecks(false)
     , m_inDrawingRecorder(false)
@@ skipping 367 matching lines @@
     restoreLayer();
 
     ASSERT(m_layerCount-- > 0);
 }
 
 void GraphicsContext::beginRecording(const FloatRect& bounds, uint32_t recordFlags)
 {
     if (contextDisabled())
         return;
 
+    if (RuntimeEnabledFeatures::slimmingPaintEnabled()) {
+        m_canvas = m_pictureRecorder.beginRecording(bounds, 0, recordFlags);
+        return;
+    }
+
     m_recordingStateStack.append(
         RecordingState::Create(m_canvas, getTotalMatrix()));
     m_canvas = m_recordingStateStack.last()->recorder().beginRecording(bounds, 0, recordFlags);
 }
 
 PassRefPtr<const SkPicture> GraphicsContext::endRecording()
 {
     if (contextDisabled())
         return nullptr;
 
+    if (RuntimeEnabledFeatures::slimmingPaintEnabled()) {
+        RefPtr<const SkPicture> picture = adoptRef(m_pictureRecorder.endRecordingAsPicture());
+        m_canvas = m_originalCanvas;
+        ASSERT(picture);
+        return picture.release();
+    }
+
     ASSERT(!m_recordingStateStack.isEmpty());
     RecordingState* recording = m_recordingStateStack.last().get();
     RefPtr<const SkPicture> picture = adoptRef(recording->recorder().endRecordingAsPicture());
     m_canvas = recording->canvas();
 
     m_recordingStateStack.removeLast();
 
     ASSERT(picture);
     return picture.release();
 }
 
 bool GraphicsContext::isRecording() const
 {
+    if (RuntimeEnabledFeatures::slimmingPaintEnabled())
+        return m_canvas != m_originalCanvas;
+
     return !m_recordingStateStack.isEmpty();
 }
 
 void GraphicsContext::drawPicture(const SkPicture* picture)
 {
     // FIXME: SP currently builds empty-bounds pictures in some cases. This is a temp
     // workaround, but the problem should be fixed: empty-bounds pictures are going to be culled
     // on playback anyway.
     bool cullEmptyPictures = !RuntimeEnabledFeatures::slimmingPaintEnabled();
     if (contextDisabled() || !picture || (picture->cullRect().isEmpty() && cullEmptyPictures))
@@ skipping 1242 matching lines @@
         // being returned from computeInterpolationQuality.
         resampling = InterpolationLow;
     }
     resampling = limitInterpolationQuality(this, resampling);
     paint->setFilterQuality(static_cast<SkFilterQuality>(resampling));
 
     return initialSaveCount;
 }
 
 } // namespace blink