cc: Measure texture upload time individually.

Measures each texture's upload time idividually to calculate
an expected texture upload rate. Removes the need for beginUpload
and endUpload.

BUG=152631


Review URL: https://chromiumcodereview.appspot.com/11031018

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

8 files changed, 47 insertions, 134 deletions

diff --git a/cc/CCTextureUpdateController.cpp b/cc/CCTextureUpdateController.cpp
index b58dc52..200948d 100644
--- a/cc/CCTextureUpdateController.cpp
+++ b/cc/CCTextureUpdateController.cpp
@@ -185,14 +185,12 @@ void CCTextureUpdateController::updateMoreTexturesNow()
         return;
 
     size_t uploadCount = 0;
-    m_uploader->beginUploads();
     while (m_queue->fullUploadSize() && uploadCount < uploads) {
         if (!(uploadCount % textureUploadFlushPeriod) && uploadCount)
             m_resourceProvider->shallowFlushIfSupported();
         m_uploader->uploadTexture(m_resourceProvider, m_queue->takeFirstFullUpload());
         uploadCount++;
     }
-    m_uploader->endUploads();
     m_resourceProvider->shallowFlushIfSupported();
 }
 
diff --git a/cc/CCTextureUpdateControllerTest.cpp b/cc/CCTextureUpdateControllerTest.cpp
index 464e46f..b57fad2 100644
--- a/cc/CCTextureUpdateControllerTest.cpp
+++ b/cc/CCTextureUpdateControllerTest.cpp
@@ -57,8 +57,6 @@ class TextureUploaderForUploadTest : public FakeTextureUploader {
 public:
     TextureUploaderForUploadTest(CCTextureUpdateControllerTest *test) : m_test(test) { }
 
-    virtual void beginUploads() OVERRIDE;
-    virtual void endUploads() OVERRIDE;
     virtual void uploadTexture(cc::CCResourceProvider*, Parameters) OVERRIDE;
 
 private:
@@ -90,14 +88,10 @@ public:
         , m_partialCountExpected(0)
         , m_totalUploadCountExpected(0)
         , m_maxUploadCountPerUpdate(0)
-        , m_numBeginUploads(0)
-        , m_numEndUploads(0)
         , m_numConsecutiveFlushes(0)
         , m_numDanglingUploads(0)
         , m_numTotalUploads(0)
         , m_numTotalFlushes(0)
-        , m_numPreviousUploads(0)
-        , m_numPreviousFlushes(0)
     {
     }
 
@@ -107,27 +101,9 @@ public:
         // Check for back-to-back flushes.
         EXPECT_EQ(0, m_numConsecutiveFlushes) << "Back-to-back flushes detected.";
 
-        // Check for premature flushes
-        if (m_numPreviousUploads != m_maxUploadCountPerUpdate) {
-            if (m_numTotalUploads < m_fullUploadCountExpected)
-                EXPECT_GE(m_numDanglingUploads, kFlushPeriodFull) << "Premature flush detected in full uploads.";
-            else if (m_numTotalUploads > m_fullUploadCountExpected && m_numTotalUploads < m_totalUploadCountExpected)
-                EXPECT_GE(m_numDanglingUploads, kFlushPeriodPartial) << "Premature flush detected in partial uploads.";
-        }
-
         m_numDanglingUploads = 0;
         m_numConsecutiveFlushes++;
         m_numTotalFlushes++;
-        m_numPreviousFlushes++;
-    }
-
-    void onBeginUploads()
-    {
-        EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
-
-        m_numPreviousFlushes = 0;
-        m_numPreviousUploads = 0;
-        m_numBeginUploads++;
     }
 
     void onUpload()
@@ -141,20 +117,6 @@ public:
         m_numConsecutiveFlushes = 0;
         m_numDanglingUploads++;
         m_numTotalUploads++;
-        m_numPreviousUploads++;
-    }
-
-    void onEndUploads()
-    {
-        // Note: The m_numTotalUploads != m_fullUploadCountExpected comparison
-        // allows for the quota not to be hit in the case where we are trasitioning
-        // from full uploads to partial uploads.
-        if (m_numTotalUploads != m_totalUploadCountExpected && m_numTotalUploads != m_fullUploadCountExpected) {
-            EXPECT_EQ(m_maxUploadCountPerUpdate, m_numPreviousUploads)
-                << "endUpload() was called when there are textures to upload, but the upload quota hasn't been filled.";
-        }
-
-        m_numEndUploads++;
     }
 
 protected:
