cc: Remove LayerTextureUpdater::Texture::updateRect() callback.

cc/layer_tree_host_unittest.cc

 // Copyright 2011 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 "CCLayerTreeHost.h"
 
 #include "CCGeometryTestUtils.h"
 #include "CCGraphicsContext.h"
@@ skipping 2380 matching lines @@
     MockContentLayerChromiumClient m_mockDelegate;
     scoped_refptr<ContentLayerChromiumWithUpdateTracking> m_rootLayer;
     scoped_refptr<ContentLayerChromiumWithUpdateTracking> m_surfaceLayer1;
     scoped_refptr<ContentLayerChromiumWithUpdateTracking> m_replicaLayer1;
     scoped_refptr<ContentLayerChromiumWithUpdateTracking> m_surfaceLayer2;
     scoped_refptr<ContentLayerChromiumWithUpdateTracking> m_replicaLayer2;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(CCLayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit)
 
-
-class EvictionTrackingTexture : public LayerTextureUpdater::Texture {
-public:
-    static PassOwnPtr<EvictionTrackingTexture> create(scoped_ptr<CCPrioritizedTexture> texture) { return adoptPtr(new EvictionTrackingTexture(texture.Pass())); }
-    virtual ~EvictionTrackingTexture() { }
-
-    virtual void updateRect(CCResourceProvider* resourceProvider, const IntRect&, const IntSize&) OVERRIDE
-    {
-        ASSERT_TRUE(!texture()->haveBackingTexture() || resourceProvider->numResources() > 0);
-        texture()->acquireBackingTexture(resourceProvider);
-        m_updated = true;
-    }
-    void resetUpdated() { m_updated = false; }
-    bool updated() const { return m_updated; }
-
-private:
-    explicit EvictionTrackingTexture(scoped_ptr<CCPrioritizedTexture> texture)
-        : LayerTextureUpdater::Texture(texture.Pass())
-        , m_updated(false)
-    { }
-    bool m_updated;
-};
-
 class EvictionTestLayer : public LayerChromium {
 public:
     static scoped_refptr<EvictionTestLayer> create() { return make_scoped_refptr(new EvictionTestLayer()); }
 
     virtual void update(CCTextureUpdateQueue&, const CCOcclusionTracker*, CCRenderingStats&) OVERRIDE;
     virtual bool drawsContent() const OVERRIDE { return true; }
 
     virtual scoped_ptr<CCLayerImpl> createCCLayerImpl() OVERRIDE;
     virtual void pushPropertiesTo(CCLayerImpl*) OVERRIDE;
     virtual void setTexturePriorities(const CCPriorityCalculator&) OVERRIDE;
 
-    void resetUpdated()
-    {
-        if (m_texture.get())
-            m_texture->resetUpdated();
-    }
-    bool updated() const { return m_texture.get() ? m_texture->updated() : false; }
+    bool haveBackingTexture() const { return m_texture.get() ? m_texture->haveBackingTexture() : false; }
 
 private:
     EvictionTestLayer() : LayerChromium() { }
     virtual ~EvictionTestLayer() { }
 
     void createTextureIfNeeded()
     {
         if (m_texture.get())
             return;
-        m_texture = EvictionTrackingTexture::create(CCPrioritizedTexture::create(layerTreeHost()->contentsTextureManager()));
-        m_texture->texture()->setDimensions(IntSize(10, 10), cc::GraphicsContext3D::RGBA);
+        m_texture = CCPrioritizedTexture::create(layerTreeHost()->contentsTextureManager());
+        m_texture->setDimensions(IntSize(10, 10), cc::GraphicsContext3D::RGBA);
+        m_bitmap.setConfig(SkBitmap::kARGB_8888_Config, 10, 10);
     }
 
-    OwnPtr<EvictionTrackingTexture> m_texture;
+    scoped_ptr<CCPrioritizedTexture> m_texture;
+    SkBitmap m_bitmap;
 };
 
 class EvictionTestLayerImpl : public CCLayerImpl {
 public:
     static scoped_ptr<EvictionTestLayerImpl> create(int id)
     {
         return make_scoped_ptr(new EvictionTestLayerImpl(id));
     }
     virtual ~EvictionTestLayerImpl() { }
 
@@ skipping 11 matching lines @@
         , m_hasTexture(false) { }
 
     bool m_hasTexture;
 };
 
 void EvictionTestLayer::setTexturePriorities(const CCPriorityCalculator&)
 {
     createTextureIfNeeded();
     if (!m_texture.get())
         return;
-    m_texture->texture()->setRequestPriority(CCPriorityCalculator::uiPriority(true));
+    m_texture->setRequestPriority(CCPriorityCalculator::uiPriority(true));
 }
 
 void EvictionTestLayer::update(CCTextureUpdateQueue& queue, const CCOcclusionTracker*, CCRenderingStats&)
 {
     createTextureIfNeeded();
     if (!m_texture.get())
         return;
     IntRect fullRect(0, 0, 10, 10);
-    TextureUploader::Parameters parameters = { m_texture.get(), fullRect, IntSize() };
-    queue.appendFullUpload(parameters);
+    TextureUploader::Parameters upload = { m_texture.get(), &m_bitmap, NULL, { fullRect, fullRect, IntSize() } };
+    queue.appendFullUpload(upload);
 }
 
 scoped_ptr<CCLayerImpl> EvictionTestLayer::createCCLayerImpl()
 {
     return EvictionTestLayerImpl::create(m_layerId).PassAs<CCLayerImpl>();
 }
 
 void EvictionTestLayer::pushPropertiesTo(CCLayerImpl* layerImpl)
 {
     LayerChromium::pushPropertiesTo(layerImpl);
 
     EvictionTestLayerImpl* testLayerImpl = static_cast<EvictionTestLayerImpl*>(layerImpl);
-    testLayerImpl->setHasTexture(m_texture->texture()->haveBackingTexture());
+    testLayerImpl->setHasTexture(m_texture->haveBackingTexture());
 }
 
 class CCLayerTreeHostTestEvictTextures : public CCLayerTreeHostTest {
 public:
     CCLayerTreeHostTestEvictTextures()
         : m_layer(EvictionTestLayer::create())
         , m_implForEvictTextures(0)
         , m_numCommits(0)
     {
     }
@@ skipping 46 matching lines @@
     // Commits 1+2 test the eviction recovery path where eviction happens outside
     // of the beginFrame/commit pair.
     // Commits 3+4 test the eviction recovery path where eviction happens inside
     // the beginFrame/commit pair.
     // Commits 5+6 test the path where an eviction happens during the eviction
     // recovery path.
     virtual void didCommitAndDrawFrame() OVERRIDE
     {
         switch (m_numCommits) {
         case 1:
-            EXPECT_TRUE(m_layer->updated());
+            EXPECT_TRUE(m_layer->haveBackingTexture());
             postEvictTextures();
             break;
         case 2:
-            EXPECT_TRUE(m_layer->updated());
+            EXPECT_TRUE(m_layer->haveBackingTexture());
             m_layerTreeHost->setNeedsCommit();
             break;
         case 3:
             break;
         case 4:
-            EXPECT_TRUE(m_layer->updated());
+            EXPECT_TRUE(m_layer->haveBackingTexture());
             m_layerTreeHost->setNeedsCommit();
             break;
         case 5:
             break;
         case 6:
-            EXPECT_TRUE(m_layer->updated());
+            EXPECT_TRUE(m_layer->haveBackingTexture());
             endTest();
             break;
         default:
             ASSERT_NOT_REACHED();
             break;
         }
     }
 
     virtual void commitCompleteOnCCThread(CCLayerTreeHostImpl* impl) OVERRIDE
     {
         m_implForEvictTextures = impl;
     }
 
     virtual void layout() OVERRIDE
     {
         ++m_numCommits;
         switch (m_numCommits) {
         case 1:
         case 2:
             break;
         case 3:
             postEvictTextures();
             break;
         case 4:
             // We couldn't check in didCommitAndDrawFrame on commit 3, so check here.
-            EXPECT_FALSE(m_layer->updated());
+            EXPECT_FALSE(m_layer->haveBackingTexture());
             break;
         case 5:
             postEvictTextures();
             break;
         case 6:
             // We couldn't check in didCommitAndDrawFrame on commit 5, so check here.
-            EXPECT_FALSE(m_layer->updated());
+            EXPECT_FALSE(m_layer->haveBackingTexture());
             postEvictTextures();
             break;
         default:
             ASSERT_NOT_REACHED();
             break;
         }
-        m_layer->resetUpdated();
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
 
 private:
     MockContentLayerChromiumClient m_client;
     scoped_refptr<EvictionTestLayer> m_layer;
     CCLayerTreeHostImpl* m_implForEvictTextures;
@@ skipping 56 matching lines @@
     // invisible (to prevent a commit that would recreate textures after
     // eviction, before the context recovery), and post a task that will evict
     // textures, then cause the context to be lost, and then set ourselves
     // visible again (to allow commits, since that's what causes context
     // recovery in single thread).
     virtual void didCommitAndDrawFrame() OVERRIDE
     {
         ++m_numCommits;
         switch (m_numCommits) {
         case 1:
-            EXPECT_TRUE(m_layer->updated());
+            EXPECT_TRUE(m_layer->haveBackingTexture());
             m_layerTreeHost->setVisible(false);
             postEvictTextures();
             m_layerTreeHost->loseContext(1);
             m_layerTreeHost->setVisible(true);
             break;
         default:
             break;
         }
     }
 
@@ skipping 274 matching lines @@
     int m_numCommitComplete;
     int m_numDrawLayers;
 };
 
 TEST_F(CCLayerTreeHostTestContinuousAnimate, runMultiThread)
 {
     runTest(true);
 }
 
 } // namespace