cc: Rename cc classes and members to match filenames

cc/test/tiled_layer_test_common.cc

 // Copyright 2012 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/test/tiled_layer_test_common.h"
 
 using namespace cc;
 
 namespace WebKitTests {
 
-FakeLayerTextureUpdater::Texture::Texture(FakeLayerTextureUpdater* layer, scoped_ptr<CCPrioritizedTexture> texture)
+FakeLayerTextureUpdater::Texture::Texture(FakeLayerTextureUpdater* layer, scoped_ptr<PrioritizedTexture> texture)
     : LayerTextureUpdater::Texture(texture.Pass())
     , m_layer(layer)
 {
 }
 
 FakeLayerTextureUpdater::Texture::~Texture()
 {
 }
 
-void FakeLayerTextureUpdater::Texture::update(CCTextureUpdateQueue& queue, const IntRect&, const IntSize&, bool partialUpdate, CCRenderingStats&)
+void FakeLayerTextureUpdater::Texture::update(TextureUpdateQueue& queue, const IntRect&, const IntSize&, bool partialUpdate, RenderingStats&)
 {
     TextureUploader::Parameters upload = { texture(), NULL, NULL, { IntRect(), IntRect(), IntSize() } };
     if (partialUpdate)
         queue.appendPartialUpload(upload);
     else
         queue.appendFullUpload(upload);
 
     m_layer->update();
 }
 
 FakeLayerTextureUpdater::FakeLayerTextureUpdater()
     : m_prepareCount(0)
     , m_updateCount(0)
 {
 }
 
 FakeLayerTextureUpdater::~FakeLayerTextureUpdater()
 {
 }
 
-void FakeLayerTextureUpdater::prepareToUpdate(const IntRect& contentRect, const IntSize&, float, float, IntRect& resultingOpaqueRect, CCRenderingStats&)
+void FakeLayerTextureUpdater::prepareToUpdate(const IntRect& contentRect, const IntSize&, float, float, IntRect& resultingOpaqueRect, RenderingStats&)
 {
     m_prepareCount++;
     m_lastUpdateRect = contentRect;
     if (!m_rectToInvalidate.isEmpty()) {
         m_layer->invalidateContentRect(m_rectToInvalidate);
         m_rectToInvalidate = IntRect();
         m_layer = NULL;
     }
     resultingOpaqueRect = m_opaquePaintRect;
 }
 
-void FakeLayerTextureUpdater::setRectToInvalidate(const IntRect& rect, FakeTiledLayerChromium* layer)
+void FakeLayerTextureUpdater::setRectToInvalidate(const IntRect& rect, FakeTiledLayer* layer)
 {
     m_rectToInvalidate = rect;
     m_layer = layer;
 }
 
-scoped_ptr<LayerTextureUpdater::Texture> FakeLayerTextureUpdater::createTexture(CCPrioritizedTextureManager* manager)
+scoped_ptr<LayerTextureUpdater::Texture> FakeLayerTextureUpdater::createTexture(PrioritizedTextureManager* manager)
 {
-    return scoped_ptr<LayerTextureUpdater::Texture>(new Texture(this, CCPrioritizedTexture::create(manager)));
+    return scoped_ptr<LayerTextureUpdater::Texture>(new Texture(this, PrioritizedTexture::create(manager)));
 }
 
 LayerTextureUpdater::SampledTexelFormat FakeLayerTextureUpdater::sampledTexelFormat(GC3Denum)
 {
     return SampledTexelFormatRGBA;
 }
 
-FakeCCTiledLayerImpl::FakeCCTiledLayerImpl(int id)
-    : CCTiledLayerImpl(id)
+FakeTiledLayerImpl::FakeTiledLayerImpl(int id)
+    : TiledLayerImpl(id)
 {
 }
 
-FakeCCTiledLayerImpl::~FakeCCTiledLayerImpl()
+FakeTiledLayerImpl::~FakeTiledLayerImpl()
 {
 }
 
-FakeTiledLayerChromium::FakeTiledLayerChromium(CCPrioritizedTextureManager* textureManager)
-    : TiledLayerChromium()
+FakeTiledLayer::FakeTiledLayer(PrioritizedTextureManager* textureManager)
+    : TiledLayer()
     , m_fakeTextureUpdater(make_scoped_refptr(new FakeLayerTextureUpdater))
     , m_textureManager(textureManager)
 {
     setTileSize(tileSize());
     setTextureFormat(GraphicsContext3D::RGBA);
-    setBorderTexelOption(CCLayerTilingData::NoBorderTexels);
+    setBorderTexelOption(LayerTilingData::NoBorderTexels);
     setIsDrawable(true); // So that we don't get false positives if any of these tests expect to return false from drawsContent() for other reasons.
 }
 
-FakeTiledLayerWithScaledBounds::FakeTiledLayerWithScaledBounds(CCPrioritizedTextureManager* textureManager)
-    : FakeTiledLayerChromium(textureManager)
+FakeTiledLayerWithScaledBounds::FakeTiledLayerWithScaledBounds(PrioritizedTextureManager* textureManager)
+    : FakeTiledLayer(textureManager)
 {
 }
 
 FakeTiledLayerWithScaledBounds::~FakeTiledLayerWithScaledBounds()
 {
 }
 
-FakeTiledLayerChromium::~FakeTiledLayerChromium()
+FakeTiledLayer::~FakeTiledLayer()
 {
 }
 
-void FakeTiledLayerChromium::setNeedsDisplayRect(const FloatRect& rect)
+void FakeTiledLayer::setNeedsDisplayRect(const FloatRect& rect)
 {
     m_lastNeedsDisplayRect = rect;
-    TiledLayerChromium::setNeedsDisplayRect(rect);
+    TiledLayer::setNeedsDisplayRect(rect);
 }
 
-void FakeTiledLayerChromium::setTexturePriorities(const CCPriorityCalculator& calculator)
+void FakeTiledLayer::setTexturePriorities(const PriorityCalculator& calculator)
 {
     // Ensure there is always a target render surface available. If none has been
     // set (the layer is an orphan for the test), then just set a surface on itself.
     bool missingTargetRenderSurface = !renderTarget();
 
     if (missingTargetRenderSurface)
         createRenderSurface();
 
-    TiledLayerChromium::setTexturePriorities(calculator);
+    TiledLayer::setTexturePriorities(calculator);
 
     if (missingTargetRenderSurface) {
         clearRenderSurface();
         setRenderTarget(0);
     }
 }
 
-cc::CCPrioritizedTextureManager* FakeTiledLayerChromium::textureManager() const
+cc::PrioritizedTextureManager* FakeTiledLayer::textureManager() const
 {
     return m_textureManager;
 }
 
-cc::LayerTextureUpdater* FakeTiledLayerChromium::textureUpdater() const
+cc::LayerTextureUpdater* FakeTiledLayer::textureUpdater() const
 {
     return m_fakeTextureUpdater.get();
 }
 
 cc::IntSize FakeTiledLayerWithScaledBounds::contentBounds() const
 {
     return m_forcedContentBounds;
 }
 
 size_t FakeTextureUploader::numBlockingUploads()
 {
     return 0;
 }
 
 void FakeTextureUploader::markPendingUploadsAsNonBlocking()
 {
 }
 
-void FakeTextureUploader::uploadTexture(cc::CCResourceProvider* resourceProvider, Parameters upload)
+void FakeTextureUploader::uploadTexture(cc::ResourceProvider* resourceProvider, Parameters upload)
 {
     upload.texture->acquireBackingTexture(resourceProvider);
 }
 
 double FakeTextureUploader::estimatedTexturesPerSecond()
 {
     return std::numeric_limits<double>::max();
 }
 
 } // namespace