[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)
@@ skipping 35 matching lines @@
 {
     // FIXME: Do some tests to determine how many states are typically used, and allocate
     // several here.
     m_paintStateStack.append(GraphicsContextState::create());
     m_paintState = m_paintStateStack.last().get();
 
     if (contextDisabled()) {
         DEFINE_STATIC_LOCAL(RefPtr<SkCanvas>, nullCanvas, (adoptRef(SkCreateNullCanvas())));
         m_canvas = nullCanvas.get();
     }
+
+    // TODO(chrishtr): switch the type of the parameter to DisplayItemList&
+    ASSERT(displayItemList);
+    m_pictureRecorder = adoptPtr(new SkPictureRecorder);
 }
 
 GraphicsContext::~GraphicsContext()
 {
 #if ENABLE(ASSERT)
     if (!m_disableDestructionChecks) {
         ASSERT(!m_paintStateIndex);
         ASSERT(!m_paintState->saveCount());
         ASSERT(!m_annotationCount);
         ASSERT(!m_layerCount);
@@ skipping 341 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 = nullptr;
+        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;
+
     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