Diff
Modified: trunk/Source/WebCore/ChangeLog (126955 => 126956)
--- trunk/Source/WebCore/ChangeLog 2012-08-29 03:57:52 UTC (rev 126955)
+++ trunk/Source/WebCore/ChangeLog 2012-08-29 04:25:17 UTC (rev 126956)
@@ -1,3 +1,49 @@
+2012-08-28 David Reveman <[email protected]>
+
+ [Chromium] Scheduler will never process a commit until it receives a vsync tick.
+ https://bugs.webkit.org/show_bug.cgi?id=94721
+
+ Reviewed by James Robinson.
+
+ Add updateResourcesComplete callback to CCScheduler and use this to
+ indicate completion of texture updates instead of calling
+ CCSchedulerClient::hasMoreResourceUpdates when receiving a vsync tick.
+
+ Unit tests: CCTextureUpdateControllerTest.UpdateMoreTextures
+ CCTextureUpdateControllerTest.HasMoreUpdates
+ CCTextureUpdateControllerTest.UpdatesCompleteInFiniteTime
+
+ * platform/graphics/chromium/cc/CCScheduler.cpp:
+ (WebCore::CCScheduler::CCScheduler):
+ (WebCore::CCScheduler::beginFrameComplete):
+ (WebCore::CCScheduler::vsyncTick):
+ (WebCore::CCScheduler::updateResourcesComplete):
+ (WebCore):
+ (WebCore::CCScheduler::processScheduledActions):
+ * platform/graphics/chromium/cc/CCScheduler.h:
+ (CCSchedulerClient):
+ (CCScheduler):
+ * platform/graphics/chromium/cc/CCTextureUpdateController.cpp:
+ (WebCore::CCTextureUpdateController::CCTextureUpdateController):
+ (WebCore::CCTextureUpdateController::updateMoreTextures):
+ (WebCore::CCTextureUpdateController::discardUploads):
+ (WebCore::CCTextureUpdateController::onTimerFired):
+ (WebCore::CCTextureUpdateController::updateMoreTexturesIfEnoughTimeRemaining):
+ * platform/graphics/chromium/cc/CCTextureUpdateController.h:
+ (CCTextureUpdateControllerClient):
+ (WebCore::CCTextureUpdateControllerClient::~CCTextureUpdateControllerClient):
+ (WebCore):
+ (WebCore::CCTextureUpdateController::create):
+ (CCTextureUpdateController):
+ * platform/graphics/chromium/cc/CCThreadProxy.cpp:
+ (WebCore::CCThreadProxy::didLoseContextOnImplThread):
+ (WebCore::CCThreadProxy::beginFrameCompleteOnImplThread):
+ (WebCore::CCThreadProxy::scheduledActionCommit):
+ (WebCore::CCThreadProxy::updateTexturesCompleted):
+ (WebCore):
+ * platform/graphics/chromium/cc/CCThreadProxy.h:
+ (WebCore):
+
2012-08-28 John Bates <[email protected]>
[Chromium] Update some compositor trace events
Modified: trunk/Source/WebCore/platform/graphics/chromium/cc/CCScheduler.cpp (126955 => 126956)
--- trunk/Source/WebCore/platform/graphics/chromium/cc/CCScheduler.cpp 2012-08-29 03:57:52 UTC (rev 126955)
+++ trunk/Source/WebCore/platform/graphics/chromium/cc/CCScheduler.cpp 2012-08-29 04:25:17 UTC (rev 126956)
@@ -33,6 +33,7 @@
CCScheduler::CCScheduler(CCSchedulerClient* client, PassOwnPtr<CCFrameRateController> frameRateController)
: m_client(client)
, m_frameRateController(frameRateController)
+ , m_hasMoreResourceUpdates(false)
, m_updateMoreResourcesPending(false)
{
ASSERT(m_client);
@@ -87,9 +88,10 @@
processScheduledActions();
}
-void CCScheduler::beginFrameComplete()
+void CCScheduler::beginFrameComplete(bool hasResourceUpdates)
{
TRACE_EVENT0("cc", "CCScheduler::beginFrameComplete");
+ m_hasMoreResourceUpdates = hasResourceUpdates;
m_stateMachine.beginFrameComplete();
processScheduledActions();
}
@@ -136,7 +138,8 @@
{
if (m_updateMoreResourcesPending) {
m_updateMoreResourcesPending = false;
- m_stateMachine.beginUpdateMoreResourcesComplete(m_client->hasMoreResourceUpdates());
+ ASSERT(m_hasMoreResourceUpdates);
+ m_stateMachine.beginUpdateMoreResourcesComplete(true);
}
TRACE_EVENT0("cc", "CCScheduler::vsyncTick");
@@ -145,6 +148,17 @@
m_stateMachine.didLeaveVSync();
}
+void CCScheduler::updateResourcesComplete()
+{
+ TRACE_EVENT0("cc", "CCScheduler::updateResourcesComplete");
+ if (m_updateMoreResourcesPending) {
+ m_updateMoreResourcesPending = false;
+ m_stateMachine.beginUpdateMoreResourcesComplete(false);
+ }
+ m_hasMoreResourceUpdates = false;
+ processScheduledActions();
+}
+
CCSchedulerStateMachine::Action CCScheduler::nextAction()
{
m_stateMachine.setCanDraw(m_client->canDraw());
@@ -174,7 +188,7 @@
m_client->scheduledActionBeginFrame();
break;
case CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES:
- if (m_client->hasMoreResourceUpdates()) {
+ if (m_hasMoreResourceUpdates) {
m_client->scheduledActionUpdateMoreResources(m_frameRateController->nextTickTimeIfActivated());
m_updateMoreResourcesPending = true;
} else
Modified: trunk/Source/WebCore/platform/graphics/chromium/cc/CCScheduler.h (126955 => 126956)
--- trunk/Source/WebCore/platform/graphics/chromium/cc/CCScheduler.h 2012-08-29 03:57:52 UTC (rev 126955)
+++ trunk/Source/WebCore/platform/graphics/chromium/cc/CCScheduler.h 2012-08-29 04:25:17 UTC (rev 126956)
@@ -53,7 +53,6 @@
class CCSchedulerClient {
public:
virtual bool canDraw() = 0;
- virtual bool hasMoreResourceUpdates() const = 0;
virtual void scheduledActionBeginFrame() = 0;
virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapIfPossible() = 0;
@@ -93,7 +92,7 @@
// Like setNeedsRedraw(), but ensures the draw will definitely happen even if we are not visible.
void setNeedsForcedRedraw();
- void beginFrameComplete();
+ void beginFrameComplete(bool hasResourceUpdates);
void beginFrameAborted();
void setMaxFramesPending(int);
@@ -110,6 +109,8 @@
// CCFrameRateControllerClient implementation
virtual void vsyncTick() OVERRIDE;
+ void updateResourcesComplete();
+
private:
CCScheduler(CCSchedulerClient*, PassOwnPtr<CCFrameRateController>);
@@ -119,6 +120,7 @@
CCSchedulerClient* m_client;
OwnPtr<CCFrameRateController> m_frameRateController;
CCSchedulerStateMachine m_stateMachine;
+ bool m_hasMoreResourceUpdates;
bool m_updateMoreResourcesPending;
};
Modified: trunk/Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp (126955 => 126956)
--- trunk/Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp 2012-08-29 03:57:52 UTC (rev 126955)
+++ trunk/Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.cpp 2012-08-29 04:25:17 UTC (rev 126956)
@@ -113,8 +113,9 @@
copier->flush();
}
-CCTextureUpdateController::CCTextureUpdateController(CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader)
- : m_timer(adoptPtr(new CCTimer(thread, this)))
+CCTextureUpdateController::CCTextureUpdateController(CCTextureUpdateControllerClient* client, CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader)
+ : m_client(client)
+ , m_timer(adoptPtr(new CCTimer(thread, this)))
, m_queue(queue)
, m_resourceProvider(resourceProvider)
, m_copier(copier)
@@ -128,34 +129,40 @@
{
}
-bool CCTextureUpdateController::hasMoreUpdates() const
-{
- return m_queue->hasMoreUpdates();
-}
-
void CCTextureUpdateController::updateMoreTextures(double monotonicTimeLimit)
{
+ ASSERT(monotonicTimeLimit >= m_monotonicTimeLimit);
m_monotonicTimeLimit = monotonicTimeLimit;
- if (!m_queue->hasMoreUpdates())
+ // Update already in progress.
+ if (m_timer->isActive())
return;
// Call updateMoreTexturesNow() directly unless it's the first update
// attempt. This ensures that we empty the update queue in a finite
// amount of time.
if (m_firstUpdateAttempt) {
- updateMoreTexturesIfEnoughTimeRemaining();
+ // Post a 0-delay task when no updates were left. When it runs,
+ // updateTexturesCompleted() will be called.
+ if (!updateMoreTexturesIfEnoughTimeRemaining())
+ m_timer->startOneShot(0);
+
m_firstUpdateAttempt = false;
} else
updateMoreTexturesNow();
}
+void CCTextureUpdateController::discardUploads()
+{
+ // CCTextureUpdateControllerClient::updateTexturesCompleted will be
+ // called when all remaining texture copies are done.
+ m_queue->clearUploads();
+}
+
void CCTextureUpdateController::onTimerFired()
{
- if (!m_queue->hasMoreUpdates())
- return;
-
- updateMoreTexturesIfEnoughTimeRemaining();
+ if (!updateMoreTexturesIfEnoughTimeRemaining())
+ m_client->updateTexturesCompleted();
}
double CCTextureUpdateController::monotonicTimeNow() const
@@ -173,11 +180,16 @@
return textureUpdatesPerTick;
}
-void CCTextureUpdateController::updateMoreTexturesIfEnoughTimeRemaining()
+bool CCTextureUpdateController::updateMoreTexturesIfEnoughTimeRemaining()
{
+ if (!m_queue->hasMoreUpdates())
+ return false;
+
bool hasTimeRemaining = monotonicTimeNow() < m_monotonicTimeLimit - updateMoreTexturesTime();
if (hasTimeRemaining)
updateMoreTexturesNow();
+
+ return true;
}
void CCTextureUpdateController::updateMoreTexturesNow()
Modified: trunk/Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.h (126955 => 126956)
--- trunk/Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.h 2012-08-29 03:57:52 UTC (rev 126955)
+++ trunk/Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateController.h 2012-08-29 04:25:17 UTC (rev 126956)
@@ -36,21 +36,31 @@
class TextureCopier;
class TextureUploader;
+class CCTextureUpdateControllerClient {
+public:
+ virtual void updateTexturesCompleted() = 0;
+
+protected:
+ virtual ~CCTextureUpdateControllerClient() { }
+};
+
class CCTextureUpdateController : public CCTimerClient {
WTF_MAKE_NONCOPYABLE(CCTextureUpdateController);
public:
- static PassOwnPtr<CCTextureUpdateController> create(CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader)
+ static PassOwnPtr<CCTextureUpdateController> create(CCTextureUpdateControllerClient* client, CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader)
{
- return adoptPtr(new CCTextureUpdateController(thread, queue, resourceProvider, copier, uploader));
+ return adoptPtr(new CCTextureUpdateController(client, thread, queue, resourceProvider, copier, uploader));
}
static size_t maxPartialTextureUpdates();
static void updateTextures(CCResourceProvider*, TextureCopier*, TextureUploader*, CCTextureUpdateQueue*, size_t count);
virtual ~CCTextureUpdateController();
- bool hasMoreUpdates() const;
void updateMoreTextures(double monotonicTimeLimit);
+ // Discard all remaining uploads.
+ void discardUploads();
+
// CCTimerClient implementation.
virtual void onTimerFired() OVERRIDE;
@@ -60,11 +70,13 @@
virtual size_t updateMoreTexturesSize() const;
protected:
- CCTextureUpdateController(CCThread*, PassOwnPtr<CCTextureUpdateQueue>, CCResourceProvider*, TextureCopier*, TextureUploader*);
+ CCTextureUpdateController(CCTextureUpdateControllerClient*, CCThread*, PassOwnPtr<CCTextureUpdateQueue>, CCResourceProvider*, TextureCopier*, TextureUploader*);
- void updateMoreTexturesIfEnoughTimeRemaining();
+ // This returns true when there were textures left to update.
+ bool updateMoreTexturesIfEnoughTimeRemaining();
void updateMoreTexturesNow();
+ CCTextureUpdateControllerClient* m_client;
OwnPtr<CCTimer> m_timer;
OwnPtr<CCTextureUpdateQueue> m_queue;
bool m_contentsTexturesPurged;
Modified: trunk/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp (126955 => 126956)
--- trunk/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp 2012-08-29 03:57:52 UTC (rev 126955)
+++ trunk/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp 2012-08-29 04:25:17 UTC (rev 126956)
@@ -34,7 +34,6 @@
#include "CCLayerTreeHost.h"
#include "CCScheduler.h"
#include "CCScopedThreadProxy.h"
-#include "CCTextureUpdateController.h"
#include "CCThreadTask.h"
#include "TraceEvent.h"
#include <public/WebSharedGraphicsContext3D.h>
@@ -314,7 +313,8 @@
{
ASSERT(isImplThread());
TRACE_EVENT0("cc", "CCThreadProxy::didLoseContextOnImplThread");
- m_currentTextureUpdateControllerOnImplThread.clear();
+ if (m_currentTextureUpdateControllerOnImplThread)
+ m_currentTextureUpdateControllerOnImplThread->discardUploads();
m_schedulerOnImplThread->didLoseContext();
}
@@ -578,10 +578,12 @@
} else
m_resetContentsTexturesPurgedAfterCommitOnImplThread = true;
- m_currentTextureUpdateControllerOnImplThread = CCTextureUpdateController::create(CCProxy::implThread(), queue, m_layerTreeHostImpl->resourceProvider(), m_layerTreeHostImpl->renderer()->textureCopier(), m_layerTreeHostImpl->renderer()->textureUploader());
+ bool hasResourceUpdates = queue->hasMoreUpdates();
+ if (hasResourceUpdates)
+ m_currentTextureUpdateControllerOnImplThread = CCTextureUpdateController::create(this, CCProxy::implThread(), queue, m_layerTreeHostImpl->resourceProvider(), m_layerTreeHostImpl->renderer()->textureCopier(), m_layerTreeHostImpl->renderer()->textureUploader());
m_commitCompletionEventOnImplThread = completion;
- m_schedulerOnImplThread->beginFrameComplete();
+ m_schedulerOnImplThread->beginFrameComplete(hasResourceUpdates);
}
void CCThreadProxy::beginFrameAbortedOnImplThread()
@@ -594,13 +596,6 @@
m_schedulerOnImplThread->beginFrameAborted();
}
-bool CCThreadProxy::hasMoreResourceUpdates() const
-{
- if (!m_currentTextureUpdateControllerOnImplThread)
- return false;
- return m_currentTextureUpdateControllerOnImplThread->hasMoreUpdates();
-}
-
bool CCThreadProxy::canDraw()
{
ASSERT(isImplThread());
@@ -620,7 +615,6 @@
{
TRACE_EVENT0("cc", "CCThreadProxy::scheduledActionCommit");
ASSERT(isImplThread());
- ASSERT(!hasMoreResourceUpdates());
ASSERT(m_commitCompletionEventOnImplThread);
m_currentTextureUpdateControllerOnImplThread.clear();
@@ -758,6 +752,12 @@
return scheduledActionDrawAndSwapInternal(true);
}
+void CCThreadProxy::updateTexturesCompleted()
+{
+ ASSERT(isImplThread());
+ m_schedulerOnImplThread->updateResourcesComplete();
+}
+
void CCThreadProxy::didCommitAndDrawFrame()
{
ASSERT(isMainThread());
Modified: trunk/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.h (126955 => 126956)
--- trunk/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.h 2012-08-29 03:57:52 UTC (rev 126955)
+++ trunk/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.h 2012-08-29 04:25:17 UTC (rev 126956)
@@ -30,6 +30,7 @@
#include "CCLayerTreeHostImpl.h"
#include "CCProxy.h"
#include "CCScheduler.h"
+#include "CCTextureUpdateController.h"
#include <wtf/OwnPtr.h>
namespace WebCore {
@@ -39,11 +40,10 @@
class CCScheduler;
class CCScopedThreadProxy;
class CCTextureUpdateQueue;
-class CCTextureUpdateController;
class CCThread;
class CCThreadProxyContextRecreationTimer;
-class CCThreadProxy : public CCProxy, CCLayerTreeHostImplClient, CCSchedulerClient {
+class CCThreadProxy : public CCProxy, CCLayerTreeHostImplClient, CCSchedulerClient, CCTextureUpdateControllerClient {
public:
static PassOwnPtr<CCProxy> create(CCLayerTreeHost*);
@@ -84,7 +84,6 @@
// CCSchedulerClient implementation
virtual bool canDraw() OVERRIDE;
- virtual bool hasMoreResourceUpdates() const OVERRIDE;
virtual void scheduledActionBeginFrame() OVERRIDE;
virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapIfPossible() OVERRIDE;
virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapForced() OVERRIDE;
@@ -93,6 +92,9 @@
virtual void scheduledActionBeginContextRecreation() OVERRIDE;
virtual void scheduledActionAcquireLayerTexturesForMainThread() OVERRIDE;
+ // CCTextureUpdateControllerClient implementation
+ virtual void updateTexturesCompleted() OVERRIDE;
+
private:
explicit CCThreadProxy(CCLayerTreeHost*);
friend class CCThreadProxyContextRecreationTimer;
Modified: trunk/Source/WebKit/chromium/ChangeLog (126955 => 126956)
--- trunk/Source/WebKit/chromium/ChangeLog 2012-08-29 03:57:52 UTC (rev 126955)
+++ trunk/Source/WebKit/chromium/ChangeLog 2012-08-29 04:25:17 UTC (rev 126956)
@@ -1,3 +1,15 @@
+2012-08-28 David Reveman <[email protected]>
+
+ [Chromium] Scheduler will never process a commit until it receives a vsync tick.
+ https://bugs.webkit.org/show_bug.cgi?id=94721
+
+ Reviewed by James Robinson.
+
+ * tests/CCSchedulerTest.cpp:
+ (WebKitTests::FakeCCSchedulerClient::reset):
+ (WebKitTests::TEST):
+ * tests/CCTextureUpdateControllerTest.cpp:
+
2012-08-28 Adam Barth <[email protected]>
Fix ASSERT in fast/events/touch/gesture/context-menu-on-two-finger-tap.html
Modified: trunk/Source/WebKit/chromium/tests/CCSchedulerTest.cpp (126955 => 126956)
--- trunk/Source/WebKit/chromium/tests/CCSchedulerTest.cpp 2012-08-29 03:57:52 UTC (rev 126955)
+++ trunk/Source/WebKit/chromium/tests/CCSchedulerTest.cpp 2012-08-29 04:25:17 UTC (rev 126956)
@@ -43,14 +43,12 @@
void reset()
{
m_actions.clear();
- m_hasMoreResourceUpdates = false;
m_canDraw = true;
m_drawWillHappen = true;
m_swapWillHappenIfDrawHappens = true;
m_numDraws = 0;
}
- void setHasMoreResourceUpdates(bool b) { m_hasMoreResourceUpdates = b; }
void setCanDraw(bool b) { m_canDraw = b; }
int numDraws() const { return m_numDraws; }
@@ -66,7 +64,6 @@
}
virtual bool canDraw() OVERRIDE { return m_canDraw; }
- virtual bool hasMoreResourceUpdates() const OVERRIDE { return m_hasMoreResourceUpdates; }
virtual void scheduledActionBeginFrame() OVERRIDE { m_actions.push_back("scheduledActionBeginFrame"); }
virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapIfPossible() OVERRIDE
{
@@ -113,9 +110,9 @@
EXPECT_FALSE(timeSource->active());
client.reset();
- // Since, hasMoreResourceUpdates is set to false,
+ // Since, hasResourceUpdates is false,
// beginFrameComplete should commit
- scheduler->beginFrameComplete();
+ scheduler->beginFrameComplete(false);
EXPECT_EQ(1, client.numActions());
EXPECT_STREQ("scheduledActionCommit", client.action(0));
EXPECT_TRUE(timeSource->active());
@@ -149,9 +146,9 @@
// Now setNeedsCommit again. Calling here means we need a second frame.
scheduler->setNeedsCommit();
- // Since, hasMoreResourceUpdates is set to false, and another commit is
+ // Since, hasResourceUpdates is false, and another commit is
// needed, beginFrameComplete should commit, then begin another frame.
- scheduler->beginFrameComplete();
+ scheduler->beginFrameComplete(false);
EXPECT_EQ(1, client.numActions());
EXPECT_STREQ("scheduledActionCommit", client.action(0));
client.reset();
@@ -184,7 +181,7 @@
EXPECT_FALSE(timeSource->active());
// Trigger the commit
- scheduler->beginFrameComplete();
+ scheduler->beginFrameComplete(false);
EXPECT_TRUE(timeSource->active());
client.reset();
@@ -212,7 +209,7 @@
scheduler->setVisible(true);
scheduler->setNeedsCommit();
- scheduler->beginFrameComplete();
+ scheduler->beginFrameComplete(false);
scheduler->setMainThreadNeedsLayerTextures();
client.reset();
// Verify that pending texture acquisition fires when visibility
@@ -381,7 +378,7 @@
EXPECT_FALSE(timeSource->active());
EXPECT_EQ(1, client.numDraws());
EXPECT_TRUE(scheduler->commitPending());
- scheduler->beginFrameComplete();
+ scheduler->beginFrameComplete(false);
timeSource->tick();
EXPECT_EQ(2, client.numDraws());
Modified: trunk/Source/WebKit/chromium/tests/CCTextureUpdateControllerTest.cpp (126955 => 126956)
--- trunk/Source/WebKit/chromium/tests/CCTextureUpdateControllerTest.cpp 2012-08-29 03:57:52 UTC (rev 126955)
+++ trunk/Source/WebKit/chromium/tests/CCTextureUpdateControllerTest.cpp 2012-08-29 04:25:17 UTC (rev 126956)
@@ -541,11 +541,23 @@
EXPECT_EQ(kFullUploads + kPartialUploads, m_numTotalUploads);
}
+class FakeCCTextureUpdateControllerClient : public WebCore::CCTextureUpdateControllerClient {
+public:
+ FakeCCTextureUpdateControllerClient() { reset(); }
+ void reset() { m_completedCalled = false; }
+ bool completedCalled() const { return m_completedCalled; }
+
+ virtual void updateTexturesCompleted() OVERRIDE { m_completedCalled = true; }
+
+protected:
+ bool m_completedCalled;
+};
+
class FakeCCTextureUpdateController : public WebCore::CCTextureUpdateController {
public:
- static PassOwnPtr<FakeCCTextureUpdateController> create(WebCore::CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader)
+ static PassOwnPtr<FakeCCTextureUpdateController> create(WebCore::CCTextureUpdateControllerClient* client, WebCore::CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader)
{
- return adoptPtr(new FakeCCTextureUpdateController(thread, queue, resourceProvider, copier, uploader));
+ return adoptPtr(new FakeCCTextureUpdateController(client, thread, queue, resourceProvider, copier, uploader));
}
void setMonotonicTimeNow(double time) { m_monotonicTimeNow = time; }
@@ -556,8 +568,8 @@
virtual size_t updateMoreTexturesSize() const OVERRIDE { return m_updateMoreTexturesSize; }
protected:
- FakeCCTextureUpdateController(WebCore::CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader)
- : WebCore::CCTextureUpdateController(thread, queue, resourceProvider, copier, uploader)
+ FakeCCTextureUpdateController(WebCore::CCTextureUpdateControllerClient* client, WebCore::CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader)
+ : WebCore::CCTextureUpdateController(client, thread, queue, resourceProvider, copier, uploader)
, m_monotonicTimeNow(0)
, m_updateMoreTexturesTime(0)
, m_updateMoreTexturesSize(0) { }
@@ -567,8 +579,17 @@
size_t m_updateMoreTexturesSize;
};
+static void runPendingTasks(FakeCCThread* thread, FakeCCTextureUpdateController* controller)
+{
+ while (thread->hasPendingTask()) {
+ controller->setMonotonicTimeNow(controller->monotonicTimeNow() + thread->pendingDelayMs() / 1000.0);
+ thread->runPendingTask();
+ }
+}
+
TEST_F(CCTextureUpdateControllerTest, UpdateMoreTextures)
{
+ FakeCCTextureUpdateControllerClient client;
FakeCCThread thread;
setMaxUploadCountPerUpdate(1);
@@ -576,39 +597,34 @@
appendPartialUploadsToUpdateQueue(0);
DebugScopedSetImplThread implThread;
- OwnPtr<FakeCCTextureUpdateController> controller(FakeCCTextureUpdateController::create(&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_copier, &m_uploader));
controller->setMonotonicTimeNow(0);
controller->setUpdateMoreTexturesTime(0.1);
controller->setUpdateMoreTexturesSize(1);
// Not enough time for any updates.
controller->updateMoreTextures(0.09);
- EXPECT_FALSE(thread.hasPendingTask());
+ runPendingTasks(&thread, controller.get());
EXPECT_EQ(0, m_numBeginUploads);
EXPECT_EQ(0, m_numEndUploads);
- thread.reset();
controller->setMonotonicTimeNow(0);
controller->setUpdateMoreTexturesTime(0.1);
controller->setUpdateMoreTexturesSize(1);
// Only enough time for 1 update.
controller->updateMoreTextures(0.12);
- EXPECT_TRUE(thread.hasPendingTask());
- controller->setMonotonicTimeNow(thread.pendingDelayMs() / 1000.0);
- thread.runPendingTask();
+ runPendingTasks(&thread, controller.get());
EXPECT_EQ(1, m_numBeginUploads);
EXPECT_EQ(1, m_numEndUploads);
EXPECT_EQ(1, m_numTotalUploads);
- thread.reset();
controller->setMonotonicTimeNow(0);
controller->setUpdateMoreTexturesTime(0.1);
controller->setUpdateMoreTexturesSize(1);
// Enough time for 2 updates.
controller->updateMoreTextures(0.22);
- EXPECT_TRUE(thread.hasPendingTask());
- controller->setMonotonicTimeNow(controller->monotonicTimeNow() + thread.pendingDelayMs() / 1000.0);
- thread.runPendingTask();
+ runPendingTasks(&thread, controller.get());
+ EXPECT_TRUE(client.completedCalled());
EXPECT_EQ(3, m_numBeginUploads);
EXPECT_EQ(3, m_numEndUploads);
EXPECT_EQ(3, m_numTotalUploads);
@@ -616,6 +632,7 @@
TEST_F(CCTextureUpdateControllerTest, NoMoreUpdates)
{
+ FakeCCTextureUpdateControllerClient client;
FakeCCThread thread;
setMaxUploadCountPerUpdate(1);
@@ -623,30 +640,26 @@
appendPartialUploadsToUpdateQueue(0);
DebugScopedSetImplThread implThread;
- OwnPtr<FakeCCTextureUpdateController> controller(FakeCCTextureUpdateController::create(&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_copier, &m_uploader));
controller->setMonotonicTimeNow(0);
controller->setUpdateMoreTexturesTime(0.1);
controller->setUpdateMoreTexturesSize(1);
// Enough time for 3 updates but only 2 necessary.
controller->updateMoreTextures(0.31);
- EXPECT_TRUE(thread.hasPendingTask());
- controller->setMonotonicTimeNow(controller->monotonicTimeNow() + thread.pendingDelayMs() / 1000.0);
- thread.runPendingTask();
- EXPECT_TRUE(thread.hasPendingTask());
- controller->setMonotonicTimeNow(controller->monotonicTimeNow() + thread.pendingDelayMs() / 1000.0);
- thread.runPendingTask();
+ runPendingTasks(&thread, controller.get());
+ EXPECT_TRUE(client.completedCalled());
EXPECT_EQ(2, m_numBeginUploads);
EXPECT_EQ(2, m_numEndUploads);
EXPECT_EQ(2, m_numTotalUploads);
- thread.reset();
controller->setMonotonicTimeNow(0);
controller->setUpdateMoreTexturesTime(0.1);
controller->setUpdateMoreTexturesSize(1);
// Enough time for updates but no more updates left.
controller->updateMoreTextures(0.31);
- EXPECT_FALSE(thread.hasPendingTask());
+ runPendingTasks(&thread, controller.get());
+ EXPECT_TRUE(client.completedCalled());
EXPECT_EQ(2, m_numBeginUploads);
EXPECT_EQ(2, m_numEndUploads);
EXPECT_EQ(2, m_numTotalUploads);
@@ -654,6 +667,7 @@
TEST_F(CCTextureUpdateControllerTest, UpdatesCompleteInFiniteTime)
{
+ FakeCCTextureUpdateControllerClient client;
FakeCCThread thread;
setMaxUploadCountPerUpdate(1);
@@ -661,25 +675,22 @@
appendPartialUploadsToUpdateQueue(0);
DebugScopedSetImplThread implThread;
- OwnPtr<FakeCCTextureUpdateController> controller(FakeCCTextureUpdateController::create(&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_copier, &m_uploader));
controller->setMonotonicTimeNow(0);
controller->setUpdateMoreTexturesTime(0.5);
controller->setUpdateMoreTexturesSize(1);
for (int i = 0; i < 100; i++) {
- if (!controller->hasMoreUpdates())
+ if (client.completedCalled())
break;
// Not enough time for any updates.
controller->updateMoreTextures(0.4);
-
- if (thread.hasPendingTask()) {
- controller->setMonotonicTimeNow(controller->monotonicTimeNow() + thread.pendingDelayMs() / 1000.0);
- thread.runPendingTask();
- }
+ runPendingTasks(&thread, controller.get());
}
+ EXPECT_TRUE(client.completedCalled());
EXPECT_EQ(2, m_numBeginUploads);
EXPECT_EQ(2, m_numEndUploads);
EXPECT_EQ(2, m_numTotalUploads);
