cc: Rename PrioritizedTexture to PrioritizedResource.

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 {
 
-FakeLayerUpdater::Resource::Resource(FakeLayerUpdater* layer, scoped_ptr<PrioritizedTexture> texture)
+FakeLayerUpdater::Resource::Resource(FakeLayerUpdater* layer, scoped_ptr<PrioritizedResource> texture)
     : LayerUpdater::Resource(texture.Pass())
     , m_layer(layer)
 {
     m_bitmap.setConfig(SkBitmap::kARGB_8888_Config, 10, 10);
     m_bitmap.allocPixels();
 }
 
 FakeLayerUpdater::Resource::~Resource()
 {
 }
@@ skipping 32 matching lines @@
     }
     resultingOpaqueRect = m_opaquePaintRect;
 }
 
 void FakeLayerUpdater::setRectToInvalidate(const gfx::Rect& rect, FakeTiledLayer* layer)
 {
     m_rectToInvalidate = rect;
     m_layer = layer;
 }
 
-scoped_ptr<LayerUpdater::Resource> FakeLayerUpdater::createResource(PrioritizedTextureManager* manager)
+scoped_ptr<LayerUpdater::Resource> FakeLayerUpdater::createResource(PrioritizedResourceManager* manager)
 {
-    return scoped_ptr<LayerUpdater::Resource>(new Resource(this, PrioritizedTexture::create(manager)));
+    return scoped_ptr<LayerUpdater::Resource>(new Resource(this, PrioritizedResource::create(manager)));
 }
 
 FakeTiledLayerImpl::FakeTiledLayerImpl(int id)
     : TiledLayerImpl(id)
 {
 }
 
 FakeTiledLayerImpl::~FakeTiledLayerImpl()
 {
 }
 
-FakeTiledLayer::FakeTiledLayer(PrioritizedTextureManager* textureManager)
+FakeTiledLayer::FakeTiledLayer(PrioritizedResourceManager* resourceManager)
     : TiledLayer()
     , m_fakeUpdater(make_scoped_refptr(new FakeLayerUpdater))
-    , m_textureManager(textureManager)
+    , m_resourceManager(resourceManager)
 {
     setTileSize(tileSize());
     setTextureFormat(GL_RGBA);
     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(PrioritizedTextureManager* textureManager)
-    : FakeTiledLayer(textureManager)
+FakeTiledLayerWithScaledBounds::FakeTiledLayerWithScaledBounds(PrioritizedResourceManager* resourceManager)
+    : FakeTiledLayer(resourceManager)
 {
 }
 
 FakeTiledLayerWithScaledBounds::~FakeTiledLayerWithScaledBounds()
 {
 }
 
 FakeTiledLayer::~FakeTiledLayer()
 {
 }
@@ skipping 14 matching lines @@
         createRenderSurface();
 
     TiledLayer::setTexturePriorities(calculator);
 
     if (missingTargetRenderSurface) {
         clearRenderSurface();
         setRenderTarget(0);
     }
 }
 
-cc::PrioritizedTextureManager* FakeTiledLayer::textureManager() const
+cc::PrioritizedResourceManager* FakeTiledLayer::resourceManager() const
 {
-    return m_textureManager;
+    return m_resourceManager;
 }
 
 cc::LayerUpdater* FakeTiledLayer::updater() const
 {
     return m_fakeUpdater.get();
 }
 
 gfx::Size FakeTiledLayerWithScaledBounds::contentBounds() const
 {
     return m_forcedContentBounds;
 }
 
 float FakeTiledLayerWithScaledBounds::contentsScaleX() const
 {
     return static_cast<float>(m_forcedContentBounds.width()) / bounds().width();
 }
 
 float FakeTiledLayerWithScaledBounds::contentsScaleY() const
 {
     return static_cast<float>(m_forcedContentBounds.height()) / bounds().height();
 }
 
 void FakeTiledLayerWithScaledBounds::setContentsScale(float)
 {
     NOTREACHED();
 }
 
 } // namespace