Make stream captures work on canvases that are not in the DOM.

third_party/WebKit/Source/platform/graphics/RecordingImageBufferSurface.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 "platform/graphics/RecordingImageBufferSurface.h"
 
 #include "platform/Histogram.h"
 #include "platform/graphics/CanvasMetrics.h"
 #include "platform/graphics/ExpensiveCanvasHeuristicParameters.h"
 #include "platform/graphics/GraphicsContext.h"
@@ skipping 211 matching lines @@
   if (!m_fallbackSurface)
     fallBackToRasterCanvas(disableDeferralReasonToFallbackReason(reason));
 }
 
 sk_sp<SkPicture> RecordingImageBufferSurface::getPicture() {
   if (m_fallbackSurface)
     return nullptr;
 
   FallbackReason fallbackReason = FallbackReasonUnknown;
   bool canUsePicture = finalizeFrameInternal(&fallbackReason);
-  m_imageBuffer->didFinalizeFrame();
 
   ASSERT(canUsePicture || m_fallbackFactory);
 
   if (canUsePicture) {
     return m_previousFrame;
   }
 
   if (!m_fallbackSurface)
     fallBackToRasterCanvas(fallbackReason);
   return nullptr;
 }
 
-void RecordingImageBufferSurface::finalizeFrame(const FloatRect& dirtyRect) {
+void RecordingImageBufferSurface::finalizeFrame() {
   if (m_fallbackSurface) {
-    m_fallbackSurface->finalizeFrame(dirtyRect);
+    m_fallbackSurface->finalizeFrame();
     return;
   }
 
   FallbackReason fallbackReason = FallbackReasonUnknown;
   if (!finalizeFrameInternal(&fallbackReason))
     fallBackToRasterCanvas(fallbackReason);
 }
 
+void RecordingImageBufferSurface::doPaintInvalidation(
+    const FloatRect& dirtyRect) {
+  if (m_fallbackSurface) {
+    m_fallbackSurface->doPaintInvalidation(dirtyRect);
+    return;
+  }
+}
+
 static RecordingImageBufferSurface::FallbackReason flushReasonToFallbackReason(
     FlushReason reason) {
   switch (reason) {
     case FlushReasonUnknown:
       return RecordingImageBufferSurface::FallbackReasonUnknown;
     case FlushReasonInitialClear:
       return RecordingImageBufferSurface::FallbackReasonFlushInitialClear;
     case FlushReasonDrawImageOfWebGL:
       return RecordingImageBufferSurface::
           FallbackReasonFlushForDrawImageOfWebGL;
@@ skipping 26 matching lines @@
   m_currentFramePixelCount += pixelBounds.width() * pixelBounds.height();
 }
 
 bool RecordingImageBufferSurface::finalizeFrameInternal(
     FallbackReason* fallbackReason) {
   CHECK(!m_fallbackSurface);
   CHECK(m_currentFrame);
   ASSERT(m_currentFrame->getRecordingCanvas());
   ASSERT(fallbackReason);
   ASSERT(*fallbackReason == FallbackReasonUnknown);
-
-  if (!m_imageBuffer->isDirty()) {
+  if (!m_didRecordDrawCommandsInCurrentFrame) {
     if (!m_previousFrame) {
       // Create an initial blank frame
       m_previousFrame = m_currentFrame->finishRecordingAsPicture();
       initializeCurrentFrame();
     }
     CHECK(m_currentFrame);
     return true;
   }
 
   if (!m_frameWasCleared) {
@@ skipping 87 matching lines @@
 }
 
 void RecordingImageBufferSurface::setIsHidden(bool hidden) {
   if (m_fallbackSurface)
     m_fallbackSurface->setIsHidden(hidden);
   else
     ImageBufferSurface::setIsHidden(hidden);
 }
 
 }  // namespace blink