Move TextureCopier and TextureUploader from CCRenderer to CCResourceProvider

cc/CCTextureUpdateControllerTest.cpp

 // 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 "CCTextureUpdateController.h"
 
 #include "CCSchedulerTestCommon.h"
 #include "CCSingleThreadProxy.h" // For DebugScopedSetImplThread
@@ skipping 136 matching lines @@
         }
 
         m_numEndUploads++;
     }
 
 protected:
     virtual void SetUp()
     {
         m_context = FakeWebCompositorOutputSurface::create(adoptPtr(new WebGraphicsContext3DForUploadTest(this)));
         DebugScopedSetImplThread implThread;
-        m_resourceProvider = CCResourceProvider::create(m_context.get());
+        m_resourceProvider = CCResourceProvider::create(m_context.get(), UnthrottledUploader);
     }
 
     void appendFullUploadsToUpdateQueue(int count)
     {
         m_fullUploadCountExpected += count;
         m_totalUploadCountExpected += count;
 
         const IntRect rect(0, 0, 300, 150);
         const TextureUploader::Parameters upload = { &m_texture, rect, IntSize() };
         for (int i = 0; i < count; i++)
@@ skipping 15 matching lines @@
     {
         m_maxUploadCountPerUpdate = count;
     }
 
 protected:
     // Classes required to interact and test the CCTextureUpdateController
     OwnPtr<CCGraphicsContext> m_context;
     OwnPtr<CCResourceProvider> m_resourceProvider;
     OwnPtr<CCTextureUpdateQueue> m_queue;
     TextureForUploadTest m_texture;
-    FakeTextureCopier m_copier;
     TextureUploaderForUploadTest m_uploader;
     OwnPtr<WebThread> m_thread;
     WebCompositorInitializer m_compositorInitializer;
 
 
     // Properties / expectations of this test
     int m_fullUploadCountExpected;
     int m_partialCountExpected;
     int m_totalUploadCountExpected;
     int m_maxUploadCountPerUpdate;
@@ skipping 33 matching lines @@
 {
     m_test->onUpload();
 }
 
 
 // ZERO UPLOADS TESTS
 TEST_F(CCTextureUpdateControllerTest, ZeroUploads)
 {
     appendFullUploadsToUpdateQueue(0);
     appendPartialUploadsToUpdateQueue(0);
-    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), m_totalUploadCountExpected);
+    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_uploader, m_queue.get(), m_totalUploadCountExpected);
 
     EXPECT_EQ(0, m_numBeginUploads);
     EXPECT_EQ(0, m_numEndUploads);
     EXPECT_EQ(0, m_numPreviousFlushes);
     EXPECT_EQ(0, m_numPreviousUploads);
 }
 
 
 // ONE UPLOAD TESTS
 TEST_F(CCTextureUpdateControllerTest, OneFullUpload)
 {
     appendFullUploadsToUpdateQueue(1);
     appendPartialUploadsToUpdateQueue(0);
     DebugScopedSetImplThread implThread;
-    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), m_totalUploadCountExpected);
+    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_uploader, m_queue.get(), m_totalUploadCountExpected);
 
     EXPECT_EQ(1, m_numBeginUploads);
     EXPECT_EQ(1, m_numEndUploads);
     EXPECT_EQ(1, m_numPreviousFlushes);
     EXPECT_EQ(1, m_numPreviousUploads);
 }
 
 TEST_F(CCTextureUpdateControllerTest, OnePartialUpload)
 {
     appendFullUploadsToUpdateQueue(0);
     appendPartialUploadsToUpdateQueue(1);
     DebugScopedSetImplThread implThread;
-    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), m_totalUploadCountExpected);
+    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_uploader, m_queue.get(), m_totalUploadCountExpected);
 
     EXPECT_EQ(1, m_numBeginUploads);
     EXPECT_EQ(1, m_numEndUploads);
     EXPECT_EQ(1, m_numPreviousFlushes);
     EXPECT_EQ(1, m_numPreviousUploads);
 }
 
 TEST_F(CCTextureUpdateControllerTest, OneFullOnePartialUpload)
 {
     appendFullUploadsToUpdateQueue(1);
     appendPartialUploadsToUpdateQueue(1);
     DebugScopedSetImplThread implThread;
-    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), m_totalUploadCountExpected);
+    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_uploader, m_queue.get(), m_totalUploadCountExpected);
 
     // We expect the full uploads to be followed by a flush
     // before the partial uploads begin.
     EXPECT_EQ(1, m_numBeginUploads);
     EXPECT_EQ(1, m_numEndUploads);
     EXPECT_EQ(2, m_numPreviousFlushes);
     EXPECT_EQ(2, m_numPreviousUploads);
 }
 
 
 // NO REMAINDER TESTS
 // This class of tests upload a number of textures that is a multiple of the flush period.
 const int fullUploadFlushMultipler = 7;
 const int fullNoRemainderCount = fullUploadFlushMultipler * kFlushPeriodFull;
 
 const int partialUploadFlushMultipler = 11;
 const int partialNoRemainderCount = partialUploadFlushMultipler * kFlushPeriodPartial;
 
 TEST_F(CCTextureUpdateControllerTest, ManyFullUploadsNoRemainder)
 {
     appendFullUploadsToUpdateQueue(fullNoRemainderCount);
     appendPartialUploadsToUpdateQueue(0);
     DebugScopedSetImplThread implThread;
-    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), m_totalUploadCountExpected);
+    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_uploader, m_queue.get(), m_totalUploadCountExpected);
 
     EXPECT_EQ(1, m_numBeginUploads);
     EXPECT_EQ(1, m_numEndUploads);
     EXPECT_EQ(fullUploadFlushMultipler, m_numPreviousFlushes);
     EXPECT_EQ(fullNoRemainderCount, m_numPreviousUploads);
 }
 
 TEST_F(CCTextureUpdateControllerTest, ManyPartialUploadsNoRemainder)
 {
     appendFullUploadsToUpdateQueue(0);
     appendPartialUploadsToUpdateQueue(partialNoRemainderCount);
     DebugScopedSetImplThread implThread;
-    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), m_totalUploadCountExpected);
+    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_uploader, m_queue.get(), m_totalUploadCountExpected);
 
     EXPECT_EQ(1, m_numBeginUploads);
     EXPECT_EQ(1, m_numEndUploads);
     EXPECT_EQ(partialUploadFlushMultipler, m_numPreviousFlushes);
     EXPECT_EQ(partialNoRemainderCount, m_numPreviousUploads);
 }
 
 TEST_F(CCTextureUpdateControllerTest, ManyFullManyPartialUploadsNoRemainder)
 {
     appendFullUploadsToUpdateQueue(fullNoRemainderCount);
     appendPartialUploadsToUpdateQueue(partialNoRemainderCount);
     DebugScopedSetImplThread implThread;
-    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), m_totalUploadCountExpected);
+    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_uploader, m_queue.get(), m_totalUploadCountExpected);
 
     EXPECT_EQ(1, m_numBeginUploads);
     EXPECT_EQ(1, m_numEndUploads);
     EXPECT_EQ(fullUploadFlushMultipler + partialUploadFlushMultipler, m_numPreviousFlushes);
     EXPECT_EQ(fullNoRemainderCount + partialNoRemainderCount, m_numPreviousUploads);
 }
 
 
 // MIN/MAX REMAINDER TESTS
 // This class of tests mix and match uploading 1 more and 1 less texture
 // than a multiple of the flush period.
 
 const int fullMinRemainderCount = fullNoRemainderCount + 1;
 const int fullMaxRemainderCount = fullNoRemainderCount - 1;
 const int partialMinRemainderCount = partialNoRemainderCount + 1;
 const int partialMaxRemainderCount = partialNoRemainderCount - 1;
 
 TEST_F(CCTextureUpdateControllerTest, ManyFullAndPartialMinRemainder)
 {
     appendFullUploadsToUpdateQueue(fullMinRemainderCount);
     appendPartialUploadsToUpdateQueue(partialMinRemainderCount);
     DebugScopedSetImplThread implThread;
-    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), m_totalUploadCountExpected);
+    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_uploader, m_queue.get(), m_totalUploadCountExpected);
 
     EXPECT_EQ(1, m_numBeginUploads);
     EXPECT_EQ(1, m_numEndUploads);
     EXPECT_EQ(fullUploadFlushMultipler + partialUploadFlushMultipler + 2, m_numPreviousFlushes);
     EXPECT_EQ(fullMinRemainderCount + partialMinRemainderCount, m_numPreviousUploads);
 }
 
 TEST_F(CCTextureUpdateControllerTest, ManyFullAndPartialUploadsMaxRemainder)
 {
     appendFullUploadsToUpdateQueue(fullMaxRemainderCount);
     appendPartialUploadsToUpdateQueue(partialMaxRemainderCount);
     DebugScopedSetImplThread implThread;
-    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), m_totalUploadCountExpected);
+    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_uploader, m_queue.get(), m_totalUploadCountExpected);
 
     EXPECT_EQ(1, m_numBeginUploads);
     EXPECT_EQ(1, m_numEndUploads);
     EXPECT_EQ(fullUploadFlushMultipler + partialUploadFlushMultipler, m_numPreviousFlushes);
     EXPECT_EQ(fullMaxRemainderCount + partialMaxRemainderCount, m_numPreviousUploads);
 }
 
 TEST_F(CCTextureUpdateControllerTest, ManyFullMinRemainderManyPartialMaxRemainder)
 {
     appendFullUploadsToUpdateQueue(fullMinRemainderCount);
     appendPartialUploadsToUpdateQueue(partialMaxRemainderCount);
     DebugScopedSetImplThread implThread;
-    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), m_totalUploadCountExpected);
+    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_uploader, m_queue.get(), m_totalUploadCountExpected);
 
     EXPECT_EQ(1, m_numBeginUploads);
     EXPECT_EQ(1, m_numEndUploads);
     EXPECT_EQ((fullUploadFlushMultipler+1) + partialUploadFlushMultipler, m_numPreviousFlushes);
     EXPECT_EQ(fullMinRemainderCount + partialMaxRemainderCount, m_numPreviousUploads);
 }
 
 TEST_F(CCTextureUpdateControllerTest, ManyFullMaxRemainderManyPartialMinRemainder)
 {
     appendFullUploadsToUpdateQueue(fullMaxRemainderCount);
     appendPartialUploadsToUpdateQueue(partialMinRemainderCount);
     DebugScopedSetImplThread implThread;
-    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), m_totalUploadCountExpected);
+    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_uploader, m_queue.get(), m_totalUploadCountExpected);
 
     EXPECT_EQ(1, m_numBeginUploads);
     EXPECT_EQ(1, m_numEndUploads);
     EXPECT_EQ(fullUploadFlushMultipler + (partialUploadFlushMultipler+1), m_numPreviousFlushes);
     EXPECT_EQ(fullMaxRemainderCount + partialMinRemainderCount, m_numPreviousUploads);
 }
 
 
 // MULTIPLE UPDATE TESTS
 // These tests attempt to upload too many textures at once, requiring