@@ -233,14 +195,10 @@ protected:
     int m_maxUploadCountPerUpdate;
 
     // Dynamic properties of this test
-    int m_numBeginUploads;
-    int m_numEndUploads;
     int m_numConsecutiveFlushes;
     int m_numDanglingUploads;
     int m_numTotalUploads;
     int m_numTotalFlushes;
-    int m_numPreviousUploads;
-    int m_numPreviousFlushes;
 };
 
 void WebGraphicsContext3DForUploadTest::flush(void)
@@ -253,16 +211,6 @@ void WebGraphicsContext3DForUploadTest::shallowFlushCHROMIUM(void)
     m_test->onFlush();
 }
 
-void TextureUploaderForUploadTest::beginUploads()
-{
-    m_test->onBeginUploads();
-}
-
-void TextureUploaderForUploadTest::endUploads()
-{
-    m_test->onEndUploads();
-}
-
 void TextureUploaderForUploadTest::uploadTexture(cc::CCResourceProvider*, Parameters)
 {
     m_test->onUpload();
@@ -276,8 +224,8 @@ TEST_F(CCTextureUpdateControllerTest, ZeroUploads)
     DebugScopedSetImplThread implThread;
     updateTextures();
 
-    EXPECT_EQ(0, m_numPreviousFlushes);
-    EXPECT_EQ(0, m_numPreviousUploads);
+    EXPECT_EQ(0, m_numTotalFlushes);
+    EXPECT_EQ(0, m_numTotalUploads);
 }
 
 
@@ -289,8 +237,8 @@ TEST_F(CCTextureUpdateControllerTest, OneFullUpload)
     DebugScopedSetImplThread implThread;
     updateTextures();
 
-    EXPECT_EQ(1, m_numPreviousFlushes);
-    EXPECT_EQ(1, m_numPreviousUploads);
+    EXPECT_EQ(1, m_numTotalFlushes);
+    EXPECT_EQ(1, m_numTotalUploads);
     EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
@@ -301,8 +249,8 @@ TEST_F(CCTextureUpdateControllerTest, OnePartialUpload)
     DebugScopedSetImplThread implThread;
     updateTextures();
 
-    EXPECT_EQ(1, m_numPreviousFlushes);
-    EXPECT_EQ(1, m_numPreviousUploads);
+    EXPECT_EQ(1, m_numTotalFlushes);
+    EXPECT_EQ(1, m_numTotalUploads);
     EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
@@ -313,8 +261,8 @@ TEST_F(CCTextureUpdateControllerTest, OneFullOnePartialUpload)
     DebugScopedSetImplThread implThread;
     updateTextures();
 
-    EXPECT_EQ(1, m_numPreviousFlushes);
-    EXPECT_EQ(2, m_numPreviousUploads);
+    EXPECT_EQ(1, m_numTotalFlushes);
+    EXPECT_EQ(2, m_numTotalUploads);
     EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
@@ -333,8 +281,8 @@ TEST_F(CCTextureUpdateControllerTest, ManyFullUploads)
     DebugScopedSetImplThread implThread;
     updateTextures();
 
-    EXPECT_EQ(fullUploadFlushMultipler, m_numPreviousFlushes);
-    EXPECT_EQ(fullCount, m_numPreviousUploads);
+    EXPECT_EQ(fullUploadFlushMultipler, m_numTotalFlushes);
+    EXPECT_EQ(fullCount, m_numTotalUploads);
     EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
@@ -345,8 +293,8 @@ TEST_F(CCTextureUpdateControllerTest, ManyPartialUploads)
     DebugScopedSetImplThread implThread;
     updateTextures();
 
-    EXPECT_EQ(partialUploadFlushMultipler, m_numPreviousFlushes);
-    EXPECT_EQ(partialCount, m_numPreviousUploads);
+    EXPECT_EQ(partialUploadFlushMultipler, m_numTotalFlushes);
+    EXPECT_EQ(partialCount, m_numTotalUploads);
     EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
