Allow certain SP recorder classes to defer their "begin" operation.

Source/platform/graphics/paint/DrawingRecorder.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "platform/graphics/paint/DrawingRecorder.h"
 
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/graphics/paint/CachedDisplayItem.h"
 #include "platform/graphics/paint/DisplayItemList.h"
 #include "platform/graphics/paint/DrawingDisplayItem.h"
 #include "third_party/skia/include/core/SkPicture.h"
 
 namespace blink {
 
-DrawingRecorder::DrawingRecorder(GraphicsContext& context, const DisplayItemClientWrapper& displayItemClient, DisplayItem::Type displayItemType, const FloatRect& cullRect)
+DrawingRecorder::DrawingRecorder(GraphicsContext& context, const DisplayItemClientWrapper& displayItemClient, DisplayItem::Type displayItemType)
     : m_context(context)
     , m_displayItemClient(displayItemClient)
     , m_displayItemType(displayItemType)
     , m_canUseCachedDrawing(false)
+    , m_engaged(false)
 #if ENABLE(ASSERT)
     , m_checkedCachedDrawing(false)
     , m_displayItemPosition(RuntimeEnabledFeatures::slimmingPaintEnabled() ? m_context.displayItemList()->newDisplayItemsSize() : 0)
     , m_skipUnderInvalidationChecking(false)
 #endif
 {
-    if (!RuntimeEnabledFeatures::slimmingPaintEnabled())
-        return;
+}
 
-    ASSERT(context.displayItemList());
-    if (context.displayItemList()->displayItemConstructionIsDisabled())
-        return;
-
-    ASSERT(DisplayItem::isDrawingType(displayItemType));
-    m_canUseCachedDrawing = context.displayItemList()->clientCacheIsValid(displayItemClient.displayItemClient());
-
-#if ENABLE(ASSERT)
-    context.setInDrawingRecorder(true);
-    m_canUseCachedDrawing &= !RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled();
-#endif
-
-#ifndef NDEBUG
-    // Enable recording to check if any painter is still doing unnecessary painting when we can use cache.
-    context.beginRecording(cullRect);
-#else
-    if (!m_canUseCachedDrawing)
-        context.beginRecording(cullRect);
-#endif
-
-#if ENABLE(ASSERT)
-    if (RuntimeEnabledFeatures::slimmingPaintStrictCullRectClippingEnabled() && !m_canUseCachedDrawing) {
-        // Skia depends on the cull rect containing all of the display item commands. When strict
-        // cull rect clipping is enabled, make this explicit. This allows us to identify potential
-        // incorrect cull rects that might otherwise be masked due to Skia internal optimizations.
-        context.save();
-        context.clipRect(enclosingIntRect(cullRect), NotAntiAliased, SkRegion::kIntersect_Op);
-    }
-#endif
+DrawingRecorder::DrawingRecorder(GraphicsContext& context, const DisplayItemClientWrapper& displayItemClient, DisplayItem::Type displayItemType, const FloatRect& cullRect)
+    : DrawingRecorder(context, displayItemClient, displayItemType)
+{
+    begin(cullRect);
 }
 
 DrawingRecorder::~DrawingRecorder()
 {
+    if (!m_engaged)
+        return;
     if (!RuntimeEnabledFeatures::slimmingPaintEnabled())
         return;
 
     ASSERT(m_context.displayItemList());
     if (m_context.displayItemList()->displayItemConstructionIsDisabled())
         return;
 
 #if ENABLE(ASSERT)
     if (RuntimeEnabledFeatures::slimmingPaintStrictCullRectClippingEnabled() && !m_canUseCachedDrawing) {
         m_context.restore();
@@ skipping 15 matching lines @@
     } else {
         OwnPtr<DrawingDisplayItem> drawingDisplayItem = DrawingDisplayItem::create(m_displayItemClient, m_displayItemType, m_context.endRecording());
 #if ENABLE(ASSERT)
         if (m_skipUnderInvalidationChecking)
             drawingDisplayItem->setSkipUnderInvalidationChecking();
 #endif
         m_context.displayItemList()->add(drawingDisplayItem.release());
     }
 }
 
+void DrawingRecorder::begin(const FloatRect& cullRect)
+{
+    ASSERT(!m_engaged);
+    m_engaged = true;
+
+    if (!RuntimeEnabledFeatures::slimmingPaintEnabled())
+        return;
+
+    ASSERT(m_context.displayItemList());
+    if (m_context.displayItemList()->displayItemConstructionIsDisabled())
+        return;
+
+    ASSERT(DisplayItem::isDrawingType(m_displayItemType));
+    m_canUseCachedDrawing = m_context.displayItemList()->clientCacheIsValid(m_displayItemClient.displayItemClient());
+
+#if ENABLE(ASSERT)
+    m_context.setInDrawingRecorder(true);
+    m_canUseCachedDrawing &= !RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled();
+#endif
+
+#ifndef NDEBUG
+    // Enable recording to check if any painter is still doing unnecessary painting when we can use cache.
+    m_context.beginRecording(cullRect);
+#else
+    if (!m_canUseCachedDrawing)
+        m_context.beginRecording(cullRect);
+#endif
+
+#if ENABLE(ASSERT)
+    if (RuntimeEnabledFeatures::slimmingPaintStrictCullRectClippingEnabled() && !m_canUseCachedDrawing) {
+        // Skia depends on the cull rect containing all of the display item commands. When strict
+        // cull rect clipping is enabled, make this explicit. This allows us to identify potential
+        // incorrect cull rects that might otherwise be masked due to Skia internal optimizations.
+        m_context.save();
+        m_context.clipRect(enclosingIntRect(cullRect), NotAntiAliased, SkRegion::kIntersect_Op);
+    }
+#endif
+}
+
 } // namespace blink