@@ skipping 12 matching lines @@
 
     int expectedPreviousFlushes = 0;
     int expectedPreviousUploads = 0;
 
     setMaxUploadCountPerUpdate(kMaxUploadsPerUpdate);
     appendFullUploadsToUpdateQueue(kFullUploads);
     appendPartialUploadsToUpdateQueue(kPartialUploads);
 
     // First update (40 full)
     DebugScopedSetImplThread implThread;
-    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), kMaxUploadsPerUpdate);
+    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_uploader, m_queue.get(), kMaxUploadsPerUpdate);
 
     EXPECT_EQ(1, m_numBeginUploads);
     EXPECT_EQ(1, m_numEndUploads);
 
     expectedPreviousFlushes = expectedFlushes(kMaxUploadsPerUpdate, kFlushPeriodFull);
     EXPECT_EQ(expectedPreviousFlushes, m_numPreviousFlushes);
 
     expectedPreviousUploads = kMaxUploadsPerUpdate;
     EXPECT_EQ(expectedPreviousUploads, m_numPreviousUploads);
 
     // Second update (40 full)
-    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), kMaxUploadsPerUpdate);
+    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_uploader, m_queue.get(), kMaxUploadsPerUpdate);
 
     EXPECT_EQ(2, m_numBeginUploads);
     EXPECT_EQ(2, m_numEndUploads);
 
     expectedPreviousFlushes = expectedFlushes(kMaxUploadsPerUpdate, kFlushPeriodFull);
     EXPECT_EQ(expectedPreviousFlushes, m_numPreviousFlushes);
 
     expectedPreviousUploads = kMaxUploadsPerUpdate;
     EXPECT_EQ(expectedPreviousUploads, m_numPreviousUploads);
 
     // Third update (20 full, 20 partial)