@@ -357,8 +305,8 @@ TEST_F(CCTextureUpdateControllerTest, ManyFullManyPartialUploads)
     DebugScopedSetImplThread implThread;
     updateTextures();
 
-    EXPECT_EQ(fullUploadFlushMultipler + partialUploadFlushMultipler, m_numPreviousFlushes);
-    EXPECT_EQ(fullCount + partialCount, m_numPreviousUploads);
+    EXPECT_EQ(fullUploadFlushMultipler + partialUploadFlushMultipler, m_numTotalFlushes);
+    EXPECT_EQ(fullCount + partialCount, m_numTotalUploads);
     EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
@@ -426,8 +374,6 @@ TEST_F(CCTextureUpdateControllerTest, UpdateMoreTextures)
     controller->performMoreUpdates(
         controller->now() + base::TimeDelta::FromMilliseconds(90));
     EXPECT_FALSE(thread.hasPendingTask());
-    EXPECT_EQ(0, m_numBeginUploads);
-    EXPECT_EQ(0, m_numEndUploads);
 
     controller->setUpdateMoreTexturesTime(
         base::TimeDelta::FromMilliseconds(100));
@@ -437,8 +383,6 @@ TEST_F(CCTextureUpdateControllerTest, UpdateMoreTextures)
         controller->now() + base::TimeDelta::FromMilliseconds(120));
     runPendingTask(&thread, controller.get());
     EXPECT_FALSE(thread.hasPendingTask());
-    EXPECT_EQ(1, m_numBeginUploads);
-    EXPECT_EQ(1, m_numEndUploads);
     EXPECT_EQ(1, m_numTotalUploads);
 
     controller->setUpdateMoreTexturesTime(
@@ -451,8 +395,6 @@ TEST_F(CCTextureUpdateControllerTest, UpdateMoreTextures)
     runPendingTask(&thread, controller.get());
     EXPECT_FALSE(thread.hasPendingTask());
     EXPECT_TRUE(client.readyToFinalizeCalled());
-    EXPECT_EQ(3, m_numBeginUploads);
-    EXPECT_EQ(3, m_numEndUploads);
     EXPECT_EQ(3, m_numTotalUploads);
 }
 
@@ -480,8 +422,6 @@ TEST_F(CCTextureUpdateControllerTest, NoMoreUpdates)
     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);
 
     controller->setUpdateMoreTexturesTime(
@@ -494,8 +434,6 @@ TEST_F(CCTextureUpdateControllerTest, NoMoreUpdates)
     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);
 }
 
@@ -531,8 +469,6 @@ TEST_F(CCTextureUpdateControllerTest, UpdatesCompleteInFiniteTime)
 
     EXPECT_FALSE(thread.hasPendingTask());
     EXPECT_TRUE(client.readyToFinalizeCalled());
-    EXPECT_EQ(2, m_numBeginUploads);
-    EXPECT_EQ(2, m_numEndUploads);
     EXPECT_EQ(2, m_numTotalUploads);
 }
 
diff --git a/cc/TextureUploader.h b/cc/TextureUploader.h
index 7918627..5505204 100644
--- a/cc/TextureUploader.h
+++ b/cc/TextureUploader.h
@@ -24,8 +24,6 @@ public:
 
     // Returns our throughput on the GPU process
     virtual double estimatedTexturesPerSecond() = 0;
-    virtual void beginUploads() = 0;
-    virtual void endUploads() = 0;
     virtual void uploadTexture(CCResourceProvider*, Parameters) = 0;
 };
 
diff --git a/cc/ThrottledTextureUploader.cpp b/cc/ThrottledTextureUploader.cpp
index 401b2b0..c152598 100644
--- a/cc/ThrottledTextureUploader.cpp
+++ b/cc/ThrottledTextureUploader.cpp
@@ -6,14 +6,16 @@
 #include "ThrottledTextureUploader.h"
 
 #include "Extensions3DChromium.h"
+#include "TraceEvent.h"
 #include <algorithm>
