Remove TiledBacking / TileCache code

Source/WebCore/rendering/RenderLayerBacking.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 35 matching lines @@
 #include "RenderApplet.h"
 #include "RenderIFrame.h"
 #include "RenderImage.h"
 #include "RenderLayerCompositor.h"
 #include "RenderEmbeddedObject.h"
 #include "RenderVideo.h"
 #include "RenderView.h"
 #include "ScrollingCoordinator.h"
 #include "Settings.h"
 #include "StyleResolver.h"
-#include "TiledBacking.h"
 #include "WebCoreMemoryInstrumentation.h"
 #include <wtf/CurrentTime.h>
 #include <wtf/text/StringBuilder.h>
 
 #if ENABLE(CSS_FILTERS)
 #include "FilterEffectRenderer.h"
 #include "CustomFilterOperation.h"
 #endif
 
 #include "GraphicsContext3D.h"
@@ skipping 25 matching lines @@
         return 0;
 
     return page->scrollingCoordinator();
 }
 
 RenderLayerBacking::RenderLayerBacking(RenderLayer* layer)
     : m_owningLayer(layer)
     , m_artificiallyInflatedBounds(false)
     , m_boundsConstrainedByClipping(false)
     , m_isMainFrameRenderViewLayer(false)
-    , m_usingTiledCacheLayer(false)
     , m_requiresOwnBackingStore(true)
 #if ENABLE(CSS_FILTERS)
     , m_canCompositeFilters(false)
 #endif
     , m_backgroundLayerPaintsFixedRootBackground(false)
 {
     if (layer->isRootLayer()) {
         Frame* frame = toRenderView(renderer())->frameView()->frame();
         Page* page = frame ? frame->page() : 0;
         if (page && frame && page->mainFrame() == frame) {
             m_isMainFrameRenderViewLayer = true;
-
-#if PLATFORM(MAC)
-            // FIXME: It's a little weird that we base this decision on whether there's a scrolling coordinator or not.
-            if (page->scrollingCoordinator())
-                m_usingTiledCacheLayer = true;
-#endif
         }
     }
     
     createPrimaryGraphicsLayer();
 }
 
 RenderLayerBacking::~RenderLayerBacking()
 {
     updateClippingLayers(false, false);
     updateOverflowControlsLayers(false, false, false);
@@ skipping 68 matching lines @@
 
 void RenderLayerBacking::createPrimaryGraphicsLayer()
 {
     String layerName;
 #ifndef NDEBUG
     layerName = m_owningLayer->name();
 #endif
     
     m_graphicsLayer = createGraphicsLayer(layerName);
 
-    if (m_usingTiledCacheLayer)
-        m_childContainmentLayer = createGraphicsLayer("TiledBacking Flattening Layer");
-
     if (m_isMainFrameRenderViewLayer) {
         m_graphicsLayer->setContentsOpaque(true);
         m_graphicsLayer->setAppliesPageScale();
     }
 
     updateOpacity(renderer()->style());
     updateTransform(renderer()->style());
 #if ENABLE(CSS_FILTERS)
     updateFilters(renderer()->style());
 #endif
@@ skipping 84 matching lines @@
     
     return false;
 }
 
 bool RenderLayerBacking::shouldClipCompositedBounds() const
 {
     // Scrollbar layers use this layer for relative positioning, so don't clip.
     if (layerForHorizontalScrollbar() || layerForVerticalScrollbar())
         return false;
 
-    if (m_usingTiledCacheLayer)
-        return false;
-
     if (!compositor()->compositingConsultsOverlap())
         return false;
 
     if (layerOrAncestorIsTransformedOrUsingCompositedScrolling(m_owningLayer))
         return false;
 
     return true;
 }
 
 void RenderLayerBacking::updateCompositedBounds()
@@ skipping 104 matching lines @@
 
     if (updateOverflowControlsLayers(requiresHorizontalScrollbarLayer(), requiresVerticalScrollbarLayer(), requiresScrollCornerLayer()))
         layerConfigChanged = true;
 
     if (updateScrollingLayers(m_owningLayer->needsCompositedScrolling()))
         layerConfigChanged = true;
 
     if (layerConfigChanged)
         updateInternalHierarchy();
 
-    if (GraphicsLayer* flatteningLayer = tileCacheFlatteningLayer()) {
-        flatteningLayer->removeFromParent();
-        m_graphicsLayer->addChild(flatteningLayer);
-    }
-
     if (updateMaskLayer(renderer->hasMask()))
         m_graphicsLayer->setMaskLayer(m_maskLayer.get());
 
     if (m_owningLayer->hasReflection()) {
         if (m_owningLayer->reflectionLayer()->backing()) {
             GraphicsLayer* reflectionLayer = m_owningLayer->reflectionLayer()->backing()->graphicsLayer();
             m_graphicsLayer->setReplicatedByLayer(reflectionLayer);
         }
     } else
         m_graphicsLayer->setReplicatedByLayer(0);
@@ skipping 425 matching lines @@
             m_ancestorClippingLayer->setMasksToBounds(true);
             layersChanged = true;
         }
     } else if (m_ancestorClippingLayer) {
         m_ancestorClippingLayer->removeFromParent();
         m_ancestorClippingLayer = nullptr;
         layersChanged = true;
     }
     
     if (needsDescendantClip) {
-        if (!m_childContainmentLayer && !m_usingTiledCacheLayer) {
+        if (!m_childContainmentLayer) {
             m_childContainmentLayer = createGraphicsLayer("Child clipping Layer");
             m_childContainmentLayer->setMasksToBounds(true);
             layersChanged = true;
         }
     } else if (hasClippingLayer()) {
         m_childContainmentLayer->removeFromParent();
         m_childContainmentLayer = nullptr;
         layersChanged = true;
     }
     
@@ skipping 297 matching lines @@
     Color backgroundColor;
     if (isSimpleContainer)
         backgroundColor = rendererBackgroundColor();
 
     // An unset (invalid) color will remove the solid color.
     m_graphicsLayer->setContentsToSolidColor(backgroundColor);
 }
 
 void RenderLayerBacking::updateRootLayerConfiguration()
 {
-    if (!m_usingTiledCacheLayer)
-        return;
-
-    Color backgroundColor;
-    bool viewIsTransparent = compositor()->viewHasTransparentBackground(&backgroundColor);
-
-    if (m_backgroundLayerPaintsFixedRootBackground && m_backgroundLayer) {
-        m_backgroundLayer->setBackgroundColor(backgroundColor);
-        m_backgroundLayer->setContentsOpaque(!viewIsTransparent);
-
-        m_graphicsLayer->setBackgroundColor(Color());
-        m_graphicsLayer->setContentsOpaque(false);
-    } else {
-        m_graphicsLayer->setBackgroundColor(backgroundColor);
-        m_graphicsLayer->setContentsOpaque(!viewIsTransparent);
-    }
 }
 
 static bool supportsDirectBoxDecorationsComposition(const RenderObject* renderer)
 {
     if (!GraphicsLayer::supportsBackgroundColorContent())
         return false;
 
     if (renderer->hasClip())
         return false;
 
@@ skipping 323 matching lines @@
         return m_ancestorClippingLayer.get();
 
     if (m_contentsContainmentLayer)
         return m_contentsContainmentLayer.get();
     
     return m_graphicsLayer.get();
 }
 
 bool RenderLayerBacking::paintsIntoWindow() const
 {
-    if (m_usingTiledCacheLayer)
-        return false;
-
     if (m_owningLayer->isRootLayer()) {
         return compositor()->rootLayerAttachment() != RenderLayerCompositor::RootLayerAttachedViaEnclosingFrame;
     }
     
     return false;
 }
 
 void RenderLayerBacking::setRequiresOwnBackingStore(bool requiresOwnBacking)
 {
     if (requiresOwnBacking == m_requiresOwnBackingStore)
@@ skipping 140 matching lines @@
         InspectorInstrumentation::willPaint(renderer());
 
         // The dirtyRect is in the coords of the painting root.
         IntRect dirtyRect = clip;
         if (!(paintingPhase & GraphicsLayerPaintOverflowContents))
             dirtyRect.intersect(compositedBounds());
 
         // We have to use the same root as for hit testing, because both methods can compute and cache clipRects.
         paintIntoLayer(graphicsLayer, &context, dirtyRect, PaintBehaviorNormal, paintingPhase);
 
-        if (m_usingTiledCacheLayer)
-            renderer()->frame()->view()->setLastPaintTime(currentTime());
-
         InspectorInstrumentation::didPaint(renderer(), &context, clip);
     } else if (graphicsLayer == layerForHorizontalScrollbar()) {
         paintScrollbar(m_owningLayer->horizontalScrollbar(), context, clip);
     } else if (graphicsLayer == layerForVerticalScrollbar()) {
         paintScrollbar(m_owningLayer->verticalScrollbar(), context, clip);
     } else if (graphicsLayer == layerForScrollCorner()) {
         const IntRect& scrollCornerAndResizer = m_owningLayer->scrollCornerAndResizerRect();
         context.save();
         context.translate(-scrollCornerAndResizer.x(), -scrollCornerAndResizer.y());
         IntRect transformedClip = clip;
@@ skipping 325 matching lines @@
     info.addMember(m_childContainmentLayer, "childContainmentLayer");
     info.addMember(m_maskLayer, "maskLayer");
     info.addMember(m_layerForHorizontalScrollbar, "layerForHorizontalScrollbar");
     info.addMember(m_layerForVerticalScrollbar, "layerForVerticalScrollbar");
     info.addMember(m_layerForScrollCorner, "layerForScrollCorner");
     info.addMember(m_scrollingLayer, "scrollingLayer");
     info.addMember(m_scrollingContentsLayer, "scrollingContentsLayer");
 }
 
 } // namespace WebCore