Streamline the presentation of ImageBitmapRenderingContext

third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp

 /*
  * Copyright (C) 2009, 2010, 2011 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 91 matching lines @@
 
 static IntRect backgroundRect(const LayoutObject& layoutObject) {
   if (!layoutObject.isBox())
     return IntRect();
 
   LayoutRect rect;
   const LayoutBox& box = toLayoutBox(layoutObject);
   return pixelSnappedIntRect(box.backgroundRect(BackgroundClipRect));
 }
 
-static inline bool isAcceleratedCanvas(const LayoutObject& layoutObject) {
+static inline bool isCompositedCanvas(const LayoutObject& layoutObject) {
   if (layoutObject.isCanvas()) {
     HTMLCanvasElement* canvas = toHTMLCanvasElement(layoutObject.node());
     if (CanvasRenderingContext* context = canvas->renderingContext())
-      return context->isAccelerated();
+      return context->isComposited();
   }
   return false;
 }
 
 static inline bool isPlaceholderCanvas(const LayoutObject& layoutObject) {
   if (layoutObject.isCanvas()) {
     HTMLCanvasElement* canvas = toHTMLCanvasElement(layoutObject.node());
     return canvas->surfaceLayerBridge();
   }
   return false;
@@ skipping 19 matching lines @@
 }
 
 static WebLayer* platformLayerForPlugin(LayoutObject& layoutObject) {
   if (!layoutObject.isEmbeddedObject())
     return nullptr;
   PluginView* plugin = toLayoutEmbeddedObject(layoutObject).plugin();
   return plugin ? plugin->platformLayer() : nullptr;
 }
 
 static inline bool isAcceleratedContents(LayoutObject& layoutObject) {
-  return isAcceleratedCanvas(layoutObject) ||
+  return isCompositedCanvas(layoutObject) ||
          (layoutObject.isEmbeddedObject() &&
           toLayoutEmbeddedObject(layoutObject)
               .requiresAcceleratedCompositing()) ||
          layoutObject.isVideo();
 }
 
 // Get the scrolling coordinator in a way that works inside
 // CompositedLayerMapping's destructor.
 static ScrollingCoordinator* scrollingCoordinatorFromLayer(PaintLayer& layer) {
   Page* page = layer.layoutObject().frame()->page();
@@ skipping 265 matching lines @@
       paintLocation & BackgroundPaintInGraphicsLayer;
   if (shouldPaintOntoGraphicsLayer != !!m_backgroundPaintsOntoGraphicsLayer) {
     m_backgroundPaintsOntoGraphicsLayer = shouldPaintOntoGraphicsLayer;
     // The graphics layer needs to be updated for changed
     // m_backgroundPaintsOntoGraphicsLayer.
     m_graphicsLayer->setNeedsDisplay();
   }
 }
 
 void CompositedLayerMapping::updateContentsOpaque() {
-  if (isAcceleratedCanvas(layoutObject())) {
+  if (isCompositedCanvas(layoutObject())) {
     CanvasRenderingContext* context =
         toHTMLCanvasElement(layoutObject().node())->renderingContext();
     WebLayer* layer = context ? context->platformLayer() : nullptr;
     // Determine whether the external texture layer covers the whole graphics
     // layer. This may not be the case if there are box decorations or
     // shadows.
     if (layer &&
         layer->bounds() == m_graphicsLayer->platformLayer()->bounds()) {
       // Determine whether the rendering context's external texture layer is
       // opaque.
@@ skipping 349 matching lines @@
       m_graphicsLayer->setContentsToPlatformLayer(layer);
     }
   } else if (layoutObject.isVideo()) {
     HTMLMediaElement* mediaElement = toHTMLMediaElement(layoutObject.node());
     m_graphicsLayer->setContentsToPlatformLayer(mediaElement->platformLayer());
   } else if (isPlaceholderCanvas(layoutObject)) {
     HTMLCanvasElement* canvas = toHTMLCanvasElement(layoutObject.node());
     m_graphicsLayer->setContentsToPlatformLayer(
         canvas->surfaceLayerBridge()->getWebLayer());
     layerConfigChanged = true;
-  } else if (isAcceleratedCanvas(layoutObject)) {
+  } else if (isCompositedCanvas(layoutObject)) {
     HTMLCanvasElement* canvas = toHTMLCanvasElement(layoutObject.node());
     if (CanvasRenderingContext* context = canvas->renderingContext())
       m_graphicsLayer->setContentsToPlatformLayer(context->platformLayer());
     layerConfigChanged = true;
   }
   if (layoutObject.isLayoutPart()) {
     if (PaintLayerCompositor::attachFrameContentLayersToIframeLayer(
             toLayoutPart(layoutObject)))
       layerConfigChanged = true;
   }
@@ skipping 923 matching lines @@
     // contents need to paint.
     m_scrollingContentsAreEmpty =
         !m_owningLayer.hasVisibleContent() ||
         !(layoutObject().styleRef().hasBackground() ||
           layoutObject().hasBackdropFilter() || paintsChildren());
     m_scrollingContentsLayer->setDrawsContent(!m_scrollingContentsAreEmpty);
   }
 
   m_drawsBackgroundOntoContentLayer = false;
 
-  if (hasPaintedContent && isAcceleratedCanvas(layoutObject())) {
+  if (hasPaintedContent && isCompositedCanvas(layoutObject())) {
     CanvasRenderingContext* context =
         toHTMLCanvasElement(layoutObject().node())->renderingContext();
     // Content layer may be null if context is lost.
     if (WebLayer* contentLayer = context->platformLayer()) {
       Color bgColor(Color::transparent);
       if (contentLayerSupportsDirectBackgroundComposition(layoutObject())) {
         bgColor = layoutObjectBackgroundColor();
         hasPaintedContent = false;
         m_drawsBackgroundOntoContentLayer = true;
       }
@@ skipping 900 matching lines @@
   return false;
 }
 
 void CompositedLayerMapping::contentChanged(ContentChangeType changeType) {
   if ((changeType == ImageChanged) && layoutObject().isImage() &&
       isDirectlyCompositedImage()) {
     updateImageContents();
     return;
   }
 
-  if (changeType == CanvasChanged && isAcceleratedCanvas(layoutObject())) {
+  if (changeType == CanvasChanged && isCompositedCanvas(layoutObject())) {
     m_graphicsLayer->setContentsNeedsDisplay();
     return;
   }
 }
 
 void CompositedLayerMapping::updateImageContents() {
   DCHECK(layoutObject().isImage());
   LayoutImage& imageLayoutObject = toLayoutImage(layoutObject());
 
   ImageResourceContent* cachedImage = imageLayoutObject.cachedImage();
@@ skipping 858 matching lines @@
   } else if (graphicsLayer == m_decorationOutlineLayer.get()) {
     name = "Decoration Layer";
   } else {
     NOTREACHED();
   }
 
   return name;
 }
 
 }  // namespace blink