+#include <public/Platform.h>
 #include <public/WebGraphicsContext3D.h>
 #include <vector>
 
 namespace {
 
 // How many previous uploads to use when predicting future throughput.
-static const size_t uploadHistorySize = 10;
+static const size_t uploadHistorySize = 100;
 
 // Global estimated number of textures per second to maintain estimates across
 // subsequent instances of ThrottledTextureUploader.
@@ -29,7 +31,6 @@ ThrottledTextureUploader::Query::Query(WebKit::WebGraphicsContext3D* context)
     , m_queryId(0)
     , m_value(0)
     , m_hasValue(false)
-    , m_texturesUploaded(0)
     , m_isNonBlocking(false)
 {
     m_queryId = m_context->createQueryEXT();
@@ -47,10 +48,9 @@ void ThrottledTextureUploader::Query::begin()
     m_context->beginQueryEXT(Extensions3DChromium::COMMANDS_ISSUED_CHROMIUM, m_queryId);
 }
 
-void ThrottledTextureUploader::Query::end(size_t texturesUploaded)
+void ThrottledTextureUploader::Query::end()
 {
     m_context->endQueryEXT(Extensions3DChromium::COMMANDS_ISSUED_CHROMIUM);
-    m_texturesUploaded = texturesUploaded;
 }
 
 bool ThrottledTextureUploader::Query::isPending()
@@ -75,11 +75,6 @@ unsigned ThrottledTextureUploader::Query::value()
     return m_value;
 }
 
-size_t ThrottledTextureUploader::Query::texturesUploaded()
-{
-    return m_texturesUploaded;
-}
-
 void ThrottledTextureUploader::Query::markAsNonBlocking()
 {
     m_isNonBlocking = true;
@@ -93,7 +88,6 @@ bool ThrottledTextureUploader::Query::isNonBlocking()
 ThrottledTextureUploader::ThrottledTextureUploader(WebKit::WebGraphicsContext3D* context)
     : m_context(context)
     , m_texturesPerSecondHistory(uploadHistorySize, estimatedTexturesPerSecondGlobal)
-    , m_texturesUploaded(0)
     , m_numBlockingTextureUploads(0)
 {
 }
@@ -105,7 +99,6 @@ ThrottledTextureUploader::~ThrottledTextureUploader()
 size_t ThrottledTextureUploader::numBlockingUploads()
 {
     processQueries();
-
     return m_numBlockingTextureUploads;
 }
 
@@ -116,7 +109,7 @@ void ThrottledTextureUploader::markPendingUploadsAsNonBlocking()
         if (it->get()->isNonBlocking())
             continue;
 
-        m_numBlockingTextureUploads -= it->get()->texturesUploaded();
+        m_numBlockingTextureUploads--;
         it->get()->markAsNonBlocking();
     }
 
@@ -135,14 +128,13 @@ double ThrottledTextureUploader::estimatedTexturesPerSecond()
                                       m_texturesPerSecondHistory.end());
     std::sort(sortedHistory.begin(), sortedHistory.end());
 
-    estimatedTexturesPerSecondGlobal = sortedHistory[sortedHistory.size() / 2];
+    estimatedTexturesPerSecondGlobal = sortedHistory[sortedHistory.size() * 2 / 3];
+    TRACE_COUNTER1("cc", "estimatedTexturesPerSecond", estimatedTexturesPerSecondGlobal);
     return estimatedTexturesPerSecondGlobal;
 }
 
-void ThrottledTextureUploader::beginUploads()
+void ThrottledTextureUploader::beginQuery()
 {
-    m_texturesUploaded = 0;
-
     processQueries();
 
     if (m_availableQueries.isEmpty())
@@ -151,17 +143,25 @@ void ThrottledTextureUploader::beginUploads()
     m_availableQueries.first()->begin();
 }
 
-void ThrottledTextureUploader::endUploads()
+void ThrottledTextureUploader::endQuery()
 {
-    m_availableQueries.first()->end(m_texturesUploaded);
+    m_availableQueries.first()->end();
     m_pendingQueries.append(m_availableQueries.takeFirst());
-    m_numBlockingTextureUploads += m_texturesUploaded;
+    m_numBlockingTextureUploads++;
 }
 
 void ThrottledTextureUploader::uploadTexture(CCResourceProvider* resourceProvider, Parameters upload)
 {
-    m_texturesUploaded++;
+    bool isFullUpload = upload.destOffset.isZero() &&
+                        upload.sourceRect.size() == upload.texture->texture()->size();
+
+    if (isFullUpload)
+        beginQuery();
+
     upload.texture->updateRect(resourceProvider, upload.sourceRect, upload.destOffset);
+
+    if (isFullUpload)
+        endQuery();
 }
 
 void ThrottledTextureUploader::processQueries()