-    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), kMaxUploadsPerUpdate);
+    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_uploader, m_queue.get(), kMaxUploadsPerUpdate);
 
     EXPECT_EQ(3, m_numBeginUploads);
     EXPECT_EQ(3, m_numEndUploads);
 
     expectedPreviousFlushes = expectedFlushes(kFullUploads-kMaxUploadsPerUpdate*2, kFlushPeriodFull) +
                               expectedFlushes(kPartialUploads, kFlushPeriodPartial);
     EXPECT_EQ(expectedPreviousFlushes, m_numPreviousFlushes);
 
     expectedPreviousUploads = (kFullUploads-kMaxUploadsPerUpdate*2)+kPartialUploads;
     EXPECT_EQ(expectedPreviousUploads, m_numPreviousUploads);
@@ skipping 10 matching lines @@
 
     int expectedPreviousFlushes = 0;
     int expectedPreviousUploads = 0;
 
     setMaxUploadCountPerUpdate(kMaxUploadsPerUpdate);
     appendFullUploadsToUpdateQueue(kFullUploads);
     appendPartialUploadsToUpdateQueue(kPartialUploads);
 
     // First update (40 full)
     DebugScopedSetImplThread implThread;
-    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), kMaxUploadsPerUpdate);
+    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_uploader, m_queue.get(), kMaxUploadsPerUpdate);
 
     EXPECT_EQ(1, m_numBeginUploads);
     EXPECT_EQ(1, m_numEndUploads);
 
     expectedPreviousFlushes = expectedFlushes(kMaxUploadsPerUpdate, kFlushPeriodFull);
     EXPECT_EQ(expectedPreviousFlushes, m_numPreviousFlushes);
 
     expectedPreviousUploads = kMaxUploadsPerUpdate;
     EXPECT_EQ(expectedPreviousUploads, m_numPreviousUploads);
 
     // Second update (30 full, optionally 10 partial)
