cc: Rename Texture class to Resource.

cc/direct_renderer.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/direct_renderer.h"
 
 #include <vector>
 
@@ skipping 104 matching lines @@
 {
 }
 
 void DirectRenderer::decideRenderPassAllocationsForFrame(const RenderPassList& renderPassesInDrawOrder)
 {
     base::hash_map<RenderPass::Id, const RenderPass*> renderPassesInFrame;
     for (size_t i = 0; i < renderPassesInDrawOrder.size(); ++i)
         renderPassesInFrame.insert(std::pair<RenderPass::Id, const RenderPass*>(renderPassesInDrawOrder[i]->id(), renderPassesInDrawOrder[i]));
 
     std::vector<RenderPass::Id> passesToDelete;
-    ScopedPtrHashMap<RenderPass::Id, CachedTexture>::const_iterator passIterator;
+    ScopedPtrHashMap<RenderPass::Id, CachedResource>::const_iterator passIterator;
     for (passIterator = m_renderPassTextures.begin(); passIterator != m_renderPassTextures.end(); ++passIterator) {
         base::hash_map<RenderPass::Id, const RenderPass*>::const_iterator it = renderPassesInFrame.find(passIterator->first);
         if (it == renderPassesInFrame.end()) {
             passesToDelete.push_back(passIterator->first);
             continue;
         }
 
         const RenderPass* renderPassInFrame = it->second;
         const gfx::Size& requiredSize = renderPassTextureSize(renderPassInFrame);
         GLenum requiredFormat = renderPassTextureFormat(renderPassInFrame);
-        CachedTexture* texture = passIterator->second;
+        CachedResource* texture = passIterator->second;
         DCHECK(texture);
 
         if (texture->id() && (texture->size() != requiredSize || texture->format() != requiredFormat))
             texture->free();
     }
 
     // Delete RenderPass textures from the previous frame that will not be used again.
     for (size_t i = 0; i < passesToDelete.size(); ++i)
         m_renderPassTextures.erase(passesToDelete[i]);
 
     for (size_t i = 0; i < renderPassesInDrawOrder.size(); ++i) {
         if (!m_renderPassTextures.contains(renderPassesInDrawOrder[i]->id())) {
-          scoped_ptr<CachedTexture> texture = CachedTexture::create(m_resourceProvider);
+          scoped_ptr<CachedResource> texture = CachedResource::create(m_resourceProvider);
             m_renderPassTextures.set(renderPassesInDrawOrder[i]->id(), texture.Pass());
         }
     }
 }
 
 void DirectRenderer::drawFrame(const RenderPassList& renderPassesInDrawOrder, const RenderPassIdHashMap& renderPassesById)
 {
     const RenderPass* rootRenderPass = renderPassesInDrawOrder.back();
     DCHECK(rootRenderPass);
 
@@ skipping 26 matching lines @@
 
     const QuadList& quadList = renderPass->quadList();
     for (QuadList::constBackToFrontIterator it = quadList.backToFrontBegin(); it != quadList.backToFrontEnd(); ++it) {
         gfx::RectF quadScissorRect = gfx::IntersectRects(frame.scissorRectInRenderPassSpace, (*it)->clippedRectInTarget());
         if (!quadScissorRect.IsEmpty()) {
             setScissorTestRect(moveScissorToWindowSpace(frame, quadScissorRect));
             drawQuad(frame, *it);
         }
     }
 
-    CachedTexture* texture = m_renderPassTextures.get(renderPass->id());
+    CachedResource* texture = m_renderPassTextures.get(renderPass->id());
     if (texture)
         texture->setIsComplete(!renderPass->hasOcclusionFromOutsideTargetSurface());
 }
 
 bool DirectRenderer::useRenderPass(DrawingFrame& frame, const RenderPass* renderPass)
 {
     frame.currentRenderPass = renderPass;
     frame.currentTexture = 0;
 
     if (renderPass == frame.rootRenderPass) {
         bindFramebufferToOutputSurface(frame);
         initializeMatrices(frame, renderPass->outputRect(), flippedFramebuffer());
         setDrawViewportSize(renderPass->outputRect().size());
         return true;
     }
 
-    CachedTexture* texture = m_renderPassTextures.get(renderPass->id());
+    CachedResource* texture = m_renderPassTextures.get(renderPass->id());
     DCHECK(texture);
     if (!texture->id() && !texture->allocate(Renderer::ImplPool, renderPassTextureSize(renderPass), renderPassTextureFormat(renderPass), ResourceProvider::TextureUsageFramebuffer))
         return false;
 
     return bindFramebufferToTexture(frame, texture, renderPass->outputRect());
 }
 
 bool DirectRenderer::haveCachedResourcesForRenderPassId(RenderPass::Id id) const
 {
-    CachedTexture* texture = m_renderPassTextures.get(id);
+    CachedResource* texture = m_renderPassTextures.get(id);
     return texture && texture->id() && texture->isComplete();
 }
 
 // static
 gfx::Size DirectRenderer::renderPassTextureSize(const RenderPass* pass)
 {
     return pass->outputRect().size();
 }
 
 // static
 GLenum DirectRenderer::renderPassTextureFormat(const RenderPass*)
 {
     return GL_RGBA;
 }
 
 }  // namespace cc