cc: Rename cc classes and members to match filenames

cc/tiled_layer.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 
 #include "cc/tiled_layer.h"
 
 #include "CCLayerImpl.h"
 #include "CCLayerTreeHost.h"
 #include "CCOverdrawMetrics.h"
 #include "CCTextureUpdateQueue.h"
 #include "CCTiledLayerImpl.h"
 #include "Region.h"
 #include "base/basictypes.h"
 
 using namespace std;
 using WebKit::WebTransformationMatrix;
 
 namespace cc {
 
-class UpdatableTile : public CCLayerTilingData::Tile {
+class UpdatableTile : public LayerTilingData::Tile {
 public:
     static scoped_ptr<UpdatableTile> create(scoped_ptr<LayerTextureUpdater::Texture> texture)
     {
         return make_scoped_ptr(new UpdatableTile(texture.Pass()));
     }
 
     LayerTextureUpdater::Texture* texture() { return m_texture.get(); }
-    CCPrioritizedTexture* managedTexture() { return m_texture->texture(); }
+    PrioritizedTexture* managedTexture() { return m_texture->texture(); }
 
     bool isDirty() const { return !dirtyRect.isEmpty(); }
 
     // Reset update state for the current frame. This should occur before painting
     // for all layers. Since painting one layer can invalidate another layer
     // after it has already painted, mark all non-dirty tiles as valid before painting
     // such that invalidations during painting won't prevent them from being pushed.
     void resetUpdateState()
     {
         updateRect = IntRect();
@@ skipping 27 matching lines @@
         , isInUseOnImpl(false)
         , m_texture(texture.Pass())
     {
     }
 
     scoped_ptr<LayerTextureUpdater::Texture> m_texture;
 
     DISALLOW_COPY_AND_ASSIGN(UpdatableTile);
 };
 
-TiledLayerChromium::TiledLayerChromium()
-    : LayerChromium()
+TiledLayer::TiledLayer()
+    : Layer()
     , m_textureFormat(GraphicsContext3D::INVALID_ENUM)
     , m_skipsDraw(false)
     , m_failedUpdate(false)
     , m_sampledTexelFormat(LayerTextureUpdater::SampledTexelFormatInvalid)
     , m_tilingOption(AutoTile)
 {
-    m_tiler = CCLayerTilingData::create(IntSize(), CCLayerTilingData::HasBorderTexels);
+    m_tiler = LayerTilingData::create(IntSize(), LayerTilingData::HasBorderTexels);
 }
 
-TiledLayerChromium::~TiledLayerChromium()
+TiledLayer::~TiledLayer()
 {
 }
 
-scoped_ptr<CCLayerImpl> TiledLayerChromium::createCCLayerImpl()
+scoped_ptr<LayerImpl> TiledLayer::createLayerImpl()
 {
-    return CCTiledLayerImpl::create(id()).PassAs<CCLayerImpl>();
+    return TiledLayerImpl::create(id()).PassAs<LayerImpl>();
 }
 
-void TiledLayerChromium::updateTileSizeAndTilingOption()
+void TiledLayer::updateTileSizeAndTilingOption()
 {
     ASSERT(layerTreeHost());
 
     const IntSize& defaultTileSize = layerTreeHost()->settings().defaultTileSize;
     const IntSize& maxUntiledLayerSize = layerTreeHost()->settings().maxUntiledLayerSize;
     int layerWidth = contentBounds().width();
     int layerHeight = contentBounds().height();
 
     const IntSize tileSize(min(defaultTileSize.width(), layerWidth), min(defaultTileSize.height(), layerHeight));
 
@@ skipping 14 matching lines @@
         isTiled = false;
     else
         isTiled = autoTiled;
 
     IntSize requestedSize = isTiled ? tileSize : contentBounds();
     const int maxSize = layerTreeHost()->rendererCapabilities().maxTextureSize;
     IntSize clampedSize = requestedSize.shrunkTo(IntSize(maxSize, maxSize));
     setTileSize(clampedSize);
 }
 
-void TiledLayerChromium::updateBounds()
+void TiledLayer::updateBounds()
 {
     IntSize oldBounds = m_tiler->bounds();
     IntSize newBounds = contentBounds();
     if (oldBounds == newBounds)
         return;
     m_tiler->setBounds(newBounds);
 
     // Invalidate any areas that the new bounds exposes.
     Region oldRegion(IntRect(IntPoint(), oldBounds));
     Region newRegion(IntRect(IntPoint(), newBounds));
     newRegion.subtract(oldRegion);
     Vector<WebCore::IntRect> rects = newRegion.rects();
     for (size_t i = 0; i < rects.size(); ++i)
         invalidateContentRect(rects[i]);
 }
 
-void TiledLayerChromium::setTileSize(const IntSize& size)
+void TiledLayer::setTileSize(const IntSize& size)
 {
     m_tiler->setTileSize(size);
 }
 
-void TiledLayerChromium::setBorderTexelOption(CCLayerTilingData::BorderTexelOption borderTexelOption)
+void TiledLayer::setBorderTexelOption(LayerTilingData::BorderTexelOption borderTexelOption)
 {
     m_tiler->setBorderTexelOption(borderTexelOption);
 }
 
-bool TiledLayerChromium::drawsContent() const
+bool TiledLayer::drawsContent() const
 {
-    if (!LayerChromium::drawsContent())
+    if (!Layer::drawsContent())
         return false;
 
     bool hasMoreThanOneTile = m_tiler->numTilesX() > 1 || m_tiler->numTilesY() > 1;
     if (m_tilingOption == NeverTile && hasMoreThanOneTile)
         return false;
 
     return true;
 }
 
-bool TiledLayerChromium::needsContentsScale() const
+bool TiledLayer::needsContentsScale() const
 {
     return true;
 }
 
-IntSize TiledLayerChromium::contentBounds() const
+IntSize TiledLayer::contentBounds() const
 {
     return IntSize(lroundf(bounds().width() * contentsScale()), lroundf(bounds().height() * contentsScale()));
 }
 
-void TiledLayerChromium::setTilingOption(TilingOption tilingOption)
+void TiledLayer::setTilingOption(TilingOption tilingOption)
 {
     m_tilingOption = tilingOption;
 }
 
-void TiledLayerChromium::setIsMask(bool isMask)
+void TiledLayer::setIsMask(bool isMask)
 {
     setTilingOption(isMask ? NeverTile : AutoTile);
 }
 
-void TiledLayerChromium::pushPropertiesTo(CCLayerImpl* layer)
+void TiledLayer::pushPropertiesTo(LayerImpl* layer)
 {
-    LayerChromium::pushPropertiesTo(layer);
+    Layer::pushPropertiesTo(layer);
 
-    CCTiledLayerImpl* tiledLayer = static_cast<CCTiledLayerImpl*>(layer);
+    TiledLayerImpl* tiledLayer = static_cast<TiledLayerImpl*>(layer);
 
     tiledLayer->setSkipsDraw(m_skipsDraw);
     tiledLayer->setContentsSwizzled(m_sampledTexelFormat != LayerTextureUpdater::SampledTexelFormatRGBA);
     tiledLayer->setTilingData(*m_tiler);
     Vector<UpdatableTile*> invalidTiles;
 
-    for (CCLayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
+    for (LayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
         int i = iter->first.first;
         int j = iter->first.second;
         UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second);
         // FIXME: This should not ever be null.
         if (!tile)
             continue;
 
         tile->isInUseOnImpl = false;
 
         if (!tile->managedTexture()->haveBackingTexture()) {
             // Evicted tiles get deleted from both layers
             invalidTiles.append(tile);
             continue;
         }
 
         if (!tile->validForFrame) {
             // Invalidated tiles are set so they can get different debug colors.
             tiledLayer->pushInvalidTile(i, j);
             continue;
         }
 
         tiledLayer->pushTileProperties(i, j, tile->managedTexture()->resourceId(), tile->opaqueRect());
         tile->isInUseOnImpl = true;
     }
     for (Vector<UpdatableTile*>::const_iterator iter = invalidTiles.begin(); iter != invalidTiles.end(); ++iter)
         m_tiler->takeTile((*iter)->i(), (*iter)->j());
 }
 
-CCPrioritizedTextureManager* TiledLayerChromium::textureManager() const
+PrioritizedTextureManager* TiledLayer::textureManager() const
 {
     if (!layerTreeHost())
         return 0;
     return layerTreeHost()->contentsTextureManager();
 }
 
-void TiledLayerChromium::setLayerTreeHost(CCLayerTreeHost* host)
+void TiledLayer::setLayerTreeHost(LayerTreeHost* host)
 {
     if (host && host != layerTreeHost()) {
-        for (CCLayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
+        for (LayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
             UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second);
             // FIXME: This should not ever be null.
             if (!tile)
                 continue;
             tile->managedTexture()->setTextureManager(host->contentsTextureManager());
         }
     }
-    LayerChromium::setLayerTreeHost(host);
+    Layer::setLayerTreeHost(host);
 }
 
-UpdatableTile* TiledLayerChromium::tileAt(int i, int j) const
+UpdatableTile* TiledLayer::tileAt(int i, int j) const
 {
     return static_cast<UpdatableTile*>(m_tiler->tileAt(i, j));
 }
 
-UpdatableTile* TiledLayerChromium::createTile(int i, int j)
+UpdatableTile* TiledLayer::createTile(int i, int j)
 {
     createTextureUpdaterIfNeeded();
 
     scoped_ptr<UpdatableTile> tile(UpdatableTile::create(textureUpdater()->createTexture(textureManager())));
     tile->managedTexture()->setDimensions(m_tiler->tileSize(), m_textureFormat);
 
     UpdatableTile* addedTile = tile.get();
-    m_tiler->addTile(tile.PassAs<CCLayerTilingData::Tile>(), i, j);
+    m_tiler->addTile(tile.PassAs<LayerTilingData::Tile>(), i, j);
 
     addedTile->dirtyRect = m_tiler->tileRect(addedTile);
 
     // Temporary diagnostic crash.
     if (!addedTile)
         CRASH();
     if (!tileAt(i, j))
         CRASH();
 
     return addedTile;
 }
 
-void TiledLayerChromium::setNeedsDisplayRect(const FloatRect& dirtyRect)
+void TiledLayer::setNeedsDisplayRect(const FloatRect& dirtyRect)
 {
     float contentsWidthScale = static_cast<float>(contentBounds().width()) / bounds().width();
     float contentsHeightScale = static_cast<float>(contentBounds().height()) / bounds().height();
     FloatRect scaledDirtyRect(dirtyRect);
     scaledDirtyRect.scale(contentsWidthScale, contentsHeightScale);
     IntRect dirty = enclosingIntRect(scaledDirtyRect);
     invalidateContentRect(dirty);
-    LayerChromium::setNeedsDisplayRect(dirtyRect);
+    Layer::setNeedsDisplayRect(dirtyRect);
 }
 
-void TiledLayerChromium::setUseLCDText(bool useLCDText)
+void TiledLayer::setUseLCDText(bool useLCDText)
 {
-    LayerChromium::setUseLCDText(useLCDText);
+    Layer::setUseLCDText(useLCDText);
 
-    CCLayerTilingData::BorderTexelOption borderTexelOption;
+    LayerTilingData::BorderTexelOption borderTexelOption;
 #if OS(ANDROID)
     // Always want border texels and GL_LINEAR due to pinch zoom.
-    borderTexelOption = CCLayerTilingData::HasBorderTexels;
+    borderTexelOption = LayerTilingData::HasBorderTexels;
 #else
-    borderTexelOption = useLCDText ? CCLayerTilingData::NoBorderTexels : CCLayerTilingData::HasBorderTexels;
+    borderTexelOption = useLCDText ? LayerTilingData::NoBorderTexels : LayerTilingData::HasBorderTexels;
 #endif
     setBorderTexelOption(borderTexelOption);
 }
 
-void TiledLayerChromium::invalidateContentRect(const IntRect& contentRect)
+void TiledLayer::invalidateContentRect(const IntRect& contentRect)
 {
     updateBounds();
     if (m_tiler->isEmpty() || contentRect.isEmpty() || m_skipsDraw)
         return;
 
-    for (CCLayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
+    for (LayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
         UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second);
         ASSERT(tile);
         // FIXME: This should not ever be null.
         if (!tile)
             continue;
         IntRect bound = m_tiler->tileRect(tile);
         bound.intersect(contentRect);
         tile->dirtyRect.unite(bound);
     }
 }
 
 // Returns true if tile is dirty and only part of it needs to be updated.
-bool TiledLayerChromium::tileOnlyNeedsPartialUpdate(UpdatableTile* tile)
+bool TiledLayer::tileOnlyNeedsPartialUpdate(UpdatableTile* tile)
 {
     return !tile->dirtyRect.contains(m_tiler->tileRect(tile));
 }
 
 // Dirty tiles with valid textures needs buffered update to guarantee that
 // we don't modify textures currently used for drawing by the impl thread.
-bool TiledLayerChromium::tileNeedsBufferedUpdate(UpdatableTile* tile)
+bool TiledLayer::tileNeedsBufferedUpdate(UpdatableTile* tile)
 {
     if (!tile->managedTexture()->haveBackingTexture())
         return false;
 
     if (!tile->isDirty())
         return false;
 
     if (!tile->isInUseOnImpl)
         return false;
 
     return true;
 }
 
 
-bool TiledLayerChromium::updateTiles(int left, int top, int right, int bottom, CCTextureUpdateQueue& queue, const CCOcclusionTracker* occlusion, CCRenderingStats& stats, bool& didPaint)
+bool TiledLayer::updateTiles(int left, int top, int right, int bottom, TextureUpdateQueue& queue, const OcclusionTracker* occlusion, RenderingStats& stats, bool& didPaint)
 {
     didPaint = false;
     createTextureUpdaterIfNeeded();
 
     bool ignoreOcclusions = !occlusion;
     if (!haveTexturesForTiles(left, top, right, bottom, ignoreOcclusions)) {
         m_failedUpdate = true;
         return false;
     }
 
     IntRect paintRect = markTilesForUpdate(left, top, right, bottom, ignoreOcclusions);
 
     if (occlusion)
         occlusion->overdrawMetrics().didPaint(paintRect);
 
     if (paintRect.isEmpty())
         return true;
 
     didPaint = true;
     updateTileTextures(paintRect, left, top, right, bottom, queue, occlusion, stats);
     return true;
 }
 
-void TiledLayerChromium::markOcclusionsAndRequestTextures(int left, int top, int right, int bottom, const CCOcclusionTracker* occlusion)
+void TiledLayer::markOcclusionsAndRequestTextures(int left, int top, int right, int bottom, const OcclusionTracker* occlusion)
 {
     // There is some difficult dependancies between occlusions, recording occlusion metrics
     // and requesting memory so those are encapsulated in this function:
     // - We only want to call requestLate on unoccluded textures (to preserve
     //   memory for other layers when near OOM).
     // - We only want to record occlusion metrics if all memory requests succeed.
 
     int occludedTileCount = 0;
     bool succeeded = true;
     for (int j = top; j <= bottom; ++j) {
@@ skipping 15 matching lines @@
     }
 
     if (!succeeded)
         return;
 
     // FIXME: Remove the loop and just pass the count!
     for (int i = 0; i < occludedTileCount; i++)
         occlusion->overdrawMetrics().didCullTileForUpload();
 }
 
-bool TiledLayerChromium::haveTexturesForTiles(int left, int top, int right, int bottom, bool ignoreOcclusions)
+bool TiledLayer::haveTexturesForTiles(int left, int top, int right, int bottom, bool ignoreOcclusions)
 {
     for (int j = top; j <= bottom; ++j) {
         for (int i = left; i <= right; ++i) {
             UpdatableTile* tile = tileAt(i, j);
             ASSERT(tile); // Did setTexturePriorites get skipped?
             // FIXME: This should not ever be null.
             if (!tile)
                 continue;
 
             // Ensure the entire tile is dirty if we don't have the texture.
             if (!tile->managedTexture()->haveBackingTexture())
                 tile->dirtyRect = m_tiler->tileRect(tile);
 
             // If using occlusion and the visible region of the tile is occluded,
             // don't reserve a texture or update the tile.
             if (tile->occluded && !ignoreOcclusions)
                 continue;
 
             if (!tile->managedTexture()->canAcquireBackingTexture())
                 return false;
         }
     }
     return true;
 }
 
-IntRect TiledLayerChromium::markTilesForUpdate(int left, int top, int right, int bottom, bool ignoreOcclusions)
+IntRect TiledLayer::markTilesForUpdate(int left, int top, int right, int bottom, bool ignoreOcclusions)
 {
     IntRect paintRect;
     for (int j = top; j <= bottom; ++j) {
         for (int i = left; i <= right; ++i) {
             UpdatableTile* tile = tileAt(i, j);
             ASSERT(tile); // Did setTexturePriorites get skipped?
             // FIXME: This should not ever be null.
             if (!tile)
                 continue;
             if (tile->occluded && !ignoreOcclusions)
                 continue;
             paintRect.unite(tile->dirtyRect);
             tile->markForUpdate();
         }
     }
     return paintRect;
 }
 
-void TiledLayerChromium::updateTileTextures(const IntRect& paintRect, int left, int top, int right, int bottom, CCTextureUpdateQueue& queue, const CCOcclusionTracker* occlusion, CCRenderingStats& stats)
+void TiledLayer::updateTileTextures(const IntRect& paintRect, int left, int top, int right, int bottom, TextureUpdateQueue& queue, const OcclusionTracker* occlusion, RenderingStats& stats)
 {
     // The updateRect should be in layer space. So we have to convert the paintRect from content space to layer space.
     m_updateRect = FloatRect(paintRect);
     float widthScale = bounds().width() / static_cast<float>(contentBounds().width());
     float heightScale = bounds().height() / static_cast<float>(contentBounds().height());
     m_updateRect.scale(widthScale, heightScale);
 
     // Calling prepareToUpdate() calls into WebKit to paint, which may have the side
     // effect of disabling compositing, which causes our reference to the texture updater to be deleted.
     // However, we can't free the memory backing the SkCanvas until the paint finishes,
@@ skipping 67 matching lines @@
                 occlusion->overdrawMetrics().didUpload(WebTransformationMatrix(), sourceRect, tile->opaqueRect());
 
         }
     }
 }
 
 namespace {
 // This picks a small animated layer to be anything less than one viewport. This
 // is specifically for page transitions which are viewport-sized layers. The extra
 // 64 pixels is due to these layers being slightly larger than the viewport in some cases.
-bool isSmallAnimatedLayer(TiledLayerChromium* layer)
+bool isSmallAnimatedLayer(TiledLayer* layer)
 {
     if (!layer->drawTransformIsAnimating() && !layer->screenSpaceTransformIsAnimating())
         return false;
     IntSize viewportSize = layer->layerTreeHost() ? layer->layerTreeHost()->deviceViewportSize() : IntSize();
     IntRect contentRect(IntPoint::zero(), layer->contentBounds());
     return contentRect.width() <= viewportSize.width() + 64
         && contentRect.height() <= viewportSize.height() + 64;
 }
 
 // FIXME: Remove this and make this based on distance once distance can be calculated
 // for offscreen layers. For now, prioritize all small animated layers after 512
 // pixels of pre-painting.
 void setPriorityForTexture(const IntRect& visibleRect,
                            const IntRect& tileRect,
                            bool drawsToRoot,
                            bool isSmallAnimatedLayer,
-                           CCPrioritizedTexture* texture)
+                           PrioritizedTexture* texture)
 {
-    int priority = CCPriorityCalculator::lowestPriority();
+    int priority = PriorityCalculator::lowestPriority();
     if (!visibleRect.isEmpty())
-        priority = CCPriorityCalculator::priorityFromDistance(visibleRect, tileRect, drawsToRoot);
+        priority = PriorityCalculator::priorityFromDistance(visibleRect, tileRect, drawsToRoot);
     if (isSmallAnimatedLayer)
-        priority = CCPriorityCalculator::maxPriority(priority, CCPriorityCalculator::smallAnimatedLayerMinPriority());
-    if (priority != CCPriorityCalculator::lowestPriority())
+        priority = PriorityCalculator::maxPriority(priority, PriorityCalculator::smallAnimatedLayerMinPriority());
+    if (priority != PriorityCalculator::lowestPriority())
         texture->setRequestPriority(priority);
 }
 }
 
