cc: Rename TextureUpdate to ResourceUpdate.

cc/image_layer.cc

 // Copyright 2010 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/image_layer.h"
 
 #include "base/compiler_specific.h"
 #include "cc/layer_updater.h"
 #include "cc/layer_tree_host.h"
-#include "cc/texture_update_queue.h"
+#include "cc/resource_update_queue.h"
 
 namespace cc {
 
 class ImageLayerUpdater : public LayerUpdater {
 public:
     class Resource : public LayerUpdater::Resource {
     public:
         Resource(ImageLayerUpdater* updater, scoped_ptr<PrioritizedTexture> texture)
             : LayerUpdater::Resource(texture.Pass())
             , m_updater(updater)
         {
         }
 
-        virtual void update(TextureUpdateQueue& queue, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate, RenderingStats&) OVERRIDE
+        virtual void update(ResourceUpdateQueue& queue, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate, RenderingStats&) OVERRIDE
         {
             updater()->updateTexture(queue, texture(), sourceRect, destOffset, partialUpdate);
         }
 
     private:
         ImageLayerUpdater* updater() { return m_updater; }
 
         ImageLayerUpdater* m_updater;
     };
 
     static scoped_refptr<ImageLayerUpdater> create()
     {
         return make_scoped_refptr(new ImageLayerUpdater());
     }
 
     virtual scoped_ptr<LayerUpdater::Resource> createResource(
         PrioritizedTextureManager* manager) OVERRIDE
     {
         return scoped_ptr<LayerUpdater::Resource>(new Resource(this, PrioritizedTexture::create(manager)));
     }
 
-    void updateTexture(TextureUpdateQueue& queue, PrioritizedTexture* texture, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate)
+    void updateTexture(ResourceUpdateQueue& queue, PrioritizedTexture* texture, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate)
     {
         // Source rect should never go outside the image pixels, even if this
         // is requested because the texture extends outside the image.
         IntRect clippedSourceRect = sourceRect;
         IntRect imageRect = IntRect(0, 0, m_bitmap.width(), m_bitmap.height());
         clippedSourceRect.intersect(imageRect);
 
         IntSize clippedDestOffset = destOffset + IntSize(clippedSourceRect.location() - sourceRect.location());
 
         ResourceUpdate upload = ResourceUpdate::Create(texture,
@@ skipping 47 matching lines @@
 }
 
 void ImageLayer::setTexturePriorities(const PriorityCalculator& priorityCalc)
 {
     // Update the tile data before creating all the layer's tiles.
     updateTileSizeAndTilingOption();
 
     TiledLayer::setTexturePriorities(priorityCalc);
 }
 
-void ImageLayer::update(TextureUpdateQueue& queue, const OcclusionTracker* occlusion, RenderingStats& stats)
+void ImageLayer::update(ResourceUpdateQueue& queue, const OcclusionTracker* occlusion, RenderingStats& stats)
 {
     createUpdaterIfNeeded();
     if (m_needsDisplay) {
         m_updater->setBitmap(m_bitmap);
         updateTileSizeAndTilingOption();
         invalidateContentRect(IntRect(IntPoint(), contentBounds()));
         m_needsDisplay = false;
     }
     TiledLayer::update(queue, occlusion, stats);
 }
@@ skipping 23 matching lines @@
     return !m_bitmap.isNull() && TiledLayer::drawsContent();
 }
 
 bool ImageLayer::needsContentsScale() const
 {
     // Contents scale is not need for image layer because this can be done in compositor more efficiently.
     return false;
 }
 
 }