@@ -171,14 +171,13 @@ void ThrottledTextureUploader::processQueries()
             break;
 
         unsigned usElapsed = m_pendingQueries.first()->value();
-        size_t texturesUploaded = m_pendingQueries.first()->texturesUploaded();
-        double texturesPerSecond = static_cast<double>(texturesUploaded) /
-            (usElapsed * 1e-6);
+        WebKit::Platform::current()->histogramCustomCounts("Renderer4.TextureGpuUploadTimeUS", usElapsed, 0, 100000, 50);
 
         if (!m_pendingQueries.first()->isNonBlocking())
-            m_numBlockingTextureUploads -= texturesUploaded;
+            m_numBlockingTextureUploads--;
 
         // Remove the oldest values from our history and insert the new one
+        double texturesPerSecond = 1.0 / (usElapsed * 1e-6);
         m_texturesPerSecondHistory.pop_back();
         m_texturesPerSecondHistory.push_front(texturesPerSecond);
 
diff --git a/cc/ThrottledTextureUploader.h b/cc/ThrottledTextureUploader.h
index 96e44d8..f517401 100644
--- a/cc/ThrottledTextureUploader.h
+++ b/cc/ThrottledTextureUploader.h
@@ -28,8 +28,6 @@ public:
     virtual size_t numBlockingUploads() OVERRIDE;
     virtual void markPendingUploadsAsNonBlocking() OVERRIDE;
     virtual double estimatedTexturesPerSecond() OVERRIDE;
-    virtual void beginUploads() OVERRIDE;
-    virtual void endUploads() OVERRIDE;
     virtual void uploadTexture(CCResourceProvider*, Parameters) OVERRIDE;
 
 private:
@@ -40,7 +38,7 @@ private:
         virtual ~Query();
 
         void begin();
-        void end(size_t texturesUploaded);
+        void end();
         bool isPending();
         void wait();
         unsigned value();
@@ -55,19 +53,19 @@ private:
         unsigned m_queryId;
         unsigned m_value;
         bool m_hasValue;
-        size_t m_texturesUploaded;
         bool m_isNonBlocking;
     };
 
     ThrottledTextureUploader(WebKit::WebGraphicsContext3D*);
 
+    void beginQuery();
+    void endQuery();
     void processQueries();
 
     WebKit::WebGraphicsContext3D* m_context;
     Deque<OwnPtr<Query> > m_pendingQueries;
     Deque<OwnPtr<Query> > m_availableQueries;
     std::deque<double> m_texturesPerSecondHistory;
-    size_t m_texturesUploaded;
     size_t m_numBlockingTextureUploads;
 
     DISALLOW_COPY_AND_ASSIGN(ThrottledTextureUploader);
diff --git a/cc/ThrottledTextureUploaderTest.cpp b/cc/ThrottledTextureUploaderTest.cpp
index cc0ba16..5e03dca 100644
--- a/cc/ThrottledTextureUploaderTest.cpp
+++ b/cc/ThrottledTextureUploaderTest.cpp
@@ -46,9 +46,11 @@ private:
 class FakeTexture : public cc::LayerTextureUpdater::Texture {
 public:
   FakeTexture() : LayerTextureUpdater::Texture(
-      PassOwnPtr<cc::CCPrioritizedTexture>()) { }
+      CCPrioritizedTexture::create(NULL, IntSize(256,256), GL_RGBA)) {
+  }
+
+  virtual void updateRect(cc::CCResourceProvider* , const cc::IntRect&, const cc::IntSize&) OVERRIDE { }
 
-    virtual void updateRect(cc::CCResourceProvider* , const cc::IntRect&, const cc::IntSize&) OVERRIDE { }
 };
 
 
@@ -59,30 +61,22 @@ TEST(ThrottledTextureUploaderTest, NumBlockingUploads)
     OwnPtr<FakeTexture> texture = adoptPtr(new FakeTexture);
     TextureUploader::Parameters upload;
     upload.texture = texture.get();
