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

third_party/WebKit/Source/platform/graphics/Canvas2DLayerBridge.cpp

 /*
  * Copyright (C) 2012 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 835 matching lines @@
     if (m_imageBuffer)
       m_imageBuffer->notifySurfaceInvalid();
     CanvasMetrics::countCanvasContextUsage(
         CanvasMetrics::Accelerated2DCanvasGPUContextLost);
   }
   return m_surface.get();
 }
 
 bool Canvas2DLayerBridge::restoreSurface() {
   DCHECK(!m_destructionInProgress);
-  if (m_destructionInProgress)
+  if (m_destructionInProgress || !isAccelerated())
     return false;
-  DCHECK(isAccelerated() && !m_surface);
+  DCHECK(!m_surface);
 
   gpu::gles2::GLES2Interface* sharedGL = nullptr;
   m_layer->clearTexture();
   m_contextProvider = WTF::wrapUnique(
       Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
   if (m_contextProvider)
     sharedGL = m_contextProvider->contextGL();
 
   if (sharedGL && sharedGL->GetGraphicsResetStatusKHR() == GL_NO_ERROR) {
     GrContext* grCtx = m_contextProvider->grContext();
@@ skipping 23 matching lines @@
     cc::TextureMailbox* outMailbox,
     std::unique_ptr<cc::SingleReleaseCallback>* outReleaseCallback) {
   if (m_destructionInProgress) {
     // It can be hit in the following sequence.
     // 1. Canvas draws something.
     // 2. The compositor begins the frame.
     // 3. Javascript makes a context be lost.
     // 4. Here.
     return false;
   }
-  DCHECK(isAccelerated() || isHibernating() || m_softwareRenderingWhileHidden);
-
-  // if hibernating but not hidden, we want to wake up from
-  // hibernation
-  if ((isHibernating() || m_softwareRenderingWhileHidden) && isHidden())
-    return false;
 
   // If the context is lost, we don't know if we should be producing GPU or
   // software frames, until we get a new context, since the compositor will
   // be trying to get a new context and may change modes.
   if (!m_contextProvider ||
       m_contextProvider->contextGL()->GetGraphicsResetStatusKHR() !=
           GL_NO_ERROR)
     return false;
 
+  DCHECK(isAccelerated() || isHibernating() || m_softwareRenderingWhileHidden);
+
+  // if hibernating but not hidden, we want to wake up from
+  // hibernation
+  if ((isHibernating() || m_softwareRenderingWhileHidden) && isHidden())
+    return false;
+
   sk_sp<SkImage> image =
       newImageSnapshot(PreferAcceleration, SnapshotReasonUnknown);
   if (!image || !image->getTexture())
     return false;
 
   // Early exit if canvas was not drawn to since last prepareMailbox.
   GLenum filter = getGLFilter();
   if (image->uniqueID() == m_lastImageId && filter == m_lastFilter)
     return false;
   m_lastImageId = image->uniqueID();
@@ skipping 108 matching lines @@
     }
   }
   if (!m_isRegisteredTaskObserver) {
     Platform::current()->currentThread()->addTaskObserver(this);
     m_isRegisteredTaskObserver = true;
   }
   m_didDrawSinceLastFlush = true;
   m_didDrawSinceLastGpuFlush = true;
 }
 
-void Canvas2DLayerBridge::prepareSurfaceForPaintingIfNeeded() {
+void Canvas2DLayerBridge::finalizeFrame() {
+  DCHECK(!m_destructionInProgress);
+
+  // Make sure surface is ready for painting: fix the rendering mode now
+  // because it will be too late during the paint invalidation phase.
   getOrCreateSurface(PreferAcceleration);
-}
 
-void Canvas2DLayerBridge::finalizeFrame(const FloatRect& dirtyRect) {
-  DCHECK(!m_destructionInProgress);
-  if (m_layer && m_accelerationMode != DisableAcceleration)
-    m_layer->layer()->invalidateRect(enclosingIntRect(dirtyRect));
   if (m_rateLimiter)
     m_rateLimiter->reset();
   m_renderingTaskCompletedForCurrentFrame = false;
 }
 
+void Canvas2DLayerBridge::doPaintInvalidation(const FloatRect& dirtyRect) {
+  DCHECK(!m_destructionInProgress);
+  if (m_layer && m_accelerationMode != DisableAcceleration)
+    m_layer->layer()->invalidateRect(enclosingIntRect(dirtyRect));
+}
+
 void Canvas2DLayerBridge::didProcessTask() {
   TRACE_EVENT0("cc", "Canvas2DLayerBridge::didProcessTask");
   DCHECK(m_isRegisteredTaskObserver);
   // If m_renderTaskProcessedForCurrentFrame is already set to true,
   // it means that rendering tasks are not synchronized with the compositor
   // (i.e. not using requestAnimationFrame), so we are at risk of posting
   // a multi-frame backlog to the GPU
   if (m_renderingTaskCompletedForCurrentFrame) {
     if (isAccelerated()) {
       flushGpu();
@@ skipping 61 matching lines @@
     default;
 
 void Canvas2DLayerBridge::Logger::reportHibernationEvent(
     HibernationEvent event) {
   DEFINE_STATIC_LOCAL(EnumerationHistogram, hibernationHistogram,
                       ("Canvas.HibernationEvents", HibernationEventCount));
   hibernationHistogram.count(event);
 }
 
 }  // namespace blink