-void TiledLayerChromium::setTexturePriorities(const CCPriorityCalculator& priorityCalc)
+void TiledLayer::setTexturePriorities(const PriorityCalculator& priorityCalc)
 {
     updateBounds();
     resetUpdateState();
 
     if (m_tiler->hasEmptyBounds())
         return;
 
     bool drawsToRoot = !renderTarget()->parent();
     bool smallAnimatedLayer = isSmallAnimatedLayer(this);
 
@@ skipping 35 matching lines @@
                     continue;
                 if (tileOnlyNeedsPartialUpdate(tile) && layerTreeHost()->requestPartialTextureUpdate()) {
                     tile->partialUpdate = true;
                     continue;
                 }
 
                 IntRect tileRect = m_tiler->tileRect(tile);
                 tile->dirtyRect = tileRect;
                 LayerTextureUpdater::Texture* backBuffer = tile->texture();
                 setPriorityForTexture(visibleContentRect(), tile->dirtyRect, drawsToRoot, smallAnimatedLayer, backBuffer->texture());
-                scoped_ptr<CCPrioritizedTexture> frontBuffer = CCPrioritizedTexture::create(backBuffer->texture()->textureManager(),
+                scoped_ptr<PrioritizedTexture> frontBuffer = PrioritizedTexture::create(backBuffer->texture()->textureManager(),
                                                                                         backBuffer->texture()->size(),
                                                                                         backBuffer->texture()->format());
                 // Swap backBuffer into frontBuffer and add it to delete after commit queue.
                 backBuffer->swapTextureWith(frontBuffer);
                 layerTreeHost()->deleteTextureAfterCommit(frontBuffer.Pass());
             }
         }
     }
 
     // Now update priorities on all tiles we have in the layer, no matter where they are.
