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

third_party/WebKit/Source/modules/canvas2d/CanvasRenderingContext2D.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc.
  * All rights reserved.
  * Copyright (C) 2008, 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008 Dirk Schulze <krit@webkit.org>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  * Copyright (C) 2012, 2013 Intel Corporation. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
@@ skipping 108 matching lines @@
       m_tryRestoreContextAttemptCount(0),
       m_dispatchContextLostEventTimer(
           this,
           &CanvasRenderingContext2D::dispatchContextLostEvent),
       m_dispatchContextRestoredEventTimer(
           this,
           &CanvasRenderingContext2D::dispatchContextRestoredEvent),
       m_tryRestoreContextEventTimer(
           this,
           &CanvasRenderingContext2D::tryRestoreContextEvent),
-      m_pruneLocalFontCacheScheduled(false) {
+      m_shouldPruneLocalFontCache(false) {
   if (document.settings() &&
       document.settings()->getAntialiasedClips2dCanvasEnabled())
     m_clipAntialiasing = AntiAliased;
   setShouldAntialias(true);
   validateStateStack();
 }
 
 void CanvasRenderingContext2D::setCanvasGetContextResult(
     RenderingContext& result) {
   result.setCanvasRenderingContext2D(this);
 }
 
 CanvasRenderingContext2D::~CanvasRenderingContext2D() {}
 
-void CanvasRenderingContext2D::dispose() {
-  if (m_pruneLocalFontCacheScheduled)
-    Platform::current()->currentThread()->removeTaskObserver(this);
-}
-
 void CanvasRenderingContext2D::validateStateStack() const {
 #if DCHECK_IS_ON()
   if (SkCanvas* skCanvas = canvas()->existingDrawingCanvas()) {
     // The canvas should always have an initial save frame, to support
     // resetting the top level matrix and clip.
     DCHECK_GT(skCanvas->getSaveCount(), 1);
 
     if (m_contextLostMode == NotLostContext) {
       DCHECK_EQ(static_cast<size_t>(skCanvas->getSaveCount()),
                 m_stateStack.size() + 1);
@@ skipping 187 matching lines @@
   if (dirtyRect.isEmpty())
     return;
 
   if (ExpensiveCanvasHeuristicParameters::BlurredShadowsAreExpensive &&
       state().shouldDrawShadows() && state().shadowBlur() > 0) {
     ImageBuffer* buffer = canvas()->buffer();
     if (buffer)
       buffer->setHasExpensiveOp();
   }
 
-  canvas()->didDraw(SkRect::Make(dirtyRect));
+  CanvasRenderingContext::didDraw(dirtyRect);
 }
 
 bool CanvasRenderingContext2D::stateHasFilter() {
   return state().hasFilter(canvas(), canvas()->size(), this);
 }
 
 sk_sp<SkImageFilter> CanvasRenderingContext2D::stateGetFilter() {
   return state().getFilter(canvas(), canvas()->size(), this);
 }
 
@@ skipping 107 matching lines @@
       elementFontDescription.setComputedSize(
           elementFontDescription.specifiedSize());
       fontStyle->setFontDescription(elementFontDescription);
       fontStyle->font().update(fontStyle->font().getFontSelector());
       canvas()->document().ensureStyleResolver().computeFont(fontStyle.get(),
                                                              *parsedStyle);
       m_fontsResolvedUsingCurrentStyle.add(newFont, fontStyle->font());
       DCHECK(!m_fontLRUList.contains(newFont));
       m_fontLRUList.add(newFont);
       pruneLocalFontCache(canvasFontCache->hardMaxFonts());  // hard limit
-      schedulePruneLocalFontCacheIfNeeded();                 // soft limit
+      m_shouldPruneLocalFontCache = true;                    // apply soft limit
       modifiableState().setFont(
           fontStyle->font(), canvas()->document().styleEngine().fontSelector());
     }
   } else {
     Font resolvedFont;
     if (!canvasFontCache->getFontUsingDefaultStyle(newFont, resolvedFont))
       return;
     modifiableState().setFont(
         resolvedFont, canvas()->document().styleEngine().fontSelector());
   }
 
   // The parse succeeded.
   String newFontSafeCopy(newFont);  // Create a string copy since newFont can be
                                     // deleted inside realizeSaves.
   modifiableState().setUnparsedFont(newFontSafeCopy);
 }
 
-void CanvasRenderingContext2D::schedulePruneLocalFontCacheIfNeeded() {
-  if (m_pruneLocalFontCacheScheduled)
-    return;
-  m_pruneLocalFontCacheScheduled = true;
-  Platform::current()->currentThread()->addTaskObserver(this);
-}
-
 void CanvasRenderingContext2D::didProcessTask() {
-  Platform::current()->currentThread()->removeTaskObserver(this);
-
+  CanvasRenderingContext::didProcessTask();
   // This should be the only place where canvas() needs to be checked for
-  // nullness because the circular refence with HTMLCanvasElement mean the
-  // canvas and the context keep each other alive as long as the pair is
-  // referenced the task observer is the only persisten refernce to this object
-  // that is not traced, so didProcessTask() may be call at a time when the
+  // nullness because the circular refence with HTMLCanvasElement means the
+  // canvas and the context keep each other alive. As long as the pair is
+  // referenced, the task observer is the only persistent refernce to this
+  // object
+  // that is not traced, so didProcessTask() may be called at a time when the
   // canvas has been garbage collected but not the context.
-  if (!canvas())
-    return;
-
-  // The rendering surface needs to be prepared now because it will be too late
-  // to create a layer once we are in the paint invalidation phase.
-  canvas()->prepareSurfaceForPaintingIfNeeded();

[xlai (Olivia), 2017/01/27 22:23:25]

Is there any specific reason why you move this creation of surface in canvas to
layerbridge->finalizeFrame?

[Justin Novosad, 2017/02/07 21:52:29]

There is no change in functionality. Just a drive-by clean-up. The series of
methods used to propagate this call was unnecessary. when we have a now
redundant parallel channel called finalizeFrame.

-
-  pruneLocalFontCache(canvas()->document().canvasFontCache()->maxFonts());
-  m_pruneLocalFontCacheScheduled = false;
+  if (m_shouldPruneLocalFontCache && canvas()) {
+    m_shouldPruneLocalFontCache = false;
+    pruneLocalFontCache(canvas()->document().canvasFontCache()->maxFonts());
+  }
 }
 
 void CanvasRenderingContext2D::pruneLocalFontCache(size_t targetSize) {
   if (targetSize == 0) {
     // Short cut: LRU does not matter when evicting everything
     m_fontLRUList.clear();
     m_fontsResolvedUsingCurrentStyle.clear();
     return;
   }
   while (m_fontLRUList.size() > targetSize) {
@@ skipping 628 matching lines @@
   }
   return true;
 }
 
 void CanvasRenderingContext2D::resetUsageTracking() {
   UsageCounters newCounters;
   m_usageCounters = newCounters;
 }
 
 }  // namespace blink