-    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), kMaxUploadsPerUpdate);
+    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_uploader, m_queue.get(), kMaxUploadsPerUpdate);
 
     EXPECT_EQ(2, m_numBeginUploads);
     EXPECT_EQ(2, m_numEndUploads);
     EXPECT_LE(m_numPreviousUploads, kMaxUploadsPerUpdate);
     // Be lenient on the exact number of flushes here, as the number of flushes
     // will depend on whether some partial uploads were performed.
     // onFlush(), onUpload(), and onEndUpload() will do basic flush checks for us anyway.
 
     // Third update (30 partial OR 20 partial if 10 partial uploaded in second update)
-    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_copier, &m_uploader, m_queue.get(), kMaxUploadsPerUpdate);
+    CCTextureUpdateController::updateTextures(m_resourceProvider.get(), &m_uploader, m_queue.get(), kMaxUploadsPerUpdate);
 
     EXPECT_EQ(3, m_numBeginUploads);
     EXPECT_EQ(3, m_numEndUploads);
     EXPECT_LE(m_numPreviousUploads, kMaxUploadsPerUpdate);
     // Be lenient on the exact number of flushes here as well.
 
     // Final sanity checks
     EXPECT_EQ(kFullUploads + kPartialUploads, m_numTotalUploads);
 }
 
 class FakeCCTextureUpdateControllerClient : public cc::CCTextureUpdateControllerClient {
 public:
     FakeCCTextureUpdateControllerClient() { reset(); }
     void reset() { m_readyToFinalizeCalled = false; }
     bool readyToFinalizeCalled() const { return m_readyToFinalizeCalled; }
 
     virtual void readyToFinalizeTextureUpdates() OVERRIDE { m_readyToFinalizeCalled = true; }
 
 protected:
     bool m_readyToFinalizeCalled;
 };
 
 class FakeCCTextureUpdateController : public cc::CCTextureUpdateController {
 public:
-    static PassOwnPtr<FakeCCTextureUpdateController> create(cc::CCTextureUpdateControllerClient* client, cc::CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader)
+    static PassOwnPtr<FakeCCTextureUpdateController> create(cc::CCTextureUpdateControllerClient* client, cc::CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureUploader* uploader)
     {
-        return adoptPtr(new FakeCCTextureUpdateController(client, thread, queue, resourceProvider, copier, uploader));
+        return adoptPtr(new FakeCCTextureUpdateController(client, thread, queue, resourceProvider, uploader));
     }
 
     void setMonotonicTimeNow(double time) { m_monotonicTimeNow = time; }
     virtual double monotonicTimeNow() const OVERRIDE { return m_monotonicTimeNow; }
     void setUpdateMoreTexturesTime(double time) { m_updateMoreTexturesTime = time; }
     virtual double updateMoreTexturesTime() const OVERRIDE { return m_updateMoreTexturesTime; }
     void setUpdateMoreTexturesSize(size_t size) { m_updateMoreTexturesSize = size; }
     virtual size_t updateMoreTexturesSize() const OVERRIDE { return m_updateMoreTexturesSize; }
 
 protected:
-    FakeCCTextureUpdateController(cc::CCTextureUpdateControllerClient* client, cc::CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader)
-        : cc::CCTextureUpdateController(client, thread, queue, resourceProvider, copier, uploader)
+    FakeCCTextureUpdateController(cc::CCTextureUpdateControllerClient* client, cc::CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureUploader* uploader)
+        : cc::CCTextureUpdateController(client, thread, queue, resourceProvider, uploader)
         , m_monotonicTimeNow(0)
         , m_updateMoreTexturesTime(0)
         , m_updateMoreTexturesSize(0) { }
 
     double m_monotonicTimeNow;
     double m_updateMoreTexturesTime;
     size_t m_updateMoreTexturesSize;
 };
 
 static void runPendingTask(FakeCCThread* thread, FakeCCTextureUpdateController* controller)
 {
     EXPECT_TRUE(thread->hasPendingTask());
     controller->setMonotonicTimeNow(controller->monotonicTimeNow() + thread->pendingDelayMs() / 1000.0);
     thread->runPendingTask();
 }
 
 TEST_F(CCTextureUpdateControllerTest, UpdateMoreTextures)
 {
     FakeCCTextureUpdateControllerClient client;
     FakeCCThread thread;
 
     setMaxUploadCountPerUpdate(1);
     appendFullUploadsToUpdateQueue(3);
     appendPartialUploadsToUpdateQueue(0);
 
     DebugScopedSetImplThread implThread;
-    OwnPtr<FakeCCTextureUpdateController> controller(FakeCCTextureUpdateController::create(&client, &thread, m_queue.release(), m_resourceProvider.get(), &m_copier, &m_uploader));
+    OwnPtr<FakeCCTextureUpdateController> controller(FakeCCTextureUpdateController::create(&client, &thread, m_queue.release(), m_resourceProvider.get(), &m_uploader));
 
     controller->setMonotonicTimeNow(0);
     controller->setUpdateMoreTexturesTime(0.1);
     controller->setUpdateMoreTexturesSize(1);
     // Not enough time for any updates.
     controller->performMoreUpdates(0.09);
     EXPECT_FALSE(thread.hasPendingTask());
     EXPECT_EQ(0, m_numBeginUploads);
     EXPECT_EQ(0, m_numEndUploads);
 
@@ skipping 25 matching lines @@
 TEST_F(CCTextureUpdateControllerTest, NoMoreUpdates)
 {
     FakeCCTextureUpdateControllerClient client;
     FakeCCThread thread;
 
     setMaxUploadCountPerUpdate(1);
     appendFullUploadsToUpdateQueue(2);
     appendPartialUploadsToUpdateQueue(0);
 
     DebugScopedSetImplThread implThread;
-    OwnPtr<FakeCCTextureUpdateController> controller(FakeCCTextureUpdateController::create(&client, &thread, m_queue.release(), m_resourceProvider.get(), &m_copier, &m_uploader));
+    OwnPtr<FakeCCTextureUpdateController> controller(FakeCCTextureUpdateController::create(&client, &thread, m_queue.release(), m_resourceProvider.get(), &m_uploader));
 
     controller->setMonotonicTimeNow(0);
     controller->setUpdateMoreTexturesTime(0.1);
     controller->setUpdateMoreTexturesSize(1);
     // Enough time for 3 updates but only 2 necessary.
     controller->performMoreUpdates(0.31);
     runPendingTask(&thread, controller.get());
     runPendingTask(&thread, controller.get());
     EXPECT_FALSE(thread.hasPendingTask());
     EXPECT_TRUE(client.readyToFinalizeCalled());
@@ skipping 18 matching lines @@
 TEST_F(CCTextureUpdateControllerTest, UpdatesCompleteInFiniteTime)
 {
     FakeCCTextureUpdateControllerClient client;
     FakeCCThread thread;
 
     setMaxUploadCountPerUpdate(1);
     appendFullUploadsToUpdateQueue(2);
     appendPartialUploadsToUpdateQueue(0);
 
     DebugScopedSetImplThread implThread;
-    OwnPtr<FakeCCTextureUpdateController> controller(FakeCCTextureUpdateController::create(&client, &thread, m_queue.release(), m_resourceProvider.get(), &m_copier, &m_uploader));
+    OwnPtr<FakeCCTextureUpdateController> controller(FakeCCTextureUpdateController::create(&client, &thread, m_queue.release(), m_resourceProvider.get(), &m_uploader));
 
     controller->setMonotonicTimeNow(0);
     controller->setUpdateMoreTexturesTime(0.5);
     controller->setUpdateMoreTexturesSize(1);
 
     for (int i = 0; i < 100; i++) {
         if (client.readyToFinalizeCalled())
             break;
 
         // Not enough time for any updates.
         controller->performMoreUpdates(0.4);
 
         if (thread.hasPendingTask())
             runPendingTask(&thread, controller.get());
     }
 
     EXPECT_FALSE(thread.hasPendingTask());
     EXPECT_TRUE(client.readyToFinalizeCalled());
     EXPECT_EQ(2, m_numBeginUploads);
     EXPECT_EQ(2, m_numEndUploads);
     EXPECT_EQ(2, m_numTotalUploads);
 }
 
 } // namespace