cc: Rename TextureUpdate to ResourceUpdate.

sed -e '
s/TextureUpdateQueue/ResourceUpdateQueue/g
s/texture_update_queue/resource_update_queue/g
s/TextureUpdateController/ResourceUpdateController/g
s/texture_update_controller/resource_update_controller/g
'

BUG=
TEST=cc_unittests

Review URL: https://codereview.chromium.org/11270047

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@164177 0039d316-1c4b-4281-b951-d872f2087c98

39 files changed, 186 insertions, 186 deletions

diff --git a/cc/bitmap_content_layer_updater.cc b/cc/bitmap_content_layer_updater.cc
index 34e5970..66828ff 100644
--- a/cc/bitmap_content_layer_updater.cc
+++ b/cc/bitmap_content_layer_updater.cc
@@ -8,7 +8,7 @@
 
 #include "cc/layer_painter.h"
 #include "cc/resource_update.h"
-#include "cc/texture_update_queue.h"
+#include "cc/resource_update_queue.h"
 #include "skia/ext/platform_canvas.h"
 
 namespace cc {
@@ -23,7 +23,7 @@ BitmapContentLayerUpdater::Resource::~Resource()
 {
 }
 
-void BitmapContentLayerUpdater::Resource::update(TextureUpdateQueue& queue, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate, RenderingStats&)
+void BitmapContentLayerUpdater::Resource::update(ResourceUpdateQueue& queue, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate, RenderingStats&)
 {
     updater()->updateTexture(queue, texture(), sourceRect, destOffset, partialUpdate);
 }
@@ -58,7 +58,7 @@ void BitmapContentLayerUpdater::prepareToUpdate(const IntRect& contentRect, cons
     paintContents(m_canvas.get(), contentRect, contentsWidthScale, contentsHeightScale, resultingOpaqueRect, stats);
 }
 
-void BitmapContentLayerUpdater::updateTexture(TextureUpdateQueue& queue, PrioritizedTexture* texture, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate)
+void BitmapContentLayerUpdater::updateTexture(ResourceUpdateQueue& queue, PrioritizedTexture* texture, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate)
 {
     ResourceUpdate upload = ResourceUpdate::Create(
         texture,
diff --git a/cc/bitmap_content_layer_updater.h b/cc/bitmap_content_layer_updater.h
index 573bcac..cdac5be 100644
--- a/cc/bitmap_content_layer_updater.h
+++ b/cc/bitmap_content_layer_updater.h
@@ -24,7 +24,7 @@ public:
         Resource(BitmapContentLayerUpdater*, scoped_ptr<PrioritizedTexture>);
         virtual ~Resource();
 
-        virtual void update(TextureUpdateQueue&, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate, RenderingStats&) OVERRIDE;
+        virtual void update(ResourceUpdateQueue&, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate, RenderingStats&) OVERRIDE;
 
     private:
         BitmapContentLayerUpdater* updater() { return m_updater; }
@@ -36,7 +36,7 @@ public:
 
     virtual scoped_ptr<LayerUpdater::Resource> createResource(PrioritizedTextureManager*) OVERRIDE;
     virtual void prepareToUpdate(const IntRect& contentRect, const IntSize& tileSize, float contentsWidthScale, float contentsHeightScale, IntRect& resultingOpaqueRect, RenderingStats&) OVERRIDE;
-    void updateTexture(TextureUpdateQueue&, PrioritizedTexture*, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate);
+    void updateTexture(ResourceUpdateQueue&, PrioritizedTexture*, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate);
 
     virtual void setOpaque(bool) OVERRIDE;
 
diff --git a/cc/bitmap_skpicture_content_layer_updater.cc b/cc/bitmap_skpicture_content_layer_updater.cc
index cf52a96..6efc9ed 100644
--- a/cc/bitmap_skpicture_content_layer_updater.cc
+++ b/cc/bitmap_skpicture_content_layer_updater.cc
@@ -9,7 +9,7 @@
 #include "base/time.h"
 #include "cc/layer_painter.h"
 #include "cc/rendering_stats.h"
-#include "cc/texture_update_queue.h"
+#include "cc/resource_update_queue.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkDevice.h"
 
@@ -21,7 +21,7 @@ BitmapSkPictureContentLayerUpdater::Resource::Resource(BitmapSkPictureContentLay
 {
 }
 
-void BitmapSkPictureContentLayerUpdater::Resource::update(TextureUpdateQueue& queue, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate, RenderingStats& stats)
+void BitmapSkPictureContentLayerUpdater::Resource::update(ResourceUpdateQueue& queue, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate, RenderingStats& stats)
 {
     m_bitmap.setConfig(SkBitmap::kARGB_8888_Config, sourceRect.width(), sourceRect.height());
     m_bitmap.allocPixels();
diff --git a/cc/bitmap_skpicture_content_layer_updater.h b/cc/bitmap_skpicture_content_layer_updater.h
index 0c76a72..cd52b46 100644
--- a/cc/bitmap_skpicture_content_layer_updater.h
+++ b/cc/bitmap_skpicture_content_layer_updater.h
@@ -18,7 +18,7 @@ public:
     public:
         Resource(BitmapSkPictureContentLayerUpdater*, scoped_ptr<PrioritizedTexture>);
 
-        virtual void update(TextureUpdateQueue&, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate, RenderingStats&) OVERRIDE;
+        virtual void update(ResourceUpdateQueue&, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate, RenderingStats&) OVERRIDE;
 
     private:
         BitmapSkPictureContentLayerUpdater* updater() { return m_updater; }
diff --git a/cc/cc.gyp b/cc/cc.gyp
index 999601c..f910053 100644
--- a/cc/cc.gyp
+++ b/cc/cc.gyp
@@ -149,10 +149,10 @@
       'texture_draw_quad.h',
       'texture_layer_impl.cc',
       'texture_layer_impl.h',
-      'texture_update_controller.cc',
-      'texture_update_controller.h',
-      'texture_update_queue.cc',
-      'texture_update_queue.h',
+      'resource_update_controller.cc',
+      'resource_update_controller.h',
+      'resource_update_queue.cc',
+      'resource_update_queue.h',
       'thread.h',
       'thread_proxy.cc',
       'thread_proxy.h',
diff --git a/cc/cc_tests.gyp b/cc/cc_tests.gyp
index 0bd7974..b3bd9ca 100644
--- a/cc/cc_tests.gyp
+++ b/cc/cc_tests.gyp
@@ -38,7 +38,7 @@
       'scoped_texture_unittest.cc',
       'scrollbar_animation_controller_linear_fade_unittest.cc',
       'solid_color_layer_impl_unittest.cc',
-      'texture_update_controller_unittest.cc',
+      'resource_update_controller_unittest.cc',
       'thread_task_unittest.cc',
       'tiled_layer_impl_unittest.cc',
       'timer_unittest.cc',
diff --git a/cc/content_layer.cc b/cc/content_layer.cc
index 6eb58f6..a8e10e6 100644
--- a/cc/content_layer.cc
+++ b/cc/content_layer.cc
@@ -65,7 +65,7 @@ void ContentLayer::setTexturePriorities(const PriorityCalculator& priorityCalc)
     TiledLayer::setTexturePriorities(priorityCalc);
 }
 
-void ContentLayer::update(TextureUpdateQueue& queue, const OcclusionTracker* occlusion, RenderingStats& stats)
+void ContentLayer::update(ResourceUpdateQueue& queue, const OcclusionTracker* occlusion, RenderingStats& stats)
 {
     createUpdaterIfNeeded();
     TiledLayer::update(queue, occlusion, stats);
diff --git a/cc/content_layer.h b/cc/content_layer.h
index ff7dbc0..96319ba 100644
--- a/cc/content_layer.h
+++ b/cc/content_layer.h
@@ -41,7 +41,7 @@ public:
 
     virtual bool drawsContent() const OVERRIDE;
     virtual void setTexturePriorities(const PriorityCalculator&) OVERRIDE;
-    virtual void update(TextureUpdateQueue&, const OcclusionTracker*, RenderingStats&) OVERRIDE;
+    virtual void update(ResourceUpdateQueue&, const OcclusionTracker*, RenderingStats&) OVERRIDE;
     virtual bool needMoreUpdates() OVERRIDE;
 
     virtual void setContentsOpaque(bool) OVERRIDE;
diff --git a/cc/heads_up_display_layer.cc b/cc/heads_up_display_layer.cc
index 2302ebb..4be91ce 100644
--- a/cc/heads_up_display_layer.cc
+++ b/cc/heads_up_display_layer.cc
@@ -28,7 +28,7 @@ HeadsUpDisplayLayer::~HeadsUpDisplayLayer()
 {
 }
 
-void HeadsUpDisplayLayer::update(TextureUpdateQueue&, const OcclusionTracker*, RenderingStats&)
+void HeadsUpDisplayLayer::update(ResourceUpdateQueue&, const OcclusionTracker*, RenderingStats&)
 {
     const LayerTreeSettings& settings = layerTreeHost()->settings();
     int maxTextureSize = layerTreeHost()->rendererCapabilities().maxTextureSize;
diff --git a/cc/heads_up_display_layer.h b/cc/heads_up_display_layer.h
index 23e4470..7c6061d 100644
--- a/cc/heads_up_display_layer.h
+++ b/cc/heads_up_display_layer.h
@@ -16,7 +16,7 @@ class HeadsUpDisplayLayer : public Layer {
 public:
     static scoped_refptr<HeadsUpDisplayLayer> create();
 
-    virtual void update(TextureUpdateQueue&, const OcclusionTracker*, RenderingStats&) OVERRIDE;
+    virtual void update(ResourceUpdateQueue&, const OcclusionTracker*, RenderingStats&) OVERRIDE;
     virtual bool drawsContent() const OVERRIDE;
 
     void setFontAtlas(scoped_ptr<FontAtlas>);
diff --git a/cc/image_layer.cc b/cc/image_layer.cc
index d31c362..b347736 100644
--- a/cc/image_layer.cc
+++ b/cc/image_layer.cc
@@ -9,7 +9,7 @@
 #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 {
 
@@ -23,7 +23,7 @@ public:
         {
         }
 
-        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);
         }
@@ -45,7 +45,7 @@ public:
         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.
@@ -113,7 +113,7 @@ void ImageLayer::setTexturePriorities(const PriorityCalculator& priorityCalc)
     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) {
diff --git a/cc/image_layer.h b/cc/image_layer.h
index b96df58..fcb3adb 100644
--- a/cc/image_layer.h
+++ b/cc/image_layer.h
@@ -19,7 +19,7 @@ public:
 
     virtual bool drawsContent() const OVERRIDE;
     virtual void setTexturePriorities(const PriorityCalculator&) OVERRIDE;
-    virtual void update(TextureUpdateQueue&, const OcclusionTracker*, RenderingStats&) OVERRIDE;
+    virtual void update(ResourceUpdateQueue&, const OcclusionTracker*, RenderingStats&) OVERRIDE;
     virtual bool needsContentsScale() const OVERRIDE;
 
     void setBitmap(const SkBitmap& image);
diff --git a/cc/layer.h b/cc/layer.h
index 01f4a59..38a32dd 100644
--- a/cc/layer.h
+++ b/cc/layer.h
@@ -32,7 +32,7 @@ class LayerAnimationDelegate;
 class LayerImpl;
 class LayerTreeHost;
 class PriorityCalculator;
-class TextureUpdateQueue;
+class ResourceUpdateQueue;
 class ScrollbarLayer;
 struct AnimationEvent;
 struct RenderingStats;
@@ -185,7 +185,7 @@ public:
 
     // These methods typically need to be overwritten by derived classes.
     virtual bool drawsContent() const;
-    virtual void update(TextureUpdateQueue&, const OcclusionTracker*, RenderingStats&) { }
+    virtual void update(ResourceUpdateQueue&, const OcclusionTracker*, RenderingStats&) { }
     virtual bool needMoreUpdates();
     virtual void setIsMask(bool) { }
     virtual void bindContentsTexture() { }
diff --git a/cc/layer_tree_host.cc b/cc/layer_tree_host.cc
index bcdf20f..aead25f 100644
--- a/cc/layer_tree_host.cc
+++ b/cc/layer_tree_host.cc
@@ -485,7 +485,7 @@ bool LayerTreeHost::initializeRendererIfNeeded()
     return true;
 }
 
-void LayerTreeHost::updateLayers(TextureUpdateQueue& queue, size_t memoryAllocationLimitBytes)
+void LayerTreeHost::updateLayers(ResourceUpdateQueue& queue, size_t memoryAllocationLimitBytes)
 {
     DCHECK(m_rendererInitialized);
     DCHECK(memoryAllocationLimitBytes);
@@ -518,7 +518,7 @@ static Layer* findFirstScrollableLayer(Layer* layer)
     return 0;
 }
 
-void LayerTreeHost::updateLayers(Layer* rootLayer, TextureUpdateQueue& queue)
+void LayerTreeHost::updateLayers(Layer* rootLayer, ResourceUpdateQueue& queue)
 {
     TRACE_EVENT0("cc", "LayerTreeHost::updateLayers");
 
@@ -625,7 +625,7 @@ size_t LayerTreeHost::calculateMemoryForRenderSurfaces(const LayerList& updateLi
     return readbackBytes + maxBackgroundTextureBytes + contentsTextureBytes;
 }
 
-bool LayerTreeHost::paintMasksForRenderSurface(Layer* renderSurfaceLayer, TextureUpdateQueue& queue)
+bool LayerTreeHost::paintMasksForRenderSurface(Layer* renderSurfaceLayer, ResourceUpdateQueue& queue)
 {
     // Note: Masks and replicas only exist for layers that own render surfaces. If we reach this point
     // in code, we already know that at least something will be drawn into this render surface, so the
@@ -646,7 +646,7 @@ bool LayerTreeHost::paintMasksForRenderSurface(Layer* renderSurfaceLayer, Textur
     return needMoreUpdates;
 }
 
-bool LayerTreeHost::paintLayerContents(const LayerList& renderSurfaceLayerList, TextureUpdateQueue& queue)
+bool LayerTreeHost::paintLayerContents(const LayerList& renderSurfaceLayerList, ResourceUpdateQueue& queue)
 {
     // Use FrontToBack to allow for testing occlusion and performing culling during the tree walk.
     typedef LayerIterator<Layer, LayerList, RenderSurface, LayerIteratorActions::FrontToBack> LayerIteratorType;
diff --git a/cc/layer_tree_host.h b/cc/layer_tree_host.h
index 733d794..f64862e 100644
--- a/cc/layer_tree_host.h
+++ b/cc/layer_tree_host.h
@@ -43,7 +43,7 @@ class Layer;
 class LayerTreeHostImpl;
 class LayerTreeHostImplClient;
 class PrioritizedTextureManager;
-class TextureUpdateQueue;
+class ResourceUpdateQueue;
 class HeadsUpDisplayLayer;
 class Region;
 struct ScrollAndScaleSet;
@@ -128,7 +128,7 @@ public:
     virtual void acquireLayerTextures();
     // Returns false if we should abort this frame due to initialization failure.
     bool initializeRendererIfNeeded();
-    void updateLayers(TextureUpdateQueue&, size_t contentsMemoryLimitBytes);
+    void updateLayers(ResourceUpdateQueue&, size_t contentsMemoryLimitBytes);
 
     LayerTreeHostClient* client() { return m_client; }
 
@@ -213,11 +213,11 @@ private:
 
     void initializeRenderer();
 
-    void update(Layer*, TextureUpdateQueue&, const OcclusionTracker*);
-    bool paintLayerContents(const LayerList&, TextureUpdateQueue&);
-    bool paintMasksForRenderSurface(Layer*, TextureUpdateQueue&);
+    void update(Layer*, ResourceUpdateQueue&, const OcclusionTracker*);
+    bool paintLayerContents(const LayerList&, ResourceUpdateQueue&);
+    bool paintMasksForRenderSurface(Layer*, ResourceUpdateQueue&);
 
-    void updateLayers(Layer*, TextureUpdateQueue&);
+    void updateLayers(Layer*, ResourceUpdateQueue&);
     void triggerPrepaint();
 
     void prioritizeTextures(const LayerList&, OverdrawMetrics&); 
diff --git a/cc/layer_tree_host_unittest.cc b/cc/layer_tree_host_unittest.cc
index 00d468d..72b094a 100644
--- a/cc/layer_tree_host_unittest.cc
+++ b/cc/layer_tree_host_unittest.cc
@@ -17,7 +17,7 @@
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_tree_test_common.h"
 #include "cc/test/occlusion_tracker_test_common.h"
-#include "cc/texture_update_queue.h"
+#include "cc/resource_update_queue.h"
 #include "cc/timing_function.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "third_party/khronos/GLES2/gl2.h"
@@ -1180,7 +1180,7 @@ public:
     int paintContentsCount() { return m_paintContentsCount; }
     void resetPaintContentsCount() { m_paintContentsCount = 0; }
 
-    virtual void update(TextureUpdateQueue& queue, const OcclusionTracker* occlusion, RenderingStats& stats) OVERRIDE
+    virtual void update(ResourceUpdateQueue& queue, const OcclusionTracker* occlusion, RenderingStats& stats) OVERRIDE
     {
         ContentLayer::update(queue, occlusion, stats);
         m_paintContentsCount++;
@@ -1613,7 +1613,7 @@ class TestLayer : public Layer {
 public:
     static scoped_refptr<TestLayer> create() { return make_scoped_refptr(new TestLayer()); }
 
-    virtual void update(TextureUpdateQueue&, const OcclusionTracker* occlusion, RenderingStats&) OVERRIDE
+    virtual void update(ResourceUpdateQueue&, const OcclusionTracker* occlusion, RenderingStats&) OVERRIDE
     {
         // Gain access to internals of the OcclusionTracker.
         const TestOcclusionTracker* testOcclusion = static_cast<const TestOcclusionTracker*>(occlusion);
@@ -1669,7 +1669,7 @@ public:
         m_layerTreeHost->setRootLayer(rootLayer);
         m_layerTreeHost->setViewportSize(rootLayer->bounds(), rootLayer->bounds());
         ASSERT_TRUE(m_layerTreeHost->initializeRendererIfNeeded());
-        TextureUpdateQueue queue;
+        ResourceUpdateQueue queue;
         m_layerTreeHost->updateLayers(queue, std::numeric_limits<size_t>::max());
         m_layerTreeHost->commitComplete();
 
@@ -1877,7 +1877,7 @@ public:
         m_layerTreeHost->setRootLayer(rootLayer);
         m_layerTreeHost->setViewportSize(rootLayer->bounds(), rootLayer->bounds());
         ASSERT_TRUE(m_layerTreeHost->initializeRendererIfNeeded());
-        TextureUpdateQueue queue;
+        ResourceUpdateQueue queue;
         m_layerTreeHost->updateLayers(queue, std::numeric_limits<size_t>::max());
         m_layerTreeHost->commitComplete();
 
@@ -1966,7 +1966,7 @@ public:
         m_layerTreeHost->setRootLayer(layers[0].get());
         m_layerTreeHost->setViewportSize(layers[0]->bounds(), layers[0]->bounds());
         ASSERT_TRUE(m_layerTreeHost->initializeRendererIfNeeded());
-        TextureUpdateQueue queue;
+        ResourceUpdateQueue queue;
         m_layerTreeHost->updateLayers(queue, std::numeric_limits<size_t>::max());
         m_layerTreeHost->commitComplete();
 
@@ -2606,7 +2606,7 @@ class EvictionTestLayer : public Layer {
 public:
     static scoped_refptr<EvictionTestLayer> create() { return make_scoped_refptr(new EvictionTestLayer()); }
 
-    virtual void update(TextureUpdateQueue&, const OcclusionTracker*, RenderingStats&) OVERRIDE;
+    virtual void update(ResourceUpdateQueue&, const OcclusionTracker*, RenderingStats&) OVERRIDE;
     virtual bool drawsContent() const OVERRIDE { return true; }
 
     virtual scoped_ptr<LayerImpl> createLayerImpl() OVERRIDE;
@@ -2664,7 +2664,7 @@ void EvictionTestLayer::setTexturePriorities(const PriorityCalculator&)
     m_texture->setRequestPriority(PriorityCalculator::uiPriority(true));
 }
 
-void EvictionTestLayer::update(TextureUpdateQueue& queue, const OcclusionTracker*, RenderingStats&)
+void EvictionTestLayer::update(ResourceUpdateQueue& queue, const OcclusionTracker*, RenderingStats&)
 {
     createTextureIfNeeded();
     if (!m_texture.get())
diff --git a/cc/layer_updater.h b/cc/layer_updater.h
index b3905ab..16e1a6a 100644
--- a/cc/layer_updater.h
+++ b/cc/layer_updater.h
@@ -15,7 +15,7 @@ class IntRect;
 class IntSize;
 class TextureManager;
 struct RenderingStats;
-class TextureUpdateQueue;
+class ResourceUpdateQueue;
 
 class LayerUpdater : public base::RefCounted<LayerUpdater> {
 public:
@@ -28,7 +28,7 @@ public:
         void swapTextureWith(scoped_ptr<PrioritizedTexture>& texture) { m_texture.swap(texture); }
         // TODO(reveman): partialUpdate should be a property of this class
         // instead of an argument passed to update().
-        virtual void update(TextureUpdateQueue&, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate, RenderingStats&) = 0;
+        virtual void update(ResourceUpdateQueue&, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate, RenderingStats&) = 0;
     protected:
         explicit Resource(scoped_ptr<PrioritizedTexture> texture);
 
diff --git a/cc/prioritized_texture_unittest.cc b/cc/prioritized_texture_unittest.cc
index 61c80d3..3bf0f42 100644
--- a/cc/prioritized_texture_unittest.cc
+++ b/cc/prioritized_texture_unittest.cc
@@ -616,7 +616,7 @@ TEST_F(PrioritizedTextureTest, clearUploadsToEvictedResources)
     for (unsigned i = 0; i < maxTextures; ++i)
         EXPECT_TRUE(validateTexture(textures[i], false));
 
-    TextureUpdateQueue queue;
+    ResourceUpdateQueue queue;
     DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
     for (size_t i = 0; i < maxTextures; ++i) {
         const ResourceUpdate upload = ResourceUpdate::Create(
diff --git a/cc/texture_update_controller.cc b/cc/resource_update_controller.cc
index a289935..c70bec7 100644
--- a/cc/texture_update_controller.cc
+++ b/cc/resource_update_controller.cc
@@ -4,7 +4,7 @@
 
 #include "config.h"
 
-#include "cc/texture_update_controller.h"
+#include "cc/resource_update_controller.h"
 
 #include "base/debug/trace_event.h"
 #include "cc/prioritized_texture.h"
@@ -57,12 +57,12 @@ scoped_ptr<SkCanvas> createAcceleratedCanvas(
 
 namespace cc {
 
-size_t TextureUpdateController::maxPartialTextureUpdates()
+size_t ResourceUpdateController::maxPartialTextureUpdates()
 {
     return partialTextureUpdatesMax;
 }
 
-size_t TextureUpdateController::maxFullUpdatesPerTick(
+size_t ResourceUpdateController::maxFullUpdatesPerTick(
     ResourceProvider* resourceProvider)
 {
     double texturesPerSecond = resourceProvider->estimatedUploadsPerSecond();
@@ -70,7 +70,7 @@ size_t TextureUpdateController::maxFullUpdatesPerTick(
     return texturesPerTick ? texturesPerTick : 1;
 }
 
-TextureUpdateController::TextureUpdateController(TextureUpdateControllerClient* client, Thread* thread, scoped_ptr<TextureUpdateQueue> queue, ResourceProvider* resourceProvider)
+ResourceUpdateController::ResourceUpdateController(ResourceUpdateControllerClient* client, Thread* thread, scoped_ptr<ResourceUpdateQueue> queue, ResourceProvider* resourceProvider)
     : m_client(client)
     , m_timer(new Timer(thread, this))
     , m_queue(queue.Pass())
@@ -80,11 +80,11 @@ TextureUpdateController::TextureUpdateController(TextureUpdateControllerClient*
 {
 }
 
-TextureUpdateController::~TextureUpdateController()
+ResourceUpdateController::~ResourceUpdateController()
 {
 }
 
-void TextureUpdateController::performMoreUpdates(
+void ResourceUpdateController::performMoreUpdates(
     base::TimeTicks timeLimit)
 {
     m_timeLimit = timeLimit;
@@ -107,12 +107,12 @@ void TextureUpdateController::performMoreUpdates(
         updateMoreTexturesNow();
 }
 
-void TextureUpdateController::discardUploadsToEvictedResources()
+void ResourceUpdateController::discardUploadsToEvictedResources()
 {
     m_queue->clearUploadsToEvictedResources();
 }
 
-void TextureUpdateController::updateTexture(ResourceUpdate update)
+void ResourceUpdateController::updateTexture(ResourceUpdate update)
 {
     if (update.picture) {
         PrioritizedTexture* texture = update.texture;
@@ -186,7 +186,7 @@ void TextureUpdateController::updateTexture(ResourceUpdate update)
     }
 }
 
-void TextureUpdateController::finalize()
+void ResourceUpdateController::finalize()
 {
     size_t uploadCount = 0;
     while (m_queue->fullUploadSize()) {
@@ -221,7 +221,7 @@ void TextureUpdateController::finalize()
     }
 }
 
-void TextureUpdateController::onTimerFired()
+void ResourceUpdateController::onTimerFired()
 {
     ResourceProvider::debugNotifyEnterZone(0xB000000);
     if (!updateMoreTexturesIfEnoughTimeRemaining())
@@ -229,27 +229,27 @@ void TextureUpdateController::onTimerFired()
     ResourceProvider::debugNotifyLeaveZone();
 }
 
-base::TimeTicks TextureUpdateController::now() const
+base::TimeTicks ResourceUpdateController::now() const
 {
     return base::TimeTicks::Now();
 }
 
-base::TimeDelta TextureUpdateController::updateMoreTexturesTime() const
+base::TimeDelta ResourceUpdateController::updateMoreTexturesTime() const
 {
     return base::TimeDelta::FromMilliseconds(textureUpdateTickRate * 1000);
 }
 
-size_t TextureUpdateController::updateMoreTexturesSize() const
+size_t ResourceUpdateController::updateMoreTexturesSize() const
 {
     return m_textureUpdatesPerTick;
 }
 
-size_t TextureUpdateController::maxBlockingUpdates() const
+size_t ResourceUpdateController::maxBlockingUpdates() const
 {
     return updateMoreTexturesSize() * maxBlockingUpdateIntervals;
 }
 
-bool TextureUpdateController::updateMoreTexturesIfEnoughTimeRemaining()
+bool ResourceUpdateController::updateMoreTexturesIfEnoughTimeRemaining()
 {
     // Blocking uploads will increase when we're too aggressive in our upload
     // time estimate. We use a different timeout here to prevent unnecessary
@@ -270,7 +270,7 @@ bool TextureUpdateController::updateMoreTexturesIfEnoughTimeRemaining()
     return true;
 }
 
-void TextureUpdateController::updateMoreTexturesNow()
+void ResourceUpdateController::updateMoreTexturesNow()
 {
     size_t uploads = std::min(
         m_queue->fullUploadSize(), updateMoreTexturesSize());
diff --git a/cc/texture_update_controller.h b/cc/resource_update_controller.h
index ee819c7..a77c93b 100644
--- a/cc/texture_update_controller.h
+++ b/cc/resource_update_controller.h
@@ -2,36 +2,36 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CCTextureUpdateController_h
-#define CCTextureUpdateController_h
+#ifndef CCResourceUpdateController_h
+#define CCResourceUpdateController_h
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time.h"
-#include "cc/texture_update_queue.h"
+#include "cc/resource_update_queue.h"
 #include "cc/timer.h"
 
 namespace cc {
 
 class ResourceProvider;
 
-class TextureUpdateControllerClient {
+class ResourceUpdateControllerClient {
 public:
     virtual void readyToFinalizeTextureUpdates() = 0;
 
 protected:
-    virtual ~TextureUpdateControllerClient() { }
+    virtual ~ResourceUpdateControllerClient() { }
 };
 
-class TextureUpdateController : public TimerClient {
+class ResourceUpdateController : public TimerClient {
 public:
-    static scoped_ptr<TextureUpdateController> create(TextureUpdateControllerClient* client, Thread* thread, scoped_ptr<TextureUpdateQueue> queue, ResourceProvider* resourceProvider)
+    static scoped_ptr<ResourceUpdateController> create(ResourceUpdateControllerClient* client, Thread* thread, scoped_ptr<ResourceUpdateQueue> queue, ResourceProvider* resourceProvider)
     {
-        return make_scoped_ptr(new TextureUpdateController(client, thread, queue.Pass(), resourceProvider));
+        return make_scoped_ptr(new ResourceUpdateController(client, thread, queue.Pass(), resourceProvider));
     }
     static size_t maxPartialTextureUpdates();
 
-    virtual ~TextureUpdateController();
+    virtual ~ResourceUpdateController();
 
     // Discard uploads to textures that were evicted on the impl thread.
     void discardUploadsToEvictedResources();
@@ -48,7 +48,7 @@ public:
     virtual size_t updateMoreTexturesSize() const;
 
 protected:
-    TextureUpdateController(TextureUpdateControllerClient*, Thread*, scoped_ptr<TextureUpdateQueue>, ResourceProvider*);
+    ResourceUpdateController(ResourceUpdateControllerClient*, Thread*, scoped_ptr<ResourceUpdateQueue>, ResourceProvider*);
 
     static size_t maxFullUpdatesPerTick(ResourceProvider*);
 
@@ -60,9 +60,9 @@ protected:
     bool updateMoreTexturesIfEnoughTimeRemaining();
     void updateMoreTexturesNow();
 
-    TextureUpdateControllerClient* m_client;
+    ResourceUpdateControllerClient* m_client;
     scoped_ptr<Timer> m_timer;
-    scoped_ptr<TextureUpdateQueue> m_queue;
+    scoped_ptr<ResourceUpdateQueue> m_queue;
     bool m_contentsTexturesPurged;
     ResourceProvider* m_resourceProvider;
     base::TimeTicks m_timeLimit;
@@ -70,9 +70,9 @@ protected:
     bool m_firstUpdateAttempt;
 
 private:
-    DISALLOW_COPY_AND_ASSIGN(TextureUpdateController);
+    DISALLOW_COPY_AND_ASSIGN(ResourceUpdateController);
 };
 
 }  // namespace cc
 
-#endif // CCTextureUpdateController_h
+#endif // CCResourceUpdateController_h
diff --git a/cc/texture_update_controller_unittest.cc b/cc/resource_update_controller_unittest.cc
index 36677c4..850581a 100644
--- a/cc/texture_update_controller_unittest.cc
+++ b/cc/resource_update_controller_unittest.cc
@@ -4,7 +4,7 @@
 
 #include "config.h"
 
-#include "cc/texture_update_controller.h"
+#include "cc/resource_update_controller.h"
 
 #include "cc/single_thread_proxy.h" // For DebugScopedSetImplThread
 #include "cc/test/fake_web_compositor_output_surface.h"
@@ -26,11 +26,11 @@ namespace {
 const int kFlushPeriodFull = 4;
 const int kFlushPeriodPartial = kFlushPeriodFull;
 
-class TextureUpdateControllerTest;
+class ResourceUpdateControllerTest;
 
 class WebGraphicsContext3DForUploadTest : public FakeWebGraphicsContext3D {
 public:
-    WebGraphicsContext3DForUploadTest(TextureUpdateControllerTest *test)
+    WebGraphicsContext3DForUploadTest(ResourceUpdateControllerTest *test)
         : m_test(test)
         , m_supportShallowFlush(true)
     { }
@@ -56,15 +56,15 @@ public:
     }
 
 private:
-    TextureUpdateControllerTest* m_test;
+    ResourceUpdateControllerTest* m_test;
     bool m_supportShallowFlush;
 };
 
 
-class TextureUpdateControllerTest : public Test {
+class ResourceUpdateControllerTest : public Test {
 public:
-    TextureUpdateControllerTest()
-        : m_queue(make_scoped_ptr(new TextureUpdateQueue))
+    ResourceUpdateControllerTest()
+        : m_queue(make_scoped_ptr(new ResourceUpdateQueue))
         , m_textureManager(PrioritizedTextureManager::create(60*1024*1024, 1024, Renderer::ContentPool))
         , m_compositorInitializer(m_thread.get())
         , m_fullUploadCountExpected(0)
@@ -78,7 +78,7 @@ public:
     {
     }
 
-    ~TextureUpdateControllerTest()
+    ~ResourceUpdateControllerTest()
     {
         DebugScopedSetImplThreadAndMainThreadBlocked
             implThreadAndMainThreadBlocked;
@@ -172,8 +172,8 @@ protected:
     {
         DebugScopedSetImplThreadAndMainThreadBlocked
             implThreadAndMainThreadBlocked;
-        scoped_ptr<TextureUpdateController> updateController =
-            TextureUpdateController::create(
+        scoped_ptr<ResourceUpdateController> updateController =
+            ResourceUpdateController::create(
                 NULL,
                 Proxy::implThread(),
                 m_queue.Pass(),
@@ -182,10 +182,10 @@ protected:
     }
 
 protected:
-    // Classes required to interact and test the TextureUpdateController
+    // Classes required to interact and test the ResourceUpdateController
     scoped_ptr<GraphicsContext> m_context;
     scoped_ptr<ResourceProvider> m_resourceProvider;
-    scoped_ptr<TextureUpdateQueue> m_queue;
+    scoped_ptr<ResourceUpdateQueue> m_queue;
     scoped_ptr<PrioritizedTexture> m_textures[4];
     scoped_ptr<WebThread> m_thread;
     WebCompositorInitializer m_compositorInitializer;
@@ -229,7 +229,7 @@ void WebGraphicsContext3DForUploadTest::texSubImage2D(WGC3Denum target,
 }
 
 // ZERO UPLOADS TESTS
-TEST_F(TextureUpdateControllerTest, ZeroUploads)
+TEST_F(ResourceUpdateControllerTest, ZeroUploads)
 {
     appendFullUploadsToUpdateQueue(0);
     appendPartialUploadsToUpdateQueue(0);
@@ -241,7 +241,7 @@ TEST_F(TextureUpdateControllerTest, ZeroUploads)
 
 
 // ONE UPLOAD TESTS
-TEST_F(TextureUpdateControllerTest, OneFullUpload)
+TEST_F(ResourceUpdateControllerTest, OneFullUpload)
 {
     appendFullUploadsToUpdateQueue(1);
     appendPartialUploadsToUpdateQueue(0);
@@ -252,7 +252,7 @@ TEST_F(TextureUpdateControllerTest, OneFullUpload)
     EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
-TEST_F(TextureUpdateControllerTest, OnePartialUpload)
+TEST_F(ResourceUpdateControllerTest, OnePartialUpload)
 {
     appendFullUploadsToUpdateQueue(0);
     appendPartialUploadsToUpdateQueue(1);
@@ -263,7 +263,7 @@ TEST_F(TextureUpdateControllerTest, OnePartialUpload)
     EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
-TEST_F(TextureUpdateControllerTest, OneFullOnePartialUpload)
+TEST_F(ResourceUpdateControllerTest, OneFullOnePartialUpload)
 {
     appendFullUploadsToUpdateQueue(1);
     appendPartialUploadsToUpdateQueue(1);
@@ -282,7 +282,7 @@ const int fullCount = fullUploadFlushMultipler * kFlushPeriodFull;
 const int partialUploadFlushMultipler = 11;
 const int partialCount = partialUploadFlushMultipler * kFlushPeriodPartial;
 
-TEST_F(TextureUpdateControllerTest, ManyFullUploads)
+TEST_F(ResourceUpdateControllerTest, ManyFullUploads)
 {
     appendFullUploadsToUpdateQueue(fullCount);
     appendPartialUploadsToUpdateQueue(0);
@@ -293,7 +293,7 @@ TEST_F(TextureUpdateControllerTest, ManyFullUploads)
     EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
-TEST_F(TextureUpdateControllerTest, ManyPartialUploads)
+TEST_F(ResourceUpdateControllerTest, ManyPartialUploads)
 {
     appendFullUploadsToUpdateQueue(0);
     appendPartialUploadsToUpdateQueue(partialCount);
@@ -304,7 +304,7 @@ TEST_F(TextureUpdateControllerTest, ManyPartialUploads)
     EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
-TEST_F(TextureUpdateControllerTest, ManyFullManyPartialUploads)
+TEST_F(ResourceUpdateControllerTest, ManyFullManyPartialUploads)
 {
     appendFullUploadsToUpdateQueue(fullCount);
     appendPartialUploadsToUpdateQueue(partialCount);
@@ -315,9 +315,9 @@ TEST_F(TextureUpdateControllerTest, ManyFullManyPartialUploads)
     EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
-class FakeTextureUpdateControllerClient : public cc::TextureUpdateControllerClient {
+class FakeResourceUpdateControllerClient : public cc::ResourceUpdateControllerClient {
 public:
-    FakeTextureUpdateControllerClient() { reset(); }
+    FakeResourceUpdateControllerClient() { reset(); }
     void reset() { m_readyToFinalizeCalled = false; }
     bool readyToFinalizeCalled() const { return m_readyToFinalizeCalled; }
 
@@ -327,11 +327,11 @@ protected:
     bool m_readyToFinalizeCalled;
 };
 
-class FakeTextureUpdateController : public cc::TextureUpdateController {
+class FakeResourceUpdateController : public cc::ResourceUpdateController {
 public:
-    static scoped_ptr<FakeTextureUpdateController> create(cc::TextureUpdateControllerClient* client, cc::Thread* thread, scoped_ptr<TextureUpdateQueue> queue, ResourceProvider* resourceProvider)
+    static scoped_ptr<FakeResourceUpdateController> create(cc::ResourceUpdateControllerClient* client, cc::Thread* thread, scoped_ptr<ResourceUpdateQueue> queue, ResourceProvider* resourceProvider)
     {
-        return make_scoped_ptr(new FakeTextureUpdateController(client, thread, queue.Pass(), resourceProvider));
+        return make_scoped_ptr(new FakeResourceUpdateController(client, thread, queue.Pass(), resourceProvider));
     }
 
     void setNow(base::TimeTicks time) { m_now = time; }
@@ -342,8 +342,8 @@ public:
     virtual size_t updateMoreTexturesSize() const OVERRIDE { return m_updateMoreTexturesSize; }
 
 protected:
-    FakeTextureUpdateController(cc::TextureUpdateControllerClient* client, cc::Thread* thread, scoped_ptr<TextureUpdateQueue> queue, ResourceProvider* resourceProvider)
-        : cc::TextureUpdateController(client, thread, queue.Pass(), resourceProvider)
+    FakeResourceUpdateController(cc::ResourceUpdateControllerClient* client, cc::Thread* thread, scoped_ptr<ResourceUpdateQueue> queue, ResourceProvider* resourceProvider)
+        : cc::ResourceUpdateController(client, thread, queue.Pass(), resourceProvider)
         , m_updateMoreTexturesSize(0) { }
 
     base::TimeTicks m_now;
@@ -351,16 +351,16 @@ protected:
     size_t m_updateMoreTexturesSize;
 };
 
-static void runPendingTask(FakeThread* thread, FakeTextureUpdateController* controller)
+static void runPendingTask(FakeThread* thread, FakeResourceUpdateController* controller)
 {
     EXPECT_TRUE(thread->hasPendingTask());
     controller->setNow(controller->now() + base::TimeDelta::FromMilliseconds(thread->pendingDelayMs()));
     thread->runPendingTask();
 }
 
-TEST_F(TextureUpdateControllerTest, UpdateMoreTextures)
+TEST_F(ResourceUpdateControllerTest, UpdateMoreTextures)
 {
-    FakeTextureUpdateControllerClient client;
+    FakeResourceUpdateControllerClient client;
     FakeThread thread;
 
     setMaxUploadCountPerUpdate(1);
@@ -369,7 +369,7 @@ TEST_F(TextureUpdateControllerTest, UpdateMoreTextures)
 
     DebugScopedSetImplThreadAndMainThreadBlocked
         implThreadAndMainThreadBlocked;
-    scoped_ptr<FakeTextureUpdateController> controller(FakeTextureUpdateController::create(&client, &thread, m_queue.Pass(), m_resourceProvider.get()));
+    scoped_ptr<FakeResourceUpdateController> controller(FakeResourceUpdateController::create(&client, &thread, m_queue.Pass(), m_resourceProvider.get()));
 
     controller->setNow(
         controller->now() + base::TimeDelta::FromMilliseconds(1));
@@ -404,9 +404,9 @@ TEST_F(TextureUpdateControllerTest, UpdateMoreTextures)
     EXPECT_EQ(3, m_numTotalUploads);
 }
 
-TEST_F(TextureUpdateControllerTest, NoMoreUpdates)
+TEST_F(ResourceUpdateControllerTest, NoMoreUpdates)
 {
-    FakeTextureUpdateControllerClient client;
+    FakeResourceUpdateControllerClient client;
     FakeThread thread;
 
     setMaxUploadCountPerUpdate(1);
@@ -415,7 +415,7 @@ TEST_F(TextureUpdateControllerTest, NoMoreUpdates)
 
     DebugScopedSetImplThreadAndMainThreadBlocked
         implThreadAndMainThreadBlocked;
-    scoped_ptr<FakeTextureUpdateController> controller(FakeTextureUpdateController::create(&client, &thread, m_queue.Pass(), m_resourceProvider.get()));
+    scoped_ptr<FakeResourceUpdateController> controller(FakeResourceUpdateController::create(&client, &thread, m_queue.Pass(), m_resourceProvider.get()));
 
     controller->setNow(
         controller->now() + base::TimeDelta::FromMilliseconds(1));
@@ -444,9 +444,9 @@ TEST_F(TextureUpdateControllerTest, NoMoreUpdates)
     EXPECT_EQ(2, m_numTotalUploads);
 }
 
-TEST_F(TextureUpdateControllerTest, UpdatesCompleteInFiniteTime)
+TEST_F(ResourceUpdateControllerTest, UpdatesCompleteInFiniteTime)
 {
-    FakeTextureUpdateControllerClient client;
+    FakeResourceUpdateControllerClient client;
     FakeThread thread;
 
     setMaxUploadCountPerUpdate(1);
@@ -455,7 +455,7 @@ TEST_F(TextureUpdateControllerTest, UpdatesCompleteInFiniteTime)
 
     DebugScopedSetImplThreadAndMainThreadBlocked
         implThreadAndMainThreadBlocked;
-    scoped_ptr<FakeTextureUpdateController> controller(FakeTextureUpdateController::create(&client, &thread, m_queue.Pass(), m_resourceProvider.get()));
+    scoped_ptr<FakeResourceUpdateController> controller(FakeResourceUpdateController::create(&client, &thread, m_queue.Pass(), m_resourceProvider.get()));
 
     controller->setNow(
         controller->now() + base::TimeDelta::FromMilliseconds(1));
diff --git a/cc/texture_update_queue.cc b/cc/resource_update_queue.cc
index 8dd992f..26a24b3 100644
--- a/cc/texture_update_queue.cc
+++ b/cc/resource_update_queue.cc
@@ -4,42 +4,42 @@
 
 #include "config.h"
 
-#include "cc/texture_update_queue.h"
+#include "cc/resource_update_queue.h"
 
 #include "cc/prioritized_texture.h"
 
 namespace cc {
 
-TextureUpdateQueue::TextureUpdateQueue()
+ResourceUpdateQueue::ResourceUpdateQueue()
 {
 }
 
-TextureUpdateQueue::~TextureUpdateQueue()
+ResourceUpdateQueue::~ResourceUpdateQueue()
 {
 }
 
-void TextureUpdateQueue::appendFullUpload(const ResourceUpdate& upload)
+void ResourceUpdateQueue::appendFullUpload(const ResourceUpdate& upload)
 {
     m_fullEntries.push_back(upload);
 }
 
-void TextureUpdateQueue::appendPartialUpload(const ResourceUpdate& upload)
+void ResourceUpdateQueue::appendPartialUpload(const ResourceUpdate& upload)
 {
     m_partialEntries.push_back(upload);
 }
 
-void TextureUpdateQueue::appendCopy(TextureCopier::Parameters copy)
+void ResourceUpdateQueue::appendCopy(TextureCopier::Parameters copy)
 {
     m_copyEntries.push_back(copy);
 }
 
-void TextureUpdateQueue::clearUploadsToEvictedResources()
+void ResourceUpdateQueue::clearUploadsToEvictedResources()
 {
     clearUploadsToEvictedResources(m_fullEntries);
     clearUploadsToEvictedResources(m_partialEntries);
 }
 
-void TextureUpdateQueue::clearUploadsToEvictedResources(std::deque<ResourceUpdate>& entryQueue)
+void ResourceUpdateQueue::clearUploadsToEvictedResources(std::deque<ResourceUpdate>& entryQueue)
 {
     std::deque<ResourceUpdate> temp;
     entryQueue.swap(temp);
@@ -51,28 +51,28 @@ void TextureUpdateQueue::clearUploadsToEvictedResources(std::deque<ResourceUpdat
     }
 }
 
-ResourceUpdate TextureUpdateQueue::takeFirstFullUpload()
+ResourceUpdate ResourceUpdateQueue::takeFirstFullUpload()
 {
     ResourceUpdate first = m_fullEntries.front();
     m_fullEntries.pop_front();
     return first;
 }
 
-ResourceUpdate TextureUpdateQueue::takeFirstPartialUpload()
+ResourceUpdate ResourceUpdateQueue::takeFirstPartialUpload()
 {
     ResourceUpdate first = m_partialEntries.front();
     m_partialEntries.pop_front();
     return first;
 }
 
-TextureCopier::Parameters TextureUpdateQueue::takeFirstCopy()
+TextureCopier::Parameters ResourceUpdateQueue::takeFirstCopy()
 {
     TextureCopier::Parameters first = m_copyEntries.front();
     m_copyEntries.pop_front();
     return first;
 }
 
-bool TextureUpdateQueue::hasMoreUpdates() const
+bool ResourceUpdateQueue::hasMoreUpdates() const
 {
     return m_fullEntries.size() || m_partialEntries.size() || m_copyEntries.size();
 }
diff --git a/cc/texture_update_queue.h b/cc/resource_update_queue.h
index 933929b..a9c0fbc 100644
--- a/cc/texture_update_queue.h
+++ b/cc/resource_update_queue.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CCTextureUpdateQueue_h
-#define CCTextureUpdateQueue_h
+#ifndef CCResourceUpdateQueue_h
+#define CCResourceUpdateQueue_h
 
 #include "base/basictypes.h"
 #include "cc/resource_update.h"
@@ -12,10 +12,10 @@
 
 namespace cc {
 
-class TextureUpdateQueue {
+class ResourceUpdateQueue {
 public:
-    TextureUpdateQueue();
-    virtual ~TextureUpdateQueue();
+    ResourceUpdateQueue();
+    virtual ~ResourceUpdateQueue();
 
     void appendFullUpload(const ResourceUpdate&);
     void appendPartialUpload(const ResourceUpdate&);
@@ -39,9 +39,9 @@ private:
     std::deque<ResourceUpdate> m_partialEntries;
     std::deque<TextureCopier::Parameters> m_copyEntries;
 
-    DISALLOW_COPY_AND_ASSIGN(TextureUpdateQueue);
+    DISALLOW_COPY_AND_ASSIGN(ResourceUpdateQueue);
 };
 
 }
 
-#endif // CCTextureUpdateQueue_h
+#endif // CCResourceUpdateQueue_h
diff --git a/cc/scrollbar_layer.cc b/cc/scrollbar_layer.cc
index d30b836..1a107bd 100644
--- a/cc/scrollbar_layer.cc
+++ b/cc/scrollbar_layer.cc
@@ -10,8 +10,8 @@
 #include "base/debug/trace_event.h"
 #include "cc/layer_painter.h"
 #include "cc/layer_tree_host.h"
+#include "cc/resource_update_queue.h"
 #include "cc/scrollbar_layer_impl.h"
-#include "cc/texture_update_queue.h"
 #include <public/WebRect.h>
 
 using WebKit::WebRect;
@@ -209,7 +209,7 @@ void ScrollbarLayer::createUpdaterIfNeeded()
         m_thumb = m_thumbUpdater->createResource(layerTreeHost()->contentsTextureManager());
 }
 
-void ScrollbarLayer::updatePart(CachingBitmapContentLayerUpdater* painter, LayerUpdater::Resource* texture, const IntRect& rect, TextureUpdateQueue& queue, RenderingStats& stats)
+void ScrollbarLayer::updatePart(CachingBitmapContentLayerUpdater* painter, LayerUpdater::Resource* texture, const IntRect& rect, ResourceUpdateQueue& queue, RenderingStats& stats)
 {
     // Skip painting and uploading if there are no invalidations and
     // we already have valid texture data.
@@ -261,7 +261,7 @@ void ScrollbarLayer::setTexturePriorities(const PriorityCalculator&)
     }
 }
 
-void ScrollbarLayer::update(TextureUpdateQueue& queue, const OcclusionTracker*, RenderingStats& stats)
+void ScrollbarLayer::update(ResourceUpdateQueue& queue, const OcclusionTracker*, RenderingStats& stats)
 {
     if (contentBounds().isEmpty())
         return;
diff --git a/cc/scrollbar_layer.h b/cc/scrollbar_layer.h
index 885bea9..95847a9 100644
--- a/cc/scrollbar_layer.h
+++ b/cc/scrollbar_layer.h
@@ -14,9 +14,9 @@
 
 namespace cc {
 
+class ResourceUpdateQueue;
 class Scrollbar;
 class ScrollbarThemeComposite;
-class TextureUpdateQueue;
 
 class ScrollbarLayer : public Layer {
 public:
@@ -28,7 +28,7 @@ public:
     virtual bool needsContentsScale() const OVERRIDE;
     virtual IntSize contentBounds() const OVERRIDE;
     virtual void setTexturePriorities(const PriorityCalculator&) OVERRIDE;
-    virtual void update(TextureUpdateQueue&, const OcclusionTracker*, RenderingStats&) OVERRIDE;
+    virtual void update(ResourceUpdateQueue&, const OcclusionTracker*, RenderingStats&) OVERRIDE;
     virtual void setLayerTreeHost(LayerTreeHost*) OVERRIDE;
     virtual void pushPropertiesTo(LayerImpl*) OVERRIDE;
 
@@ -42,7 +42,7 @@ protected:
     virtual ~ScrollbarLayer();
 
 private:
-    void updatePart(CachingBitmapContentLayerUpdater*, LayerUpdater::Resource*, const IntRect&, TextureUpdateQueue&, RenderingStats&);
+    void updatePart(CachingBitmapContentLayerUpdater*, LayerUpdater::Resource*, const IntRect&, ResourceUpdateQueue&, RenderingStats&);
     void createUpdaterIfNeeded();
 
     scoped_ptr<WebKit::WebScrollbar> m_scrollbar;
diff --git a/cc/single_thread_proxy.cc b/cc/single_thread_proxy.cc
index d9918fa..5cbe3d2 100644
--- a/cc/single_thread_proxy.cc
+++ b/cc/single_thread_proxy.cc
@@ -10,7 +10,7 @@
 #include "cc/draw_quad.h"
 #include "cc/graphics_context.h"
 #include "cc/layer_tree_host.h"
-#include "cc/texture_update_controller.h"
+#include "cc/resource_update_controller.h"
 #include "cc/timer.h"
 #include <wtf/CurrentTime.h>
 
@@ -176,7 +176,7 @@ void SingleThreadProxy::setNeedsAnimate()
     NOTREACHED();
 }
 
-void SingleThreadProxy::doCommit(scoped_ptr<TextureUpdateQueue> queue)
+void SingleThreadProxy::doCommit(scoped_ptr<ResourceUpdateQueue> queue)
 {
     DCHECK(Proxy::isMainThread());
     // Commit immediately
@@ -190,8 +190,8 @@ void SingleThreadProxy::doCommit(scoped_ptr<TextureUpdateQueue> queue)
         m_layerTreeHost->contentsTextureManager()->pushTexturePrioritiesToBackings();
         m_layerTreeHost->beginCommitOnImplThread(m_layerTreeHostImpl.get());
 
-        scoped_ptr<TextureUpdateController> updateController =
-            TextureUpdateController::create(
+        scoped_ptr<ResourceUpdateController> updateController =
+            ResourceUpdateController::create(
                 NULL,
                 Proxy::mainThread(),
                 queue.Pass(),
@@ -334,7 +334,7 @@ bool SingleThreadProxy::commitAndComposite()
     }
     m_layerTreeHost->contentsTextureManager()->unlinkEvictedBackings(evictedContentsTexturesBackings);
 
-    scoped_ptr<TextureUpdateQueue> queue = make_scoped_ptr(new TextureUpdateQueue);
+    scoped_ptr<ResourceUpdateQueue> queue = make_scoped_ptr(new ResourceUpdateQueue);
     m_layerTreeHost->updateLayers(*(queue.get()), m_layerTreeHostImpl->memoryAllocationLimitBytes());
 
     if (m_layerTreeHostImpl->contentsTexturesPurged())
diff --git a/cc/single_thread_proxy.h b/cc/single_thread_proxy.h
index 9ade5f8..2a27e32 100644
--- a/cc/single_thread_proxy.h
+++ b/cc/single_thread_proxy.h
@@ -63,7 +63,7 @@ private:
     explicit SingleThreadProxy(LayerTreeHost*);
 
     bool commitAndComposite();
-    void doCommit(scoped_ptr<TextureUpdateQueue>);
+    void doCommit(scoped_ptr<ResourceUpdateQueue>);
     bool doComposite();
     void didSwapFrame();
 
diff --git a/cc/skpicture_content_layer_updater.cc b/cc/skpicture_content_layer_updater.cc
index 7eff91c..e646945 100644
--- a/cc/skpicture_content_layer_updater.cc
+++ b/cc/skpicture_content_layer_updater.cc
@@ -8,7 +8,7 @@
 
 #include "base/debug/trace_event.h"
 #include "cc/layer_painter.h"
-#include "cc/texture_update_queue.h"
+#include "cc/resource_update_queue.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 
 namespace cc {
@@ -23,7 +23,7 @@ SkPictureContentLayerUpdater::Resource::~Resource()
 {
 }
 
-void SkPictureContentLayerUpdater::Resource::update(TextureUpdateQueue& queue, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate, RenderingStats&)
+void SkPictureContentLayerUpdater::Resource::update(ResourceUpdateQueue& queue, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate, RenderingStats&)
 {
     updater()->updateTexture(queue, texture(), sourceRect, destOffset, partialUpdate);
 }
@@ -61,7 +61,7 @@ void SkPictureContentLayerUpdater::drawPicture(SkCanvas* canvas)
     canvas->drawPicture(m_picture);
 }
 
-void SkPictureContentLayerUpdater::updateTexture(TextureUpdateQueue& queue, PrioritizedTexture* texture, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate)
+void SkPictureContentLayerUpdater::updateTexture(ResourceUpdateQueue& queue, PrioritizedTexture* texture, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate)
 {
     ResourceUpdate upload = ResourceUpdate::CreateFromPicture(
         texture, &m_picture, contentRect(), sourceRect, destOffset);
diff --git a/cc/skpicture_content_layer_updater.h b/cc/skpicture_content_layer_updater.h
index 685ee39..72305cd 100644
--- a/cc/skpicture_content_layer_updater.h
+++ b/cc/skpicture_content_layer_updater.h
@@ -27,7 +27,7 @@ public:
         Resource(SkPictureContentLayerUpdater*, scoped_ptr<PrioritizedTexture>);
         virtual ~Resource();
 
-        virtual void update(TextureUpdateQueue&, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate, RenderingStats&) OVERRIDE;
+        virtual void update(ResourceUpdateQueue&, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate, RenderingStats&) OVERRIDE;
 
     private:
         SkPictureContentLayerUpdater* updater() { return m_updater; }
@@ -46,7 +46,7 @@ protected:
 
     virtual void prepareToUpdate(const IntRect& contentRect, const IntSize& tileSize, float contentsWidthScale, float contentsHeightScale, IntRect& resultingOpaqueRect, RenderingStats&) OVERRIDE;
     void drawPicture(SkCanvas*);
-    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);
 
     bool layerIsOpaque() const { return m_layerIsOpaque; }
 
diff --git a/cc/test/tiled_layer_test_common.cc b/cc/test/tiled_layer_test_common.cc
index 5f6a0a2..2988e5e 100644
--- a/cc/test/tiled_layer_test_common.cc
+++ b/cc/test/tiled_layer_test_common.cc
@@ -22,7 +22,7 @@ FakeLayerUpdater::Resource::~Resource()
 {
 }
 
-void FakeLayerUpdater::Resource::update(TextureUpdateQueue& queue, const IntRect&, const IntSize&, bool partialUpdate, RenderingStats&)
+void FakeLayerUpdater::Resource::update(ResourceUpdateQueue& queue, const IntRect&, const IntSize&, bool partialUpdate, RenderingStats&)
 {
     const IntRect rect(0, 0, 10, 10);
     ResourceUpdate upload = ResourceUpdate::Create(
diff --git a/cc/test/tiled_layer_test_common.h b/cc/test/tiled_layer_test_common.h
index bcb5909..8344b3b 100644
--- a/cc/test/tiled_layer_test_common.h
+++ b/cc/test/tiled_layer_test_common.h
@@ -11,8 +11,8 @@
 #include "cc/layer_updater.h"
 #include "cc/prioritized_texture.h"
 #include "cc/resource_provider.h"
+#include "cc/resource_update_queue.h"
 #include "cc/texture_copier.h"
-#include "cc/texture_update_queue.h"
 #include "cc/texture_uploader.h"
 #include "cc/tiled_layer.h"
 #include "cc/tiled_layer_impl.h"
@@ -28,7 +28,7 @@ public:
         Resource(FakeLayerUpdater*, scoped_ptr<cc::PrioritizedTexture>);
         virtual ~Resource();
 
-        virtual void update(cc::TextureUpdateQueue&, const cc::IntRect&, const cc::IntSize&, bool, cc::RenderingStats&) OVERRIDE;
+        virtual void update(cc::ResourceUpdateQueue&, const cc::IntRect&, const cc::IntSize&, bool, cc::RenderingStats&) OVERRIDE;
 
     private:
         FakeLayerUpdater* m_layer;
diff --git a/cc/texture_layer.cc b/cc/texture_layer.cc
index c0115f7..926d564 100644
--- a/cc/texture_layer.cc
+++ b/cc/texture_layer.cc
@@ -107,7 +107,7 @@ bool TextureLayer::drawsContent() const
     return (m_client || m_textureId) && !m_contextLost && Layer::drawsContent();
 }
 
-void TextureLayer::update(TextureUpdateQueue& queue, const OcclusionTracker*, RenderingStats&)
+void TextureLayer::update(ResourceUpdateQueue& queue, const OcclusionTracker*, RenderingStats&)
 {
     if (m_client) {
         m_textureId = m_client->prepareTexture(queue);
diff --git a/cc/texture_layer.h b/cc/texture_layer.h
index f72282f..bd49760 100644
--- a/cc/texture_layer.h
+++ b/cc/texture_layer.h
@@ -50,7 +50,7 @@ public:
 
     virtual void setLayerTreeHost(LayerTreeHost*) OVERRIDE;
     virtual bool drawsContent() const OVERRIDE;
-    virtual void update(TextureUpdateQueue&, const OcclusionTracker*, RenderingStats&) OVERRIDE;
+    virtual void update(ResourceUpdateQueue&, const OcclusionTracker*, RenderingStats&) OVERRIDE;
     virtual void pushPropertiesTo(LayerImpl*) OVERRIDE;
 
 protected:
diff --git a/cc/texture_layer_client.h b/cc/texture_layer_client.h
index 35e7fc5..9ebc8d5 100644
--- a/cc/texture_layer_client.h
+++ b/cc/texture_layer_client.h
@@ -10,14 +10,14 @@ class WebGraphicsContext3D;
 }
 
 namespace cc {
-class TextureUpdateQueue;
+class ResourceUpdateQueue;
 
 class TextureLayerClient {
 public:
     // Called to prepare this layer's texture for compositing. The client may queue a texture
-    // upload or copy on the TextureUpdateQueue.
+    // upload or copy on the ResourceUpdateQueue.
     // Returns the texture ID to be used for compositing.
-    virtual unsigned prepareTexture(TextureUpdateQueue&) = 0;
+    virtual unsigned prepareTexture(ResourceUpdateQueue&) = 0;
 
     // Returns the context that is providing the texture. Used for rate limiting and detecting lost context.
     virtual WebKit::WebGraphicsContext3D* context() = 0;
diff --git a/cc/thread_proxy.cc b/cc/thread_proxy.cc
index ace26b5..666c03f 100644
--- a/cc/thread_proxy.cc
+++ b/cc/thread_proxy.cc
@@ -363,8 +363,8 @@ bool ThreadProxy::reduceContentsTextureMemoryOnImplThread(size_t limitBytes, int
 
     // The texture upload queue may reference textures that were just purged, clear
     // them from the queue.
-    if (m_currentTextureUpdateControllerOnImplThread.get())
-        m_currentTextureUpdateControllerOnImplThread->discardUploadsToEvictedResources();
+    if (m_currentResourceUpdateControllerOnImplThread.get())
+        m_currentResourceUpdateControllerOnImplThread->discardUploadsToEvictedResources();
     return true;
 }
 
@@ -557,7 +557,7 @@ void ThreadProxy::beginFrame()
 
     m_layerTreeHost->contentsTextureManager()->unlinkEvictedBackings(request->evictedContentsTexturesBackings);
 
-    scoped_ptr<TextureUpdateQueue> queue = make_scoped_ptr(new TextureUpdateQueue);
+    scoped_ptr<ResourceUpdateQueue> queue = make_scoped_ptr(new ResourceUpdateQueue);
     m_layerTreeHost->updateLayers(*(queue.get()), request->memoryAllocationLimitBytes);
 
     // Once single buffered layers are committed, they cannot be modified until
@@ -599,9 +599,9 @@ void ThreadProxy::beginFrame()
     m_layerTreeHost->didBeginFrame();
 }
 
-void ThreadProxy::beginFrameCompleteOnImplThread(CompletionEvent* completion, TextureUpdateQueue* rawQueue)
+void ThreadProxy::beginFrameCompleteOnImplThread(CompletionEvent* completion, ResourceUpdateQueue* rawQueue)
 {
-    scoped_ptr<TextureUpdateQueue> queue(rawQueue);
+    scoped_ptr<ResourceUpdateQueue> queue(rawQueue);
 
     TRACE_EVENT0("cc", "ThreadProxy::beginFrameCompleteOnImplThread");
     DCHECK(!m_commitCompletionEventOnImplThread);
@@ -626,9 +626,9 @@ void ThreadProxy::beginFrameCompleteOnImplThread(CompletionEvent* completion, Te
 
     m_layerTreeHost->contentsTextureManager()->pushTexturePrioritiesToBackings();
 
-    m_currentTextureUpdateControllerOnImplThread = TextureUpdateController::create(this, Proxy::implThread(), queue.Pass(), m_layerTreeHostImpl->resourceProvider());
+    m_currentResourceUpdateControllerOnImplThread = ResourceUpdateController::create(this, Proxy::implThread(), queue.Pass(), m_layerTreeHostImpl->resourceProvider());
     ResourceProvider::debugNotifyEnterZone(0x2000000);
-    m_currentTextureUpdateControllerOnImplThread->performMoreUpdates(
+    m_currentResourceUpdateControllerOnImplThread->performMoreUpdates(
         m_schedulerOnImplThread->anticipatedDrawTime());
     ResourceProvider::debugNotifyLeaveZone();
 
@@ -650,13 +650,13 @@ void ThreadProxy::scheduledActionCommit()
     TRACE_EVENT0("cc", "ThreadProxy::scheduledActionCommit");
     DCHECK(isImplThread());
     DCHECK(m_commitCompletionEventOnImplThread);
-    DCHECK(m_currentTextureUpdateControllerOnImplThread);
+    DCHECK(m_currentResourceUpdateControllerOnImplThread);
 
     // Complete all remaining texture updates.
     ResourceProvider::debugNotifyEnterZone(0x3000000);
-    m_currentTextureUpdateControllerOnImplThread->finalize();
+    m_currentResourceUpdateControllerOnImplThread->finalize();
     ResourceProvider::debugNotifyLeaveZone();
-    m_currentTextureUpdateControllerOnImplThread.reset();
+    m_currentResourceUpdateControllerOnImplThread.reset();
 
     // If there are linked evicted backings, these backings' resources may be put into the
     // impl tree, so we can't draw yet. Determine this before clearing all evicted backings.
@@ -800,11 +800,11 @@ ScheduledActionDrawAndSwapResult ThreadProxy::scheduledActionDrawAndSwapForced()
 
 void ThreadProxy::didAnticipatedDrawTimeChange(base::TimeTicks time)
 {
-    if (!m_currentTextureUpdateControllerOnImplThread)
+    if (!m_currentResourceUpdateControllerOnImplThread)
         return;
 
     ResourceProvider::debugNotifyEnterZone(0x5000000);
-    m_currentTextureUpdateControllerOnImplThread->performMoreUpdates(time);
+    m_currentResourceUpdateControllerOnImplThread->performMoreUpdates(time);
     ResourceProvider::debugNotifyLeaveZone();
 }
 
@@ -945,7 +945,7 @@ void ThreadProxy::setFullRootLayerDamageOnImplThread()
 
 size_t ThreadProxy::maxPartialTextureUpdates() const
 {
-    return TextureUpdateController::maxPartialTextureUpdates();
+    return ResourceUpdateController::maxPartialTextureUpdates();
 }
 
 void ThreadProxy::recreateContextOnImplThread(CompletionEvent* completion, GraphicsContext* contextPtr, bool* recreateSucceeded, RendererCapabilities* capabilities)
diff --git a/cc/thread_proxy.h b/cc/thread_proxy.h
index 58c8fd4..58e327c 100644
--- a/cc/thread_proxy.h
+++ b/cc/thread_proxy.h
@@ -10,20 +10,20 @@
 #include "cc/completion_event.h"
 #include "cc/layer_tree_host_impl.h"
 #include "cc/proxy.h"
+#include "cc/resource_update_controller.h"
 #include "cc/scheduler.h"
-#include "cc/texture_update_controller.h"
 
 namespace cc {
 
 class InputHandler;
 class LayerTreeHost;
+class ResourceUpdateQueue;
 class Scheduler;
 class ScopedThreadProxy;
-class TextureUpdateQueue;
 class Thread;
 class ThreadProxyContextRecreationTimer;
 
-class ThreadProxy : public Proxy, LayerTreeHostImplClient, SchedulerClient, TextureUpdateControllerClient {
+class ThreadProxy : public Proxy, LayerTreeHostImplClient, SchedulerClient, ResourceUpdateControllerClient {
 public:
     static scoped_ptr<Proxy> create(LayerTreeHost*);
 
@@ -73,7 +73,7 @@ public:
     virtual void scheduledActionAcquireLayerTexturesForMainThread() OVERRIDE;
     virtual void didAnticipatedDrawTimeChange(base::TimeTicks) OVERRIDE;
 
-    // TextureUpdateControllerClient implementation
+    // ResourceUpdateControllerClient implementation
     virtual void readyToFinalizeTextureUpdates() OVERRIDE;
 
 private:
@@ -109,7 +109,7 @@ private:
         IntRect rect;
     };
     void forceBeginFrameOnImplThread(CompletionEvent*);
-    void beginFrameCompleteOnImplThread(CompletionEvent*, TextureUpdateQueue*);
+    void beginFrameCompleteOnImplThread(CompletionEvent*, ResourceUpdateQueue*);
     void beginFrameAbortedOnImplThread();
     void requestReadbackOnImplThread(ReadbackRequest*);
     void requestStartPageScaleAnimationOnImplThread(IntSize targetPosition, bool useAnchor, float scale, double durationSec);
@@ -165,7 +165,7 @@ private:
     // Set when the main thread is waiting on layers to be drawn.
     CompletionEvent* m_textureAcquisitionCompletionEventOnImplThread;
 
-    scoped_ptr<TextureUpdateController> m_currentTextureUpdateControllerOnImplThread;
+    scoped_ptr<ResourceUpdateController> m_currentResourceUpdateControllerOnImplThread;
 
     // Set when the next draw should post didCommitAndDrawFrame to the main thread.
     bool m_nextFrameIsNewlyCommittedFrameOnImplThread;
diff --git a/cc/tiled_layer.cc b/cc/tiled_layer.cc
index 9b8d2d1..df4a985 100644
--- a/cc/tiled_layer.cc
+++ b/cc/tiled_layer.cc
@@ -328,7 +328,7 @@ bool TiledLayer::tileOnlyNeedsPartialUpdate(UpdatableTile* tile)
     return !tile->dirtyRect.contains(m_tiler->tileRect(tile)) && tile->managedTexture()->haveBackingTexture();
 }
 
-bool TiledLayer::updateTiles(int left, int top, int right, int bottom, TextureUpdateQueue& queue, const OcclusionTracker* occlusion, RenderingStats& stats, bool& didPaint)
+bool TiledLayer::updateTiles(int left, int top, int right, int bottom, ResourceUpdateQueue& queue, const OcclusionTracker* occlusion, RenderingStats& stats, bool& didPaint)
 {
     didPaint = false;
     createUpdaterIfNeeded();
@@ -446,7 +446,7 @@ IntRect TiledLayer::markTilesForUpdate(int left, int top, int right, int bottom,
     return paintRect;
 }
 
-void TiledLayer::updateTileTextures(const IntRect& paintRect, int left, int top, int right, int bottom, TextureUpdateQueue& queue, const OcclusionTracker* occlusion, RenderingStats& stats)
+void TiledLayer::updateTileTextures(const IntRect& paintRect, int left, int top, int right, int bottom, ResourceUpdateQueue& 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);
@@ -665,7 +665,7 @@ void TiledLayer::updateScrollPrediction()
     m_previousVisibleRect = visibleContentRect();
 }
 
-void TiledLayer::update(TextureUpdateQueue& queue, const OcclusionTracker* occlusion, RenderingStats& stats)
+void TiledLayer::update(ResourceUpdateQueue& queue, const OcclusionTracker* occlusion, RenderingStats& stats)
 {
     DCHECK(!m_skipsDraw && !m_failedUpdate); // Did resetUpdateState get skipped?
     updateBounds();
diff --git a/cc/tiled_layer.h b/cc/tiled_layer.h
index d3ec856..c6cb541 100644
--- a/cc/tiled_layer.h
+++ b/cc/tiled_layer.h
@@ -35,7 +35,7 @@ public:
 
     virtual Region visibleContentOpaqueRegion() const OVERRIDE;
 
-    virtual void update(TextureUpdateQueue&, const OcclusionTracker*, RenderingStats&) OVERRIDE;
+    virtual void update(ResourceUpdateQueue&, const OcclusionTracker*, RenderingStats&) OVERRIDE;
 
 protected:
     TiledLayer();
@@ -79,10 +79,10 @@ private:
 
     void markOcclusionsAndRequestTextures(int left, int top, int right, int bottom, const OcclusionTracker*);
 
-    bool updateTiles(int left, int top, int right, int bottom, TextureUpdateQueue&, const OcclusionTracker*, RenderingStats&, bool& didPaint);
+    bool updateTiles(int left, int top, int right, int bottom, ResourceUpdateQueue&, const OcclusionTracker*, RenderingStats&, bool& didPaint);
     bool haveTexturesForTiles(int left, int top, int right, int bottom, bool ignoreOcclusions);
     IntRect markTilesForUpdate(int left, int top, int right, int bottom, bool ignoreOcclusions);
-    void updateTileTextures(const IntRect& paintRect, int left, int top, int right, int bottom, TextureUpdateQueue&, const OcclusionTracker*, RenderingStats&);
+    void updateTileTextures(const IntRect& paintRect, int left, int top, int right, int bottom, ResourceUpdateQueue&, const OcclusionTracker*, RenderingStats&);
     void updateScrollPrediction();
 
     UpdatableTile* tileAt(int, int) const;
diff --git a/cc/tiled_layer_unittest.cc b/cc/tiled_layer_unittest.cc
index 3c78e27..ffa8461 100644
--- a/cc/tiled_layer_unittest.cc
+++ b/cc/tiled_layer_unittest.cc
@@ -10,6 +10,7 @@
 #include "cc/layer_painter.h"
 #include "cc/overdraw_metrics.h"
 #include "cc/rendering_stats.h"
+#include "cc/resource_update_controller.h"
 #include "cc/single_thread_proxy.h" // For DebugScopedSetImplThread
 #include "cc/test/animation_test_common.h"
 #include "cc/test/fake_graphics_context.h"
@@ -17,7 +18,6 @@
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/tiled_layer_test_common.h"
 #include "cc/test/web_compositor_initializer.h"
-#include "cc/texture_update_controller.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include <public/WebTransformationMatrix.h>
 
@@ -51,7 +51,7 @@ public:
     TiledLayerTest()
         : m_compositorInitializer(0)
         , m_context(WebKit::createFakeGraphicsContext())
-        , m_queue(make_scoped_ptr(new TextureUpdateQueue))
+        , m_queue(make_scoped_ptr(new ResourceUpdateQueue))
         , m_textureManager(PrioritizedTextureManager::create(60*1024*1024, 1024, Renderer::ContentPool))
         , m_occlusion(0)
     {
@@ -101,14 +101,14 @@ public:
     {
         DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
         DCHECK(m_queue);
-        scoped_ptr<TextureUpdateController> updateController =
-            TextureUpdateController::create(
+        scoped_ptr<ResourceUpdateController> updateController =
+            ResourceUpdateController::create(
                 NULL,
                 Proxy::implThread(),
                 m_queue.Pass(),
                 m_resourceProvider.get());
         updateController->finalize();
-        m_queue = make_scoped_ptr(new TextureUpdateQueue);
+        m_queue = make_scoped_ptr(new ResourceUpdateQueue);
     }
     void layerPushPropertiesTo(FakeTiledLayer* layer, FakeTiledLayerImpl* layerImpl)
     {
@@ -160,7 +160,7 @@ public:
     WebKitTests::WebCompositorInitializer m_compositorInitializer;
     scoped_ptr<GraphicsContext> m_context;
     scoped_ptr<ResourceProvider> m_resourceProvider;
-    scoped_ptr<TextureUpdateQueue> m_queue;
+    scoped_ptr<ResourceUpdateQueue> m_queue;
     RenderingStats m_stats;
     PriorityCalculator m_priorityCalculator;
     scoped_ptr<PrioritizedTextureManager> m_textureManager;