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

third_party/WebKit/Source/modules/webgl/WebGLRenderingContextBase.cpp

 /*
  * Copyright (C) 2009 Apple 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 1381 matching lines @@
 
   if (!drawingBuffer()->markContentsChanged() && m_markedCanvasDirty) {
     return;
   }
 
   if (!canvas())
     return;
 
   LayoutBox* layoutBox = canvas()->layoutBox();
   if (layoutBox && layoutBox->hasAcceleratedCompositing()) {
+    layoutBox->contentChanged(changeType);
+  }
+  if (!m_markedCanvasDirty) {
     m_markedCanvasDirty = true;
-    canvas()->clearCopiedImage();
-    layoutBox->contentChanged(changeType);
-  } else {
-    if (!m_markedCanvasDirty) {
-      m_markedCanvasDirty = true;
-      canvas()->didDraw(
-          FloatRect(FloatPoint(0, 0), FloatSize(clampedCanvasSize())));
-    }
+    IntSize canvasSize = clampedCanvasSize();
+    didDraw(SkIRect::MakeXYWH(0, 0, canvasSize.width(), canvasSize.height()));

[Ken Russell (switch to Gerrit), 2017/02/14 01:31:38]

This is going to be triggered all the time now, and it registers a "finalize
frame" task observer in CanvasRenderingContext::didDraw. Task observers are not
cheap. I'm concerned about the performance impact of this change in the common
case, namely that stream capturing is not enabled. What can you say about this
part of this change?

[Justin Novosad, 2017/02/14 18:36:25]

This does not get called more than once per frame due to the check on 
m_markedCanvasDirty. I added trace instrumentation in a local build and I found
that the cost of CanvasRenderingContext::didDraw is 20us to 30us. Of that cost,
5us to 10us is for registering the task observer.  And the execution of the task
observer handler (didProcessTask), including the cost of de-registering itself
as an observer is 5us.  So in all the additional overhead is 10 to 15
microseconds per frame. I am not sure how reliable this data is since the values
are pretty close to the precision limit of the timer. For reference,
TRACE_EVENT0 inside an empty function is 5us.  So the overhead is pretty much
negligible IMO.

   }
 }
 
 void WebGLRenderingContextBase::onErrorMessage(const char* message,
                                                int32_t id) {
   if (m_synthesizedErrorsToConsole)
     printGLErrorToConsole(message);
   InspectorInstrumentation::didFireWebGLErrorOrWarning(canvas(), message);
 }
 
@@ skipping 6380 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
     result.setOffscreenCanvas(offscreenCanvas());
 }
 
 }  // namespace blink