-    for (CCLayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
+    for (LayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
         UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second);
         // FIXME: This should not ever be null.
         if (!tile)
             continue;
         IntRect tileRect = m_tiler->tileRect(tile);
         setPriorityForTexture(visibleContentRect(), tileRect, drawsToRoot, smallAnimatedLayer, tile->managedTexture());
     }
 }
 
-Region TiledLayerChromium::visibleContentOpaqueRegion() const
+Region TiledLayer::visibleContentOpaqueRegion() const
 {
     if (m_skipsDraw)
         return Region();
     if (contentsOpaque())
         return visibleContentRect();
     return m_tiler->opaqueRegionInContentRect(visibleContentRect());
 }
 
-void TiledLayerChromium::resetUpdateState()
+void TiledLayer::resetUpdateState()
 {
     m_skipsDraw = false;
     m_failedUpdate = false;
 
-    CCLayerTilingData::TileMap::const_iterator end = m_tiler->tiles().end();
-    for (CCLayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != end; ++iter) {
+    LayerTilingData::TileMap::const_iterator end = m_tiler->tiles().end();
+    for (LayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != end; ++iter) {
         UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second);
         // FIXME: This should not ever be null.
         if (!tile)
             continue;
         tile->resetUpdateState();
     }
 }
 