-    upload.sourceRect = IntRect();
+    upload.sourceRect = IntRect(IntPoint(0,0), texture->texture()->size());
     upload.destOffset = IntSize();
 
     fakeContext->setResultAvailable(0);
     EXPECT_EQ(0, uploader->numBlockingUploads());
-    uploader->beginUploads();
     uploader->uploadTexture(NULL, upload);
-    uploader->endUploads();
     EXPECT_EQ(1, uploader->numBlockingUploads());
-    uploader->beginUploads();
     uploader->uploadTexture(NULL, upload);
-    uploader->endUploads();
     EXPECT_EQ(2, uploader->numBlockingUploads());
 
     fakeContext->setResultAvailable(1);
     EXPECT_EQ(0, uploader->numBlockingUploads());
-    uploader->beginUploads();
     uploader->uploadTexture(NULL, upload);
-    uploader->endUploads();
     EXPECT_EQ(0, uploader->numBlockingUploads());
-    uploader->beginUploads();
     uploader->uploadTexture(NULL, upload);
     uploader->uploadTexture(NULL, upload);
-    uploader->endUploads();
     EXPECT_EQ(0, uploader->numBlockingUploads());
 }
 
@@ -93,29 +87,23 @@ TEST(ThrottledTextureUploaderTest, MarkPendingUploadsAsNonBlocking)
     OwnPtr<FakeTexture> texture = adoptPtr(new FakeTexture);
     TextureUploader::Parameters upload;
     upload.texture = texture.get();
-    upload.sourceRect = IntRect();
+    upload.sourceRect = IntRect(IntPoint(0,0), texture->texture()->size());
     upload.destOffset = IntSize();
 
     fakeContext->setResultAvailable(0);
     EXPECT_EQ(0, uploader->numBlockingUploads());
-    uploader->beginUploads();
     uploader->uploadTexture(NULL, upload);
     uploader->uploadTexture(NULL, upload);
-    uploader->endUploads();
     EXPECT_EQ(2, uploader->numBlockingUploads());
 
     uploader->markPendingUploadsAsNonBlocking();
     EXPECT_EQ(0, uploader->numBlockingUploads());
-    uploader->beginUploads();
     uploader->uploadTexture(NULL, upload);
-    uploader->endUploads();
     EXPECT_EQ(1, uploader->numBlockingUploads());
 
     fakeContext->setResultAvailable(1);
     EXPECT_EQ(0, uploader->numBlockingUploads());
-    uploader->beginUploads();
     uploader->uploadTexture(NULL, upload);
-    uploader->endUploads();
     uploader->markPendingUploadsAsNonBlocking();
     EXPECT_EQ(0, uploader->numBlockingUploads());
 }
diff --git a/cc/UnthrottledTextureUploader.h b/cc/UnthrottledTextureUploader.h
index 565a090..bc0822a 100644
--- a/cc/UnthrottledTextureUploader.h
+++ b/cc/UnthrottledTextureUploader.h
@@ -22,8 +22,6 @@ public:
     virtual size_t numBlockingUploads() OVERRIDE;
     virtual void markPendingUploadsAsNonBlocking() OVERRIDE;
     virtual double estimatedTexturesPerSecond() OVERRIDE;
-    virtual void beginUploads() OVERRIDE { }
-    virtual void endUploads() OVERRIDE { }
     virtual void uploadTexture(CCResourceProvider* resourceProvider, Parameters upload) OVERRIDE;
 
 protected:
diff --git a/cc/test/CCTiledLayerTestCommon.h b/cc/test/CCTiledLayerTestCommon.h
index 884dbd2..99613c0 100644
--- a/cc/test/CCTiledLayerTestCommon.h
+++ b/cc/test/CCTiledLayerTestCommon.h
@@ -133,9 +133,7 @@ public:
     virtual size_t numBlockingUploads() OVERRIDE;
     virtual void markPendingUploadsAsNonBlocking() OVERRIDE;
     virtual double estimatedTexturesPerSecond() OVERRIDE;
-    virtual void beginUploads() OVERRIDE { }
-    virtual void endUploads() OVERRIDE { }
-    virtual void uploadTexture(cc::CCResourceProvider*, Parameters upload) OVERRIDE;
+    virtual void uploadTexture(cc::CCResourceProvider*, Parameters) OVERRIDE;
 };
 
 }