Add missing paint invalidation when creating canvas 2d context with no alpha

third_party/WebKit/Source/core/html/HTMLCanvasElement.cpp

 /*
  * Copyright (C) 2004, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. 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.
@@ skipping 244 matching lines @@
     return nullptr;
   }
 
   m_context = factory->create(this, attributes, document());
   if (!m_context)
     return nullptr;
 
   if (m_context->is3d()) {
     updateExternallyAllocatedMemory();
   }
+
+  LayoutObject* layoutObject = this->layoutObject();
+  if (layoutObject && m_context->is2d() &&
+      !m_context->creationAttributes().alpha()) {
+    // In the alpha false case, canvas is initially opaque even though there is
+    // no ImageBuffer, so we need to trigger an invalidation.
+    didDraw(FloatRect(0, 0, size().width(), size().height()));
+  }
+
   setNeedsCompositingUpdate();
 
   return m_context.get();
 }
 
 bool HTMLCanvasElement::shouldBeDirectComposited() const {
   return (m_context && m_context->isAccelerated()) ||
          (hasImageBuffer() && buffer()->isExpensiveToPaint()) ||
          (!!m_surfaceLayerBridge);
 }
@@ skipping 56 matching lines @@
     // FIXME: is this invalidation using the correct compositing state?
     DisableCompositingQueryAsserts disabler;
     ro->invalidatePaintRectangle(mappedDirtyRect);
   }
   m_dirtyRect = FloatRect();
 
   m_numFramesSinceLastRenderingModeSwitch++;
   if (RuntimeEnabledFeatures::
           enableCanvas2dDynamicRenderingModeSwitchingEnabled() &&
       !RuntimeEnabledFeatures::canvas2dFixedRenderingModeEnabled()) {
-    if (m_context->is2d() && buffer() && buffer()->isAccelerated() &&
+    if (m_context->is2d() && hasImageBuffer() && buffer()->isAccelerated() &&
         m_numFramesSinceLastRenderingModeSwitch >=
             ExpensiveCanvasHeuristicParameters::MinFramesBeforeSwitch &&
         !m_pendingRenderingModeSwitch) {
       if (!m_context->isAccelerationOptimalForCanvasContent()) {
         // The switch must be done asynchronously in order to avoid switching
         // during the paint invalidation step.
         Platform::current()->currentThread()->getWebTaskRunner()->postTask(
             BLINK_FROM_HERE,
             WTF::bind(
                 [](WeakPtr<ImageBuffer> buffer) {
@@ skipping 24 matching lines @@
 void HTMLCanvasElement::restoreCanvasMatrixClipStack(SkCanvas* canvas) const {
   if (m_context)
     m_context->restoreCanvasMatrixClipStack(canvas);
 }
 
 void HTMLCanvasElement::doDeferredPaintInvalidation() {
   DCHECK(!m_dirtyRect.isEmpty());
   if (!m_context->is2d()) {
     didFinalizeFrame();
   } else {
-    DCHECK(hasImageBuffer());
     FloatRect srcRect(0, 0, size().width(), size().height());
     m_dirtyRect.intersect(srcRect);
     LayoutBox* lb = layoutBox();
+    FloatRect invalidationRect;
     if (lb) {
       FloatRect mappedDirtyRect =
           mapRect(m_dirtyRect, srcRect, FloatRect(lb->contentBoxRect()));
       if (m_context->isAccelerated()) {
         // Accelerated 2D canvases need the dirty rect to be expressed relative
         // to the content box, as opposed to the layout box.
         mappedDirtyRect.move(-lb->contentBoxOffset());
       }
-      m_imageBuffer->finalizeFrame(mappedDirtyRect);
+      invalidationRect = mappedDirtyRect;
     } else {
-      m_imageBuffer->finalizeFrame(m_dirtyRect);
+      invalidationRect = m_dirtyRect;
+    }
+    if (hasImageBuffer()) {
+      m_imageBuffer->finalizeFrame(invalidationRect);
+    } else {
+      didFinalizeFrame();
     }
   }
   DCHECK(m_dirtyRect.isEmpty());
 }
 
 void HTMLCanvasElement::reset() {
   if (m_ignoreReset)
     return;
 
   m_dirtyRect = FloatRect();
@@ skipping 958 matching lines @@
   mojom::blink::OffscreenCanvasSurfacePtr service;
   Platform::current()->interfaceProvider()->getInterface(
       mojo::GetProxy(&service));
   m_surfaceLayerBridge =
       wrapUnique(new CanvasSurfaceLayerBridge(std::move(service)));
   return m_surfaceLayerBridge->createSurfaceLayer(this->width(),
                                                   this->height());
 }
 
 }  // namespace blink