Streamline the presentation of ImageBitmapRenderingContext

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 266 matching lines @@
 
   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()));
+    didDraw();
   }
 
   setNeedsCompositingUpdate();
 
   return m_context.get();
 }
 
 bool HTMLCanvasElement::shouldBeDirectComposited() const {
-  return (m_context && m_context->isAccelerated()) ||
+  return (m_context && m_context->isComposited()) ||
          (hasImageBuffer() && buffer()->isExpensiveToPaint()) ||
          (!!m_surfaceLayerBridge);
 }
 
 bool HTMLCanvasElement::isPaintable() const {
   return (m_context && m_context->isPaintable()) ||
          ImageBuffer::canCreateImageBuffer(size());
 }
 
 bool HTMLCanvasElement::isAccelerated() const {
@@ skipping 12 matching lines @@
     FloatRect inflatedRect = rect;
     inflatedRect.inflate(1);
     m_dirtyRect.unite(inflatedRect);
   } else {
     m_dirtyRect.unite(rect);
   }
   if (m_context && m_context->is2d() && hasImageBuffer())
     buffer()->didDraw(rect);
 }
 
+void HTMLCanvasElement::didDraw() {
+  didDraw(FloatRect(0, 0, size().width(), size().height()));
+}
+
 void HTMLCanvasElement::finalizeFrame() {
   if (hasImageBuffer())
     m_imageBuffer->finalizeFrame();
 
   // If the canvas is visible, notifying listeners is taken
   // care of in the in doDeferredPaintInvalidation, which allows
   // the frame to be grabbed prior to compositing, which is
   // critically important because compositing may clear the canvas's
   // image. (e.g. WebGL context with preserveDrawingBuffer=false).
   // If the canvas is not visible, doDeferredPaintInvalidation
   // will not get called, so we need to take care of business here.
   if (!m_didNotifyListenersForCurrentFrame)
     notifyListenersCanvasChanged();
   m_didNotifyListenersForCurrentFrame = false;
 }
 
 void HTMLCanvasElement::didDisableAcceleration() {
   // We must force a paint invalidation on the canvas even if it's
   // content did not change because it layer was destroyed.
-  didDraw(FloatRect(0, 0, size().width(), size().height()));
+  didDraw();
 }
 
 void HTMLCanvasElement::restoreCanvasMatrixClipStack(
     PaintCanvas* canvas) const {
   if (m_context)
     m_context->restoreCanvasMatrixClipStack(canvas);
 }
 
 void HTMLCanvasElement::doDeferredPaintInvalidation() {
   DCHECK(!m_dirtyRect.isEmpty());
   if (m_context->is2d()) {
     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()) {
+      if (m_context->isComposited()) {
         // 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());
       }
       invalidationRect = mappedDirtyRect;
     } else {
       invalidationRect = m_dirtyRect;
     }
+
+    if (m_dirtyRect.isEmpty())
+      return;
+
     if (hasImageBuffer()) {
       m_imageBuffer->doPaintInvalidation(invalidationRect);
     }
   }
 
-  if (m_dirtyRect.isEmpty())
-    return;
+  if (m_context->getContextType() ==
+          CanvasRenderingContext::ContextImageBitmap &&
+      m_context->platformLayer()) {
+    m_context->platformLayer()->invalidate();
+  }
 
   notifyListenersCanvasChanged();
   m_didNotifyListenersForCurrentFrame = true;
 
   // Propagate the m_dirtyRect accumulated so far to the compositor
   // before restarting with a blank dirty rect.
   FloatRect srcRect(0, 0, size().width(), size().height());
 
   LayoutBox* ro = layoutBox();
   // Canvas content updates do not need to be propagated as
-  // paint invalidations if the canvas is accelerated, since
+  // paint invalidations if the canvas is composited separately, since
   // the canvas contents are sent separately through a texture layer.
-  if (ro && (!m_context || !m_context->isAccelerated())) {
+  if (ro && (!m_context || !m_context->isComposited())) {
     // If ro->contentBoxRect() is larger than srcRect the canvas's image is
     // being stretched, so we need to account for color bleeding caused by the
     // interpollation filter.
     if (ro->contentBoxRect().width() > srcRect.width() ||
         ro->contentBoxRect().height() > srcRect.height()) {
       m_dirtyRect.inflate(0.5);
     }
 
     m_dirtyRect.intersect(srcRect);
     LayoutRect mappedDirtyRect(enclosingIntRect(
@@ skipping 87 matching lines @@
       if (hadImageBuffer)
         layoutObject->setShouldDoFullPaintInvalidation();
     }
   }
 }
 
 bool HTMLCanvasElement::paintsIntoCanvasBuffer() const {
   if (placeholderFrame())
     return false;
   DCHECK(m_context);
-  if (!m_context->isAccelerated())
+  if (!m_context->isComposited())
     return true;
   if (layoutBox() && layoutBox()->hasAcceleratedCompositing())
     return false;
 
   return true;
 }
 
 void HTMLCanvasElement::notifyListenersCanvasChanged() {
   if (m_listeners.size() == 0)
     return;
@@ skipping 767 matching lines @@
     renderingContext()->paintRenderingResultsToCanvas(BackBuffer);
     if (hasImageBuffer()) {
       skImage = buffer()->newSkImageSnapshot(hint, reason);
     } else {
       skImage = createTransparentSkImage(size());
     }
   } else {
     if (ExpensiveCanvasHeuristicParameters::
             DisableAccelerationToAvoidReadbacks &&
         !RuntimeEnabledFeatures::canvas2dFixedRenderingModeEnabled() &&
-        hint == PreferNoAcceleration && m_context->isAccelerated() &&
-        hasImageBuffer()) {
+        hint == PreferNoAcceleration && hasImageBuffer() &&
+        buffer()->isAccelerated()) {
       buffer()->disableAcceleration();
     }
     RefPtr<Image> image = renderingContext()->getImage(hint, reason);
     if (image) {
       skImage = image->imageForCurrentFrame();
     } else {
       skImage = createTransparentSkImage(size());
     }
   }
 
@@ skipping 159 matching lines @@
     // Creates a placeholder layer first before Surface is created.
     m_surfaceLayerBridge->createSolidColorLayer();
   }
 }
 
 void HTMLCanvasElement::OnWebLayerReplaced() {
   setNeedsCompositingUpdate();
 }
 
 }  // namespace blink