-void TiledLayerChromium::update(CCTextureUpdateQueue& queue, const CCOcclusionTracker* occlusion, CCRenderingStats& stats)
+void TiledLayer::update(TextureUpdateQueue& queue, const OcclusionTracker* occlusion, RenderingStats& stats)
 {
     ASSERT(!m_skipsDraw && !m_failedUpdate); // Did resetUpdateState get skipped?
     updateBounds();
     if (m_tiler->hasEmptyBounds() || !drawsContent())
         return;
 
     bool didPaint = false;
 
     // Animation pre-paint. If the layer is small, try to paint it all
     // immediately whether or not it is occluded, to avoid paint/upload
@@ skipping 52 matching lines @@
                 return;
         }
         if (right < prepaintRight) {
             ++right;
             if (!updateTiles(right, top, right, bottom, queue, 0, stats, didPaint) || didPaint)
                 return;
         }
     }
 }
 
-bool TiledLayerChromium::needsIdlePaint()
+bool TiledLayer::needsIdlePaint()
 {
     // Don't trigger more paints if we failed (as we'll just fail again).
     if (m_failedUpdate || visibleContentRect().isEmpty() || m_tiler->hasEmptyBounds() || !drawsContent())
         return false;
 
     IntRect idlePaintContentRect = idlePaintRect();
     if (idlePaintContentRect.isEmpty())
         return false;
 
     int left, top, right, bottom;
     m_tiler->contentRectToTileIndices(idlePaintContentRect, left, top, right, bottom);
 
     for (int j = top; j <= bottom; ++j) {
         for (int i = left; i <= right; ++i) {
             UpdatableTile* tile = tileAt(i, j);
             ASSERT(tile); // Did setTexturePriorities get skipped?
             if (!tile)
                 continue;
 
             bool updated = !tile->updateRect.isEmpty();
             bool canAcquire = tile->managedTexture()->canAcquireBackingTexture();
             bool dirty = tile->isDirty() || !tile->managedTexture()->haveBackingTexture();
             if (!updated && canAcquire && dirty)
                 return true;
         }
     }
     return false;
 }
 
-IntRect TiledLayerChromium::idlePaintRect()
+IntRect TiledLayer::idlePaintRect()
 {
     // Don't inflate an empty rect.
     if (visibleContentRect().isEmpty())
         return IntRect();
 
     // FIXME: This can be made a lot larger now! We should increase
     //        this slowly while insuring it doesn't cause any perf issues.
     IntRect prepaintRect = visibleContentRect();
     prepaintRect.inflateX(m_tiler->tileSize().width());
     prepaintRect.inflateY(m_tiler->tileSize().height() * 2);
     IntRect contentRect(IntPoint::zero(), contentBounds());
     prepaintRect.intersect(contentRect);
 
     return prepaintRect;
 }
 
 }