Attachment #161077 for bug #95057

View Details Raw Unified Return to Bug 95057

| Differences between



2012-08-27  Christopher Cameron  <ccameron@chromium.org>

        [chromium] Allow impl-thread deletion of only some resources
        https://bugs.webkit.org/show_bug.cgi?id=95057

        Reviewed by NOBODY (OOPS!).

        Towards allowing the impl thread to delete just some resources (as
        opposed to deleting all resources).

        Do impl-thread deletion through CCPrioritizedTextureManager instead of
        CCResourceProvider. In subsequent changes the impl thread will be able
        to set a threshold for what to delete). Put all state that can
        be concurrently accessed by the main and impl threads into a separate
        SharedState sub-class which has a mutex. Add a set of textures that
        have been deleted by the impl thread, but have not had their related
        structures clear by the main thread yet. Add helper functions to delete
        a backing's resource.

        Allow multiple in-flight texture purges. In CCThreadProxy, make the
        acknowledgement of texture deletion be an integer counter instead of a
        bool, because we may have multiple in-flight purges. Remove many
        instances where texture purges were avoided when there was an
        outstanding text.

        Add the ability to clear only the references to deleted textures from
        the texture upload queue.

        Add assertions that resources be freed to CCPrioritizedTextureManager.

        Add lots of asserts to CCPrioritizedTextureManager to ensure and
        illuminate supported multithreaded access.
        
        Fix a dozen places where CCThreadProxy and CCSingleThreadProxy hold
        the main thread blocked, but don't notify the debug structures of
        this.

        No new tests (OOPS!).

        * platform/graphics/chromium/LayerTextureUpdater.h:
        (WebCore::LayerTextureUpdater::Texture::backingWasAsynchronouslyDeleted):
        * platform/graphics/chromium/cc/CCLayerTreeHost.cpp:
        (WebCore::CCLayerTreeHost::deleteContentsTexturesResourcesOnImplThread):
        (WebCore):
        (WebCore::CCLayerTreeHost::destroyTexturesDeletedByImplThread):
        * platform/graphics/chromium/cc/CCLayerTreeHost.h:
        (CCLayerTreeHost):
        * platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp:
        (WebCore::CCLayerTreeHostImpl::releaseContentsTextures):
        * platform/graphics/chromium/cc/CCLayerTreeHostImpl.h:
        (CCLayerTreeHostImplClient):
        (WebCore::CCLayerTreeHostImpl::setContentsTexturesPurged):
        (CCLayerTreeHostImpl):
        * platform/graphics/chromium/cc/CCPrioritizedTexture.cpp:
        (WebCore::CCPrioritizedTexture::upload):
        (WebCore::CCPrioritizedTexture::backingWasAsynchronouslyDeleted):
        (WebCore):
        * platform/graphics/chromium/cc/CCPrioritizedTexture.h:
        (CCPrioritizedTexture):
        (WebCore::CCPrioritizedTexture::Backing::Backing):
        (WebCore::CCPrioritizedTexture::Backing::~Backing):
        (Backing):
        (WebCore::CCPrioritizedTexture::Backing::owner):
        (WebCore::CCPrioritizedTexture::Backing::resourceDeleted):
        * platform/graphics/chromium/cc/CCPrioritizedTextureManager.cpp:
        (WebCore::CCPrioritizedTextureManager::~CCPrioritizedTextureManager):
        (WebCore::CCPrioritizedTextureManager::prioritizeTextures):
        (WebCore::CCPrioritizedTextureManager::requestLate):
        (WebCore::CCPrioritizedTextureManager::acquireBackingTextureIfNeeded):
        (WebCore::CCPrioritizedTextureManager::reduceMemory):
        (WebCore::CCPrioritizedTextureManager::deleteBackingsResourcesOnImplThread):
        (WebCore::CCPrioritizedTextureManager::destroyBackingsFreedByImplThread):
        (WebCore):
        (WebCore::CCPrioritizedTextureManager::clearAllMemory):
        (WebCore::CCPrioritizedTextureManager::registerTexture):
        (WebCore::CCPrioritizedTextureManager::returnBackingTexture):
        (WebCore::CCPrioritizedTextureManager::createBacking):
        (WebCore::CCPrioritizedTextureManager::destroyBacking):
        (WebCore::CCPrioritizedTextureManager::assertInvariants):
        * platform/graphics/chromium/cc/CCPrioritizedTextureManager.h:
        (CCPrioritizedTextureManager):
        * platform/graphics/chromium/cc/CCScheduler.cpp:
        (WebCore::CCScheduler::beginFrameAborted):
        * platform/graphics/chromium/cc/CCSingleThreadProxy.cpp:
        (WebCore::CCSingleThreadProxy::recreateContext):
        (WebCore::CCSingleThreadProxy::stop):
        (WebCore::CCSingleThreadProxy::deleteContentsTexturesOnImplThread):
        (WebCore):
        (WebCore::CCSingleThreadProxy::commitAndComposite):
        * platform/graphics/chromium/cc/CCSingleThreadProxy.h:
        * platform/graphics/chromium/cc/CCTextureUpdateQueue.cpp:
        (WebCore::CCTextureUpdateQueue::clearUploadsToDeletedResources):
        (WebCore):
        * platform/graphics/chromium/cc/CCTextureUpdateQueue.h:
        (CCTextureUpdateQueue):
        * platform/graphics/chromium/cc/CCThreadProxy.cpp:
        (WebCore::CCThreadProxy::CCThreadProxy):
        (WebCore::CCThreadProxy::deleteContentsTexturesOnImplThread):
        (WebCore):
        (WebCore::CCThreadProxy::scheduledActionBeginFrame):
        (WebCore::CCThreadProxy::beginFrame):
        (WebCore::CCThreadProxy::beginFrameCompleteOnImplThread):
        (WebCore::CCThreadProxy::scheduledActionCommit):
        (WebCore::CCThreadProxy::layerTreeHostClosedOnImplThread):
        (WebCore::CCThreadProxy::recreateContextOnImplThread):
        * platform/graphics/chromium/cc/CCThreadProxy.h:
        (WebCore::CCThreadProxy::BeginFrameAndCommitState::BeginFrameAndCommitState):
        (BeginFrameAndCommitState):
        (CCThreadProxy):

2012-08-24  Robert Kroeger  <rjkroege@chromium.org>

        [chromium] CCLayerTreeHostImpl::scrollBy always assumes screen space deltas



2012-08-27  Christopher Cameron  <ccameron@chromium.org>

        [chromium] Allow impl-thread deletion of only some resources
        https://bugs.webkit.org/show_bug.cgi?id=95057

        Reviewed by NOBODY (OOPS!).

        In CCLayerTreeHostImplTest, remove the test
        releaseContentsTextureShouldTriggerCommit because it is no longer valid
        and is redundant.  A releaseContentsTexture will only trigger a commit
        if the releaseContentsTexture actually deletes any textures, and
        CCLayerTreeHostTestEvictTextures already tests that the commit is
        issued upon eviction.

        Update TiledLayerChromiumTest to adhere to threading requirements and
        not leak resources.

        Update CCPrioritizedTextureTest to adhere to threading requirments.

        * tests/CCLayerTreeHostImplTest.cpp:
        * tests/TiledLayerChromiumTest.cpp:

2012-08-24  Cris Neckar  <cdn@chromium.org>

        Plumb consumeUserGesture() to the chromium platform layer.

Lines 49-54 public: a/Source/WebCore/platform/graphics/chromium/LayerTextureUpdater.h_sec1
- a/Source/WebCore/platform/graphics/chromium/LayerTextureUpdater.h +1 lines
49		49
50	CCPrioritizedTexture* texture() { return m_texture.get(); }	50	CCPrioritizedTexture* texture() { return m_texture.get(); }
51	void swapTextureWith(OwnPtr<CCPrioritizedTexture>& texture) { m_texture.swap(texture); }	51	void swapTextureWith(OwnPtr<CCPrioritizedTexture>& texture) { m_texture.swap(texture); }
		52	bool backingWasAsynchronouslyDeleted() const { return m_texture->backingWasAsynchronouslyDeleted(); }
52	virtual void prepareRect(const IntRect& /* sourceRect */, CCRenderingStats&) { }	53	virtual void prepareRect(const IntRect& /* sourceRect */, CCRenderingStats&) { }
53	virtual void updateRect(CCResourceProvider*, const IntRect& sourceRect, const IntSize& destOffset) = 0;	54	virtual void updateRect(CCResourceProvider*, const IntRect& sourceRect, const IntSize& destOffset) = 0;
54	protected:	55	protected:



    return RecreateFailedAndGaveUp;
}

void CCLayerTreeHost::deleteAllContentsTexturesOnImplThread(CCResourceProvider* resourceProvider)
{
    ASSERT(CCProxy::isImplThread());
    if (m_rendererInitialized)
        m_contentsTextureManager->clearAllMemory(resourceProvider);
}

bool CCLayerTreeHost::reduceContentsTexturesMemoryOnImplThread(CCResourceProvider* resourceProvider)
{
    ASSERT(CCProxy::isImplThread());
        return m_contentsTextureManager->reduceMemoryOnImplThreadAsync(resourceProvider);
    return false;
}

void CCLayerTreeHost::acquireLayerTextures()
{
    ASSERT(CCProxy::isMainThread());

    m_proxy->setVisible(visible);
}


void CCLayerTreeHost::destroyContentsTexturesEvictedByImplThread()
{
    ASSERT(CCProxy::isMainThread());
    ASSERT(m_contentsTextureManager.get());
    m_contentsTextureManager->destroyBackingsAsynchronouslyEvicted();
}

void CCLayerTreeHost::startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, double durationSec)



    RecreateResult recreateContext();
    void didCommitAndDrawFrame() { m_client->didCommitAndDrawFrame(); }
    void didCompleteSwapBuffers() { m_client->didCompleteSwapBuffers(); }
    void deleteContentsTexturesOnImplThread(CCResourceProvider*);
    virtual void acquireLayerTextures();
    // Returns false if we should abort this frame due to initialization failure.
    bool initializeRendererIfNeeded();


    CCPrioritizedTextureManager* contentsTextureManager() const;

    void deleteAllContentsTexturesOnImplThread(CCResourceProvider*);

    // This will cause contents texture manager to free some resources used
    // by textures, but will not delete the texture backings objects. The
    // function returns true if some resources were indeed destroyed.
    bool reduceContentsTexturesMemoryOnImplThread(CCResourceProvider*);

    // This will destroy the backings that had their GPU resources freed
    // by deleteContentsTexturesResourcesOnImplThread.
    void destroyContentsTexturesEvictedByImplThread();

    bool visible() const { return m_visible; }
    void setVisible(bool);




void CCLayerTreeHostImpl::releaseContentsTextures()
{
    m_client->reduceContentsTexturesMemoryOnImplThread();
        return;
    m_resourceProvider->deleteOwnedResources(CCRenderer::ContentPool);
    m_contentsTexturesPurged = true;
    m_client->setNeedsCommitOnImplThread();
}

void CCLayerTreeHostImpl::setMemoryAllocationLimitBytes(size_t bytes)

Lines 59-64 public: a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.h_sec1
- a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.h -1 / +6 lines
59	virtual void setNeedsRedrawOnImplThread() = 0;	59	virtual void setNeedsRedrawOnImplThread() = 0;
60	virtual void setNeedsCommitOnImplThread() = 0;	60	virtual void setNeedsCommitOnImplThread() = 0;
61	virtual void postAnimationEventsToMainThreadOnImplThread(PassOwnPtr<CCAnimationEventsVector>, double wallClockTime) = 0;	61	virtual void postAnimationEventsToMainThreadOnImplThread(PassOwnPtr<CCAnimationEventsVector>, double wallClockTime) = 0;
		62	virtual void reduceContentsTexturesMemoryOnImplThread() = 0;
62	};	63	};
63		64
64	// CCLayerTreeHostImpl owns the CCLayerImpl tree as well as associated rendering state	65	// CCLayerTreeHostImpl owns the CCLayerImpl tree as well as associated rendering state
Lines 155-161 public: a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.h_sec2
155	int sourceFrameNumber() const { return m_sourceFrameNumber; }	156	int sourceFrameNumber() const { return m_sourceFrameNumber; }
156	void setSourceFrameNumber(int frameNumber) { m_sourceFrameNumber = frameNumber; }	157	void setSourceFrameNumber(int frameNumber) { m_sourceFrameNumber = frameNumber; }
157		158
158	bool contentsTexturesPurged() const { return m_contentsTexturesPurged; }	159	void setContentsTexturesPurged() { m_contentsTexturesPurged = true; }
159	void resetContentsTexturesPurged() { m_contentsTexturesPurged = false; }	160	void resetContentsTexturesPurged() { m_contentsTexturesPurged = false; }
160	size_t memoryAllocationLimitBytes() const { return m_memoryAllocationLimitBytes; }	161	size_t memoryAllocationLimitBytes() const { return m_memoryAllocationLimitBytes; }
161		162
Lines 278-283 private: a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.h_sec3
278	IntSize m_deviceViewportSize;	279	IntSize m_deviceViewportSize;
279	float m_deviceScaleFactor;	280	float m_deviceScaleFactor;
280	bool m_visible;	281	bool m_visible;
		282
		283	// Set when the impl thread deletes textures, un-set when the impl's layer tree
		284	// is known to not reference any deleted resources. Used to prevent drawing
		285	// with deleted resources.
281	bool m_contentsTexturesPurged;	286	bool m_contentsTexturesPurged;
282	size_t m_memoryAllocationLimitBytes;	287	size_t m_memoryAllocationLimitBytes;
283		288

Lines 28-33 a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTexture.cpp_sec1
- a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTexture.cpp +30 lines
28		28
29	#include "CCPrioritizedTextureManager.h"	29	#include "CCPrioritizedTextureManager.h"
30	#include "CCPriorityCalculator.h"	30	#include "CCPriorityCalculator.h"
		31	#include "CCProxy.h"
31	#include <algorithm>	32	#include <algorithm>
32		33
33	using namespace std;	34	using namespace std;
Lines 106-111 void CCPrioritizedTexture::upload(CCResourceProvider* resourceProvider, a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTexture.cpp_sec2
106	const uint8_t* image, const IntRect& imageRect,	107	const uint8_t* image, const IntRect& imageRect,
107	const IntRect& sourceRect, const IntSize& destOffset)	108	const IntRect& sourceRect, const IntSize& destOffset)
108	{	109	{
		110	ASSERT(!backingWasAsynchronouslyDeleted());
109	ASSERT(m_isAbovePriorityCutoff);	111	ASSERT(m_isAbovePriorityCutoff);
110	if (m_isAbovePriorityCutoff)	112	if (m_isAbovePriorityCutoff)
111	acquireBackingTexture(resourceProvider);	113	acquireBackingTexture(resourceProvider);
Lines 113-118 void CCPrioritizedTexture::upload(CCResourceProvider* resourceProvider, a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTexture.cpp_sec3
113	resourceProvider->upload(resourceId(), image, imageRect, sourceRect, destOffset);	115	resourceProvider->upload(resourceId(), image, imageRect, sourceRect, destOffset);
114	}	116	}
115		117
		118	bool CCPrioritizedTexture::backingWasAsynchronouslyDeleted() const
		119	{
		120	if (m_backing)
		121	return m_backing->resourceDeleted();
		122	return false;
		123	}
		124
116	void CCPrioritizedTexture::link(Backing* backing)	125	void CCPrioritizedTexture::link(Backing* backing)
117	{	126	{
118	ASSERT(backing);	127	ASSERT(backing);
Lines 139-142 void CCPrioritizedTexture::setToSelfManagedMemoryPlaceholder(size_t bytes) a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTexture.cpp_sec4
139	m_bytes = bytes;	148	m_bytes = bytes;
140	}	149	}
141		150
		151	CCResourceProvider::ResourceId CCPrioritizedTexture::Backing::id()
		152	{
		153	ASSERT(CCProxy::isImplThread());
		154	return m_texture.id();
		155	}
		156
		157	bool CCPrioritizedTexture::Backing::resourceDeleted() const
		158	{
		159	ASSERT(CCProxy::isImplThread());
		160	return m_resourceDeleted;
		161	}
		162
		163	void CCPrioritizedTexture::Backing::deleteResource(CCResourceProvider* resourceProvider)
		164	{
		165	ASSERT(CCProxy::isImplThread());
		166	ASSERT(resourceProvider);
		167	ASSERT(!m_resourceDeleted);
		168	resourceProvider->deleteResource(m_texture.id());
		169	m_resourceDeleted = true;
		170	}
		171
142	} // namespace WebCore	172	} // namespace WebCore

Lines 88-93 public: a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTexture.h_sec1
- a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTexture.h -4 / +17 lines
88	// Uploads pixels into the backing resource. This functions will aquire the backing if needed.	88	// Uploads pixels into the backing resource. This functions will aquire the backing if needed.
89	void upload(CCResourceProvider, const uint8_t image, const IntRect& imageRect, const IntRect& sourceRect, const IntSize& destOffset);	89	void upload(CCResourceProvider, const uint8_t image, const IntRect& imageRect, const IntRect& sourceRect, const IntSize& destOffset);
90		90
		91	bool backingWasAsynchronouslyDeleted() const;
		92
91	CCResourceProvider::ResourceId resourceId() const;	93	CCResourceProvider::ResourceId resourceId() const;
92		94
93	// Self-managed textures are accounted for when prioritizing other textures,	95	// Self-managed textures are accounted for when prioritizing other textures,
Lines 101-116 public: a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTexture.h_sec2
101	private:	103	private:
102	friend class CCPrioritizedTextureManager;	104	friend class CCPrioritizedTextureManager;
103		105
104	class Backing : public CCTexture {	106	class Backing {
105	WTF_MAKE_NONCOPYABLE(Backing);	107	WTF_MAKE_NONCOPYABLE(Backing);
106	public:	108	public:
107	Backing(unsigned id, IntSize size, GC3Denum format)	109	Backing(unsigned id, IntSize size, GC3Denum format)
108	: CCTexture(id, size, format), m_owner(0) { }	110	: m_texture(id, size, format), m_resourceDeleted(false), m_owner(0) { }
109	~Backing() { ASSERT(!m_owner); }	111	~Backing() { ASSERT(!m_owner && m_resourceDeleted); }
		112
		113	CCPrioritizedTexture* owner() const { return m_owner; }
		114
		115	CCResourceProvider::ResourceId id();
		116	void deleteResource(CCResourceProvider*);
		117	bool resourceDeleted() const;
		118	const IntSize& size() const { return m_texture.size(); }
		119	GC3Denum format() const { return m_texture.format(); }
		120	size_t bytes() const { return m_texture.bytes(); }
110		121
111	CCPrioritizedTexture* owner() { return m_owner; }
112	private:	122	private:
113	friend class CCPrioritizedTexture;	123	friend class CCPrioritizedTexture;
		124	friend class CCPrioritizedTextureManager;
		125	CCTexture m_texture;
		126	bool m_resourceDeleted;
114	CCPrioritizedTexture* m_owner;	127	CCPrioritizedTexture* m_owner;
115	};	128	};
116		129




#include "CCPrioritizedTexture.h"
#include "CCPriorityCalculator.h"
#include "CCProxy.h"
#include "TraceEvent.h"
#include <algorithm>


    while (m_textures.size() > 0)
        unregisterTexture(*m_textures.begin());

    // Remove any backings that were evicted.
    clearEvictedBackings();

    // Each remaining backing is real memory leak. This shouldn't happen.
    ASSERT(m_backings.isEmpty());
}

void CCPrioritizedTextureManager::prioritizeTextures()
{
    TRACE_EVENT0("cc", "CCPrioritizedTextureManager::prioritizeTextures");
    ASSERT(CCProxy::isMainThread());

#if !ASSERT_DISABLED
    assertInvariants();


void CCPrioritizedTextureManager::clearPriorities()
{
    ASSERT(CCProxy::isMainThread());
    for (TextureSet::iterator it = m_textures.begin(); it != m_textures.end(); ++it) {
        // FIXME: We should remove this and just set all priorities to
        //        CCPriorityCalculator::lowestPriority() once we have priorities


bool CCPrioritizedTextureManager::requestLate(CCPrioritizedTexture* texture)
{
    ASSERT(CCProxy::isMainThread());

    // This is already above cutoff, so don't double count it's memory below.
    if (texture->isAbovePriorityCutoff())
        return true;


void CCPrioritizedTextureManager::acquireBackingTextureIfNeeded(CCPrioritizedTexture* texture, CCResourceProvider* resourceProvider)
{
    ASSERT(CCProxy::isImplThread() && CCProxy::isMainThreadBlocked());
    ASSERT(resourceProvider);
    ASSERT(!texture->isSelfManaged());
    ASSERT(texture->isAbovePriorityCutoff());
    if (texture->backing() || !texture->isAbovePriorityCutoff())


void CCPrioritizedTextureManager::reduceMemory(size_t limitBytes, CCResourceProvider* resourceProvider)
{
    ASSERT(CCProxy::isImplThread() && CCProxy::isMainThreadBlocked());
    ASSERT(resourceProvider);
    if (memoryUseBytes() <= limitBytes)
        return;
    // Destroy backings until we are below the limit,
    // or until all backings remaining are above the cutoff.
    while (memoryUseBytes() > limitBytes && m_backings.size() > 0) {
        CCPrioritizedTexture::Backing* backing = *m_backings.begin();
        if (backing->owner() && backing->owner()->isAbovePriorityCutoff())
            break;
        m_sharedState.removeBackingOnImplThread(backing);
        if (!backing->resourceDeleted())
            backing->deleteResource(resourceProvider);
        destroyBacking(backing);
    }
}

void CCPrioritizedTextureManager::reduceMemory(CCResourceProvider* resourceProvider)
{
    ASSERT(CCProxy::isImplThread() && CCProxy::isMainThreadBlocked());
    reduceMemory(m_memoryAvailableBytes, resourceProvider);
    ASSERT(memoryUseBytes() <= maxMemoryLimitBytes());


    reduceMemory(memoryUseBytes() - (wastedMemory - tenPercentOfMemory), resourceProvider);
}

bool CCPrioritizedTextureManager::reduceMemoryOnImplThreadAsync(CCResourceProvider* resourceProvider)
{
    ASSERT(CCProxy::isImplThread());
    ASSERT(resourceProvider);
    return m_sharedState.evictBackingsResourcesOnImplThreadAsync(resourceProvider);
        if ((*it)->owner())
            (*it)->owner()->unlink();
        destroyBacking((*it), resourceProvider);
    }
}

void CCPrioritizedTextureManager::destroyBackingsAsynchronouslyEvicted()
{
    ASSERT(CCProxy::isMainThread());
    clearEvictedBackings();
}

void CCPrioritizedTextureManager::clearEvictedBackings()
{
    BackingSet evictedBackings;
    m_sharedState.getAndClearEvictedBackings(evictedBackings);
    for (BackingSet::iterator it = evictedBackings.begin(); it != evictedBackings.end(); ++it)
        destroyBacking((*it));
}

void CCPrioritizedTextureManager::clearAllMemory(CCResourceProvider* resourceProvider)
{
    ASSERT(CCProxy::isImplThread() && CCProxy::isMainThreadBlocked());
    ASSERT(resourceProvider);
    reduceMemoryOnImplThreadAsync(resourceProvider);
    clearEvictedBackings();
}

void CCPrioritizedTextureManager::registerTexture(CCPrioritizedTexture* texture)
{
    ASSERT(CCProxy::isMainThread());
    ASSERT(texture);
    ASSERT(!texture->textureManager());
    ASSERT(!texture->backing());


    texture->setManagerInternal(this);
    m_textures.add(texture);

}

void CCPrioritizedTextureManager::unregisterTexture(CCPrioritizedTexture* texture)
{
    ASSERT(CCProxy::isMainThread() || (CCProxy::isImplThread() && CCProxy::isMainThreadBlocked()));
    ASSERT(texture);
    ASSERT(m_textures.find(texture) != m_textures.end());


    texture->setAbovePriorityCutoff(false);
}


void CCPrioritizedTextureManager::returnBackingTexture(CCPrioritizedTexture* texture)
{
    ASSERT(CCProxy::isMainThread() || (CCProxy::isImplThread() && CCProxy::isMainThreadBlocked()));
    if (texture->backing()) {
        // Move the backing texture to the front for eviction/recycling and unlink it.
        m_backings.remove(texture->backing());


CCPrioritizedTexture::Backing* CCPrioritizedTextureManager::createBacking(IntSize size, GC3Denum format, CCResourceProvider* resourceProvider)
{
    ASSERT(CCProxy::isImplThread() && CCProxy::isMainThreadBlocked());
    ASSERT(resourceProvider);

    CCResourceProvider::ResourceId resourceId = resourceProvider->createResource(m_pool, size, format, CCResourceProvider::TextureUsageAny);
    CCPrioritizedTexture::Backing* backing = new CCPrioritizedTexture::Backing(resourceId, size, format);
    m_memoryUseBytes += backing->bytes();
    // Put backing texture at the front for eviction, since it isn't in use yet.
    m_backings.insertBefore(m_backings.begin(), backing);
    m_sharedState.addBackingOnImplThread(backing);
    return backing;
}

void CCPrioritizedTextureManager::destroyBacking(CCPrioritizedTexture::Backing* backing)
{
    ASSERT(backing);
    ASSERT(!backing->owner() || !backing->owner()->isAbovePriorityCutoff());
    ASSERT(!backing->owner() || !backing->owner()->isSelfManaged());
    ASSERT(m_backings.find(backing) != m_backings.end());

    if (resourceProvider)
        resourceProvider->deleteResource(backing->id());
    if (backing->owner())
        backing->owner()->unlink();
    m_memoryUseBytes -= backing->bytes();

    delete backing;
}


#if !ASSERT_DISABLED
void CCPrioritizedTextureManager::assertInvariants()
{
    ASSERT(CCProxy::isMainThread());

    // If we hit any of these asserts, there is a bug in this class. To see
    // where the bug is, call this function at the beginning and end of
    // every public function.

}
#endif

CCPrioritizedTextureManager::SharedState::~SharedState()
{
    ASSERT(m_evictedBackings.isEmpty());
    ASSERT(m_unevictedBackings.isEmpty());
}

void CCPrioritizedTextureManager::SharedState::addBackingOnImplThread(CCPrioritizedTexture::Backing* backing)
{
    ASSERT(CCProxy::isImplThread() && CCProxy::isMainThreadBlocked());
    m_unevictedBackings.add(backing);
}

void CCPrioritizedTextureManager::SharedState::removeBackingOnImplThread(CCPrioritizedTexture::Backing* backing)
{
    ASSERT(CCProxy::isImplThread() && CCProxy::isMainThreadBlocked());
    if (backing->resourceDeleted()) {
        ASSERT(m_evictedBackings.find(backing) != m_evictedBackings.end());
        m_evictedBackings.remove(backing);
    } else {
        ASSERT(m_unevictedBackings.find(backing) != m_unevictedBackings.end());
        m_unevictedBackings.remove(backing);
    }
}

bool CCPrioritizedTextureManager::SharedState::evictBackingsResourcesOnImplThreadAsync(CCResourceProvider* resourceProvider)
{
    bool result = false;
    ASSERT(CCProxy::isImplThread());
    MutexLocker lock(m_mutex);
    for (BackingSet::iterator it = m_unevictedBackings.begin(); it != m_unevictedBackings.end(); ++it) {
        result = true;
        (*it)->deleteResource(resourceProvider);
        m_evictedBackings.add((*it));
    }
    m_unevictedBackings.clear();
    return result;
}

void CCPrioritizedTextureManager::SharedState::getAndClearEvictedBackings(BackingSet& evictedBackings)
{
    evictedBackings.clear();
    MutexLocker lock(m_mutex);
    evictedBackings.swap(m_evictedBackings);
}

} // namespace WebCore



#include "IntSize.h"
#include <wtf/HashSet.h>
#include <wtf/ListHashSet.h>
#include <wtf/ThreadingPrimitives.h>
#include <wtf/Vector.h>

namespace WebCore {

    bool requestLate(CCPrioritizedTexture*);

    void reduceMemory(CCResourceProvider*);

    // Returns true if resources are deleted as a result of this call.
    // This can be called concurrently with the main thread accessing this
    // structure, and only touches data in the quarantined m_sharedState.
    bool reduceMemoryOnImplThreadAsync(CCResourceProvider*);

    // Remove the backings whose resources were destroyed by 
    // reduceMemoryOnImplThreadAsync
    void destroyBackingsAsynchronouslyEvicted();

    // Delete all textures and frm the impl thread (at thread exit and
    // context lost).
    void clearAllMemory(CCResourceProvider*);
    void allBackingTexturesWereDeleted();

    void acquireBackingTextureIfNeeded(CCPrioritizedTexture*, CCResourceProvider*);


#endif

private:

    // Compare textures. Highest priority first.
    static inline bool compareTextures(CCPrioritizedTexture* a, CCPrioritizedTexture* b)
    {

    }

    CCPrioritizedTextureManager(size_t maxMemoryLimitBytes, int maxTextureSize, int pool);

    void reduceMemory(size_t limit, CCResourceProvider*);

    CCPrioritizedTexture::Backing* createBacking(IntSize, GC3Denum format, CCResourceProvider*);
    void clearEvictedBackings();
    void destroyBacking(CCPrioritizedTexture::Backing*);

    size_t m_maxMemoryLimitBytes;
    unsigned m_priorityCutoff;


    TextureVector m_tempTextureVector;
    BackingVector m_tempBackingVector;

    // This state that can be concurrently accessed by the main and impl thread,
    // and needs protection by a mutex.
    class SharedState {
    public:
        SharedState() { }
        ~SharedState();

        // Called on the impl thread while the main thread is blocked
        void addBackingOnImplThread(CCPrioritizedTexture::Backing*);
        void removeBackingOnImplThread(CCPrioritizedTexture::Backing*);

        // Called on the impl thread while the main thread may not be
        // blocked
        bool evictBackingsResourcesOnImplThreadAsync(CCResourceProvider*);

        // Called on the main thread, possibly concurrently with 
        // evictBackingsResourcesOnImplThreadAsync.
        // Also called on the impl thread during thread-shutdown and 
        // context-lost
        void getAndClearEvictedBackings(BackingSet&);

    private:
        Mutex m_mutex;
        BackingSet m_unevictedBackings;
        BackingSet m_evictedBackings;
    };
    SharedState m_sharedState;
};

} // WebCore

Lines 99-104 void CCScheduler::beginFrameAborted() a/Source/WebCore/platform/graphics/chromium/cc/CCScheduler.cpp_sec1
- a/Source/WebCore/platform/graphics/chromium/cc/CCScheduler.cpp +1 lines
99	TRACE_EVENT0("cc", "CCScheduler::beginFrameAborted");	99	TRACE_EVENT0("cc", "CCScheduler::beginFrameAborted");
100	m_stateMachine.beginFrameAborted();	100	m_stateMachine.beginFrameAborted();
101	processScheduledActions();	101	processScheduledActions();
		102	setNeedsCommit();
102	}	103	}
103		104
104	void CCScheduler::setMaxFramesPending(int maxFramesPending)	105	void CCScheduler::setMaxFramesPending(int maxFramesPending)




    bool initialized;
    {
        DebugScopedSetMainThreadBlocked mainThreadBlocked;
        DebugScopedSetImplThread impl;
        m_layerTreeHost->deleteAllContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
            m_layerTreeHost->deleteContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
        initialized = m_layerTreeHostImpl->initializeRenderer(context.release(), UnthrottledUploader);
        if (initialized) {
            m_RendererCapabilitiesForMainThread = m_layerTreeHostImpl->rendererCapabilities();

    {
        DebugScopedSetMainThreadBlocked mainThreadBlocked;
        DebugScopedSetImplThread impl;
        m_layerTreeHost->deleteAllContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
        if (!m_layerTreeHostImpl->contentsTexturesPurged())
            m_layerTreeHost->deleteContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
        m_layerTreeHostImpl.clear();
    }
    m_layerTreeHost = 0;

    m_layerTreeHost->setAnimationEvents(events, wallClockTime);
}

void CCSingleThreadProxy::reduceContentsTexturesMemoryOnImplThread()
{
    ASSERT(CCProxy::isImplThread());
    if (m_layerTreeHost->reduceContentsTexturesMemoryOnImplThread(m_layerTreeHostImpl->resourceProvider())) {
        m_layerTreeHostImpl->setContentsTexturesPurged();
        setNeedsCommitOnImplThread();
    }
}

// Called by the legacy scheduling path (e.g. where render_widget does the scheduling)
void CCSingleThreadProxy::compositeImmediately()
{

    if (!m_layerTreeHost->initializeRendererIfNeeded())
        return false;

    m_layerTreeHost->destroyContentsTexturesEvictedByImplThread();
        m_layerTreeHost->evictAllContentTextures();

    CCTextureUpdateQueue queue;
    m_layerTreeHost->updateLayers(queue, m_layerTreeHostImpl->memoryAllocationLimitBytes());



    virtual void setNeedsRedrawOnImplThread() OVERRIDE { m_layerTreeHost->scheduleComposite(); }
    virtual void setNeedsCommitOnImplThread() OVERRIDE { m_layerTreeHost->scheduleComposite(); }
    virtual void postAnimationEventsToMainThreadOnImplThread(PassOwnPtr<CCAnimationEventsVector>, double wallClockTime) OVERRIDE;
    virtual void reduceContentsTexturesMemoryOnImplThread() OVERRIDE;

    // Called by the legacy path where RenderWidget does the scheduling.
    void compositeImmediately();

};

// For use in the single-threaded case. In debug builds, it pretends that the
// code is running on the impl thread to satisfy assertion checks.
class DebugScopedSetImplThread {
public:
    DebugScopedSetImplThread()

    }
};

// For use in the single-threaded case. In debug builds, it pretends that the
// code is running on the impl thread and that the main thread is blocked to
// satisfy assertion checks
class DebugScopedSetImplThreadAndMainThreadBlocked {
private:
    DebugScopedSetImplThread m_implThread;
    DebugScopedSetMainThreadBlocked m_mainThreadBlocked;
};

} // namespace WebCore

#endif



    m_copyEntries.append(copy);
}

void CCTextureUpdateQueue::clearUploadsToDeletedResources()
{
    clearUploadsToDeletedResources(m_fullEntries);
    clearUploadsToDeletedResources(m_partialEntries);
}

void CCTextureUpdateQueue::clearUploadsToDeletedResources(Deque<TextureUploader::Parameters>& entryQueue)
{
    Deque<TextureUploader::Parameters> temp;
    entryQueue.swap(temp);
    while (temp.size()) {
        TextureUploader::Parameters upload = temp.takeFirst();
        if (!upload.texture->backingWasAsynchronouslyDeleted())
            entryQueue.append(upload);
    }
}

TextureUploader::Parameters CCTextureUpdateQueue::takeFirstFullUpload()



    void appendPartialUpload(TextureUploader::Parameters);
    void appendCopy(TextureCopier::Parameters);

    void clearUploadsToDeletedResources();

    TextureUploader::Parameters takeFirstFullUpload();
    TextureUploader::Parameters takeFirstPartialUpload();

    bool hasMoreUpdates() const;

private:
    void clearUploadsToDeletedResources(Deque<TextureUploader::Parameters>& entryQueue);
    Deque<TextureUploader::Parameters> m_fullEntries;
    Deque<TextureUploader::Parameters> m_partialEntries;
    Deque<TextureCopier::Parameters> m_copyEntries;

Lines 80-86 CCThreadProxy::CCThreadProxy(CCLayerTreeHost* layerTreeHost) a/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp_sec1
- a/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp -44 / +73 lines
80	, m_readbackRequestOnImplThread(0)	80	, m_readbackRequestOnImplThread(0)
81	, m_commitCompletionEventOnImplThread(0)	81	, m_commitCompletionEventOnImplThread(0)
82	, m_textureAcquisitionCompletionEventOnImplThread(0)	82	, m_textureAcquisitionCompletionEventOnImplThread(0)
83	, m_resetContentsTexturesPurgedAfterCommitOnImplThread(false)	83	, m_contentsTexturesPurgeCount(0)
		84	, m_contentsTexturesPurgeAck(0)
84	, m_nextFrameIsNewlyCommittedFrameOnImplThread(false)	85	, m_nextFrameIsNewlyCommittedFrameOnImplThread(false)
85	, m_renderVSyncEnabled(layerTreeHost->settings().renderVSyncEnabled)	86	, m_renderVSyncEnabled(layerTreeHost->settings().renderVSyncEnabled)
86	{	87	{
Lines 108-116 bool CCThreadProxy::compositeAndReadback(void *pixels, const IntRect& rect) a/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp_sec2
108		109
109		110
110	// Perform a synchronous commit.	111	// Perform a synchronous commit.
111	CCCompletionEvent beginFrameCompletion;	112	{
112	CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::forceBeginFrameOnImplThread, &beginFrameCompletion));	113	DebugScopedSetMainThreadBlocked mainThreadBlocked;
113	beginFrameCompletion.wait();	114	CCCompletionEvent beginFrameCompletion;
		115	CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::forceBeginFrameOnImplThread, &beginFrameCompletion));
		116	beginFrameCompletion.wait();
		117	}
114	m_inCompositeAndReadback = true;	118	m_inCompositeAndReadback = true;
115	beginFrame();	119	beginFrame();
116	m_inCompositeAndReadback = false;	120	m_inCompositeAndReadback = false;
Lines 119-126 bool CCThreadProxy::compositeAndReadback(void *pixels, const IntRect& rect) a/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp_sec3
119	ReadbackRequest request;	123	ReadbackRequest request;
120	request.rect = rect;	124	request.rect = rect;
121	request.pixels = pixels;	125	request.pixels = pixels;
122	CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::requestReadbackOnImplThread, &request));	126	{
123	request.completion.wait();	127	DebugScopedSetMainThreadBlocked mainThreadBlocked;
		128	CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::requestReadbackOnImplThread, &request));
		129	request.completion.wait();
		130	}
124	return request.success;	131	return request.success;
125	}	132	}
126		133
Lines 157-162 void CCThreadProxy::finishAllRendering() a/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp_sec4
157	ASSERT(CCProxy::isMainThread());	164	ASSERT(CCProxy::isMainThread());
158		165
159	// Make sure all GL drawing is finished on the impl thread.	166	// Make sure all GL drawing is finished on the impl thread.
		167	DebugScopedSetMainThreadBlocked mainThreadBlocked;
160	CCCompletionEvent completion;	168	CCCompletionEvent completion;
161	CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::finishAllRenderingOnImplThread, &completion));	169	CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::finishAllRenderingOnImplThread, &completion));
162	completion.wait();	170	completion.wait();
Lines 195-200 void CCThreadProxy::setSurfaceReadyOnImplThread() a/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp_sec5
195	void CCThreadProxy::setVisible(bool visible)	203	void CCThreadProxy::setVisible(bool visible)
196	{	204	{
197	TRACE_EVENT0("cc", "CCThreadProxy::setVisible");	205	TRACE_EVENT0("cc", "CCThreadProxy::setVisible");
		206	DebugScopedSetMainThreadBlocked mainThreadBlocked;
198	CCCompletionEvent completion;	207	CCCompletionEvent completion;
199	CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::setVisibleOnImplThread, &completion, visible));	208	CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::setVisibleOnImplThread, &completion, visible));
200	completion.wait();	209	completion.wait();
Lines 213-226 bool CCThreadProxy::initializeRenderer() a/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp_sec6
213	TRACE_EVENT0("cc", "CCThreadProxy::initializeRenderer");	222	TRACE_EVENT0("cc", "CCThreadProxy::initializeRenderer");
214	// Make a blocking call to initializeRendererOnImplThread. The results of that call	223	// Make a blocking call to initializeRendererOnImplThread. The results of that call
215	// are pushed into the initializeSucceeded and capabilities local variables.	224	// are pushed into the initializeSucceeded and capabilities local variables.
216	CCCompletionEvent completion;
217	bool initializeSucceeded = false;	225	bool initializeSucceeded = false;
218	RendererCapabilities capabilities;	226	RendererCapabilities capabilities;
219	CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::initializeRendererOnImplThread,	227	{
220	&completion,	228	DebugScopedSetMainThreadBlocked mainThreadBlocked;
221	&initializeSucceeded,	229	CCCompletionEvent completion;
222	&capabilities));	230	CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::initializeRendererOnImplThread,
223	completion.wait();	231	&completion,
		232	&initializeSucceeded,
		233	&capabilities));
		234	completion.wait();
		235	}
224		236
225	if (initializeSucceeded) {	237	if (initializeSucceeded) {
226	m_rendererInitialized = true;	238	m_rendererInitialized = true;
Lines 245-259 bool CCThreadProxy::recreateContext() a/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp_sec7
245	// Make a blocking call to recreateContextOnImplThread. The results of that	257	// Make a blocking call to recreateContextOnImplThread. The results of that
246	// call are pushed into the recreateSucceeded and capabilities local	258	// call are pushed into the recreateSucceeded and capabilities local
247	// variables.	259	// variables.
248	CCCompletionEvent completion;
249	bool recreateSucceeded = false;	260	bool recreateSucceeded = false;
250	RendererCapabilities capabilities;	261	RendererCapabilities capabilities;
251	CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::recreateContextOnImplThread,	262	{
252	&completion,	263	DebugScopedSetMainThreadBlocked mainThreadBlocked;
253	context.leakPtr(),	264	CCCompletionEvent completion;
254	&recreateSucceeded,	265	CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::recreateContextOnImplThread,
255	&capabilities));	266	&completion,
256	completion.wait();	267	context.leakPtr(),
		268	&recreateSucceeded,
		269	&capabilities));
		270	completion.wait();
		271	}
257		272
258	if (recreateSucceeded)	273	if (recreateSucceeded)
259	m_RendererCapabilitiesMainThreadCopy = capabilities;	274	m_RendererCapabilitiesMainThreadCopy = capabilities;
Lines 270-275 void CCThreadProxy::implSideRenderingStats(CCRenderingStats& stats) a/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp_sec8
270	{	285	{
271	ASSERT(isMainThread());	286	ASSERT(isMainThread());
272		287
		288	DebugScopedSetMainThreadBlocked mainThreadBlocked;
273	CCCompletionEvent completion;	289	CCCompletionEvent completion;
274	CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::implSideRenderingStatsOnImplThread,	290	CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::implSideRenderingStatsOnImplThread,
275	&completion,	291	&completion,
Lines 332-337 void CCThreadProxy::onVSyncParametersChanged(double monotonicTimebase, double in a/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp_sec9
332	m_schedulerOnImplThread->setTimebaseAndInterval(monotonicTimebase, intervalInSeconds);	348	m_schedulerOnImplThread->setTimebaseAndInterval(monotonicTimebase, intervalInSeconds);
333	}	349	}
334		350
		351	void CCThreadProxy::reduceContentsTexturesMemoryOnImplThread()
		352	{
		353	ASSERT(isImplThread());
		354	TRACE_EVENT0("cc", "CCThreadProxy::reduceContentsTexturesMemoryOnImplThread");
		355
		356	if (m_layerTreeHost->reduceContentsTexturesMemoryOnImplThread(m_layerTreeHostImpl->resourceProvider())) {
		357	m_contentsTexturesPurgeCount += 1;
		358	m_layerTreeHostImpl->setContentsTexturesPurged();
		359	setNeedsCommitOnImplThread();
		360	}
		361	}
		362
335	void CCThreadProxy::setNeedsCommitOnImplThread()	363	void CCThreadProxy::setNeedsCommitOnImplThread()
336	{	364	{
337	ASSERT(isImplThread());	365	ASSERT(isImplThread());
Lines 380-385 void CCThreadProxy::start() a/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp_sec10
380	ASSERT(isMainThread());	408	ASSERT(isMainThread());
381	ASSERT(CCProxy::implThread());	409	ASSERT(CCProxy::implThread());
382	// Create LayerTreeHostImpl.	410	// Create LayerTreeHostImpl.
		411	DebugScopedSetMainThreadBlocked mainThreadBlocked;
383	CCCompletionEvent completion;	412	CCCompletionEvent completion;
384	CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::initializeImplOnImplThread, &completion));	413	CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::initializeImplOnImplThread, &completion));
385	completion.wait();	414	completion.wait();
Lines 396-402 void CCThreadProxy::stop() a/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp_sec11
396	// Synchronously deletes the impl.	425	// Synchronously deletes the impl.
397	{	426	{
398	DebugScopedSetMainThreadBlocked mainThreadBlocked;	427	DebugScopedSetMainThreadBlocked mainThreadBlocked;
399
400	CCCompletionEvent completion;	428	CCCompletionEvent completion;
401	CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::layerTreeHostClosedOnImplThread, &completion));	429	CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::layerTreeHostClosedOnImplThread, &completion));
402	completion.wait();	430	completion.wait();
Lines 411-416 void CCThreadProxy::stop() a/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp_sec12
411		439
412	void CCThreadProxy::forceSerializeOnSwapBuffers()	440	void CCThreadProxy::forceSerializeOnSwapBuffers()
413	{	441	{
		442	DebugScopedSetMainThreadBlocked mainThreadBlocked;
414	CCCompletionEvent completion;	443	CCCompletionEvent completion;
415	CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::forceSerializeOnSwapBuffersOnImplThread, &completion));	444	CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::forceSerializeOnSwapBuffersOnImplThread, &completion));
416	completion.wait();	445	completion.wait();
Lines 453-459 void CCThreadProxy::scheduledActionBeginFrame() a/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp_sec13
453	m_pendingBeginFrameRequest = adoptPtr(new BeginFrameAndCommitState());	482	m_pendingBeginFrameRequest = adoptPtr(new BeginFrameAndCommitState());
454	m_pendingBeginFrameRequest->monotonicFrameBeginTime = monotonicallyIncreasingTime();	483	m_pendingBeginFrameRequest->monotonicFrameBeginTime = monotonicallyIncreasingTime();
455	m_pendingBeginFrameRequest->scrollInfo = m_layerTreeHostImpl->processScrollDeltas();	484	m_pendingBeginFrameRequest->scrollInfo = m_layerTreeHostImpl->processScrollDeltas();
456	m_pendingBeginFrameRequest->contentsTexturesWereDeleted = m_layerTreeHostImpl->contentsTexturesPurged();	485	m_pendingBeginFrameRequest->contentsTexturesPurgeAck = m_contentsTexturesPurgeCount;
457	m_pendingBeginFrameRequest->memoryAllocationLimitBytes = m_layerTreeHostImpl->memoryAllocationLimitBytes();	486	m_pendingBeginFrameRequest->memoryAllocationLimitBytes = m_layerTreeHostImpl->memoryAllocationLimitBytes();
458		487
459	m_mainThreadProxy->postTask(createCCThreadTask(this, &CCThreadProxy::beginFrame));	488	m_mainThreadProxy->postTask(createCCThreadTask(this, &CCThreadProxy::beginFrame));
Lines 520-527 void CCThreadProxy::beginFrame() a/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp_sec14
520	if (!m_layerTreeHost->initializeRendererIfNeeded())	549	if (!m_layerTreeHost->initializeRendererIfNeeded())
521	return;	550	return;
522		551
523	if (request->contentsTexturesWereDeleted)	552	m_layerTreeHost->destroyContentsTexturesEvictedByImplThread();
524	m_layerTreeHost->evictAllContentTextures();
525		553
526	OwnPtr<CCTextureUpdateQueue> queue = adoptPtr(new CCTextureUpdateQueue);	554	OwnPtr<CCTextureUpdateQueue> queue = adoptPtr(new CCTextureUpdateQueue);
527	m_layerTreeHost->updateLayers(*(queue.get()), request->memoryAllocationLimitBytes);	555	m_layerTreeHost->updateLayers(*(queue.get()), request->memoryAllocationLimitBytes);
Lines 544-552 void CCThreadProxy::beginFrame() a/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp_sec15
544	{	572	{
545	TRACE_EVENT0("cc", "commit");	573	TRACE_EVENT0("cc", "commit");
546	DebugScopedSetMainThreadBlocked mainThreadBlocked;	574	DebugScopedSetMainThreadBlocked mainThreadBlocked;
547
548	CCCompletionEvent completion;	575	CCCompletionEvent completion;
549	CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::beginFrameCompleteOnImplThread, &completion, queue.release(), request->contentsTexturesWereDeleted));	576	CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::beginFrameCompleteOnImplThread, &completion, queue.release(), request->contentsTexturesPurgeAck));
550	completion.wait();	577	completion.wait();
551	}	578	}
552		579
Lines 554-560 void CCThreadProxy::beginFrame() a/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp_sec16
554	m_layerTreeHost->didBeginFrame();	581	m_layerTreeHost->didBeginFrame();
555	}	582	}
556		583
557	void CCThreadProxy::beginFrameCompleteOnImplThread(CCCompletionEvent* completion, PassOwnPtr<CCTextureUpdateQueue> queue, bool contentsTexturesWereDeleted)	584	void CCThreadProxy::beginFrameCompleteOnImplThread(CCCompletionEvent* completion, PassOwnPtr<CCTextureUpdateQueue> queue, int contentsTexturesPurgeAck)
558	{	585	{
559	TRACE_EVENT0("cc", "CCThreadProxy::beginFrameCompleteOnImplThread");	586	TRACE_EVENT0("cc", "CCThreadProxy::beginFrameCompleteOnImplThread");
560	ASSERT(!m_commitCompletionEventOnImplThread);	587	ASSERT(!m_commitCompletionEventOnImplThread);
Lines 567-585 void CCThreadProxy::beginFrameCompleteOnImplThread(CCCompletionEvent* completion a/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp_sec17
567	return;	594	return;
568	}	595	}
569		596
570	if (!contentsTexturesWereDeleted && m_layerTreeHostImpl->contentsTexturesPurged()) {	597	m_contentsTexturesPurgeAck = contentsTexturesPurgeAck;
571	// We purged the content textures on the impl thread between the time we	598	if (m_contentsTexturesPurgeAck != m_contentsTexturesPurgeCount) {
572	// posted the beginFrame task and now, meaning we have a bunch of	599	TRACE_EVENT0("cc", "CCThreadProxy::beginFrameCompleteOnImplThread_purge_since_commit");
573	// uploads that are now invalid. Clear the uploads (they all go to	600	// The upload queue may contain references to textures that were asynchronously
574	// content textures), and kick another commit to fill them again.	601	// deleted. Remove them.
575	queue->clearUploads();	602	queue->clearUploadsToDeletedResources();
		603	// There exist textures purged by the impl thread that the main thread
		604	// doesn't know of. Rquest a recommit, which will inform the main thread
		605	// of the purged resources.
576	setNeedsCommitOnImplThread();	606	setNeedsCommitOnImplThread();
577	} else	607	}
578	m_resetContentsTexturesPurgedAfterCommitOnImplThread = true;
579		608
580	m_currentTextureUpdateControllerOnImplThread = CCTextureUpdateController::create(CCProxy::implThread(), queue, m_layerTreeHostImpl->resourceProvider(), m_layerTreeHostImpl->renderer()->textureCopier(), m_layerTreeHostImpl->renderer()->textureUploader());	609	m_currentTextureUpdateControllerOnImplThread = CCTextureUpdateController::create(CCProxy::implThread(), queue, m_layerTreeHostImpl->resourceProvider(), m_layerTreeHostImpl->renderer()->textureCopier(), m_layerTreeHostImpl->renderer()->textureUploader());
581	m_commitCompletionEventOnImplThread = completion;	610	m_commitCompletionEventOnImplThread = completion;
582
583	m_schedulerOnImplThread->beginFrameComplete();	611	m_schedulerOnImplThread->beginFrameComplete();
584	}	612	}
585		613
Lines 630-637 void CCThreadProxy::scheduledActionCommit() a/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp_sec18
630	m_layerTreeHost->beginCommitOnImplThread(m_layerTreeHostImpl.get());	658	m_layerTreeHost->beginCommitOnImplThread(m_layerTreeHostImpl.get());
631	m_layerTreeHost->finishCommitOnImplThread(m_layerTreeHostImpl.get());	659	m_layerTreeHost->finishCommitOnImplThread(m_layerTreeHostImpl.get());
632		660
633	if (m_resetContentsTexturesPurgedAfterCommitOnImplThread) {	661	if (m_contentsTexturesPurgeAck == m_contentsTexturesPurgeCount) {
634	m_resetContentsTexturesPurgedAfterCommitOnImplThread = false;	662	// The tree now references no purged textures. Allow it to draw again.
635	m_layerTreeHostImpl->resetContentsTexturesPurged();	663	m_layerTreeHostImpl->resetContentsTexturesPurged();
636	}	664	}
637		665
Lines 725-733 void CCThreadProxy::acquireLayerTextures() a/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp_sec19
725	return;	753	return;
726		754
727	TRACE_EVENT0("cc", "CCThreadProxy::acquireLayerTextures");	755	TRACE_EVENT0("cc", "CCThreadProxy::acquireLayerTextures");
728	CCCompletionEvent completion;	756	{
729	CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::acquireLayerTexturesForMainThreadOnImplThread, &completion));	757	DebugScopedSetMainThreadBlocked mainThreadBlocked;
730	completion.wait(); // Block until it is safe to write to layer textures from the main thread.	758	CCCompletionEvent completion;
		759	CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::acquireLayerTexturesForMainThreadOnImplThread, &completion));
		760	completion.wait(); // Block until it is safe to write to layer textures from the main thread.
		761	}
731		762
732	m_texturesAcquired = true;	763	m_texturesAcquired = true;
733	}	764	}
Lines 869-876 void CCThreadProxy::layerTreeHostClosedOnImplThread(CCCompletionEvent* completio a/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp_sec20
869	{	900	{
870	TRACE_EVENT0("cc", "CCThreadProxy::layerTreeHostClosedOnImplThread");	901	TRACE_EVENT0("cc", "CCThreadProxy::layerTreeHostClosedOnImplThread");
871	ASSERT(isImplThread());	902	ASSERT(isImplThread());
872	if (!m_layerTreeHostImpl->contentsTexturesPurged())	903	m_layerTreeHost->deleteAllContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
873	m_layerTreeHost->deleteContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
874	m_inputHandlerOnImplThread.clear();	904	m_inputHandlerOnImplThread.clear();
875	m_layerTreeHostImpl.clear();	905	m_layerTreeHostImpl.clear();
876	m_schedulerOnImplThread.clear();	906	m_schedulerOnImplThread.clear();
Lines 892-899 void CCThreadProxy::recreateContextOnImplThread(CCCompletionEvent* completion, C a/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp_sec21
892	{	922	{
893	TRACE_EVENT0("cc", "CCThreadProxy::recreateContextOnImplThread");	923	TRACE_EVENT0("cc", "CCThreadProxy::recreateContextOnImplThread");
894	ASSERT(isImplThread());	924	ASSERT(isImplThread());
895	if (!m_layerTreeHostImpl->contentsTexturesPurged())	925	m_layerTreeHost->deleteAllContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
896	m_layerTreeHost->deleteContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
897	*recreateSucceeded = m_layerTreeHostImpl->initializeRenderer(adoptPtr(contextPtr), textureUploader);	926	*recreateSucceeded = m_layerTreeHostImpl->initializeRenderer(adoptPtr(contextPtr), textureUploader);
898	if (*recreateSucceeded) {	927	if (*recreateSucceeded) {
899	*capabilities = m_layerTreeHostImpl->rendererCapabilities();	928	*capabilities = m_layerTreeHostImpl->rendererCapabilities();



    virtual void setNeedsRedrawOnImplThread() OVERRIDE;
    virtual void setNeedsCommitOnImplThread() OVERRIDE;
    virtual void postAnimationEventsToMainThreadOnImplThread(PassOwnPtr<CCAnimationEventsVector>, double wallClockTime) OVERRIDE;
    virtual void reduceContentsTexturesMemoryOnImplThread() OVERRIDE;

    // CCSchedulerClient implementation
    virtual bool canDraw() OVERRIDE;

    // Set on impl thread, read on main thread.
    struct BeginFrameAndCommitState {
        BeginFrameAndCommitState()
            : monotonicFrameBeginTime(0), contentsTexturesPurgeAck(0)
        {
        }

        double monotonicFrameBeginTime;
        OwnPtr<CCScrollAndScaleSet> scrollInfo;
        int contentsTexturesPurgeAck;
        size_t memoryAllocationLimitBytes;
    };
    OwnPtr<BeginFrameAndCommitState> m_pendingBeginFrameRequest;

        IntRect rect;
    };
    void forceBeginFrameOnImplThread(CCCompletionEvent*);
    void beginFrameCompleteOnImplThread(CCCompletionEvent*, PassOwnPtr<CCTextureUpdateQueue>, int contentsTexturesPurgeAck);
    void beginFrameAbortedOnImplThread();
    void requestReadbackOnImplThread(ReadbackRequest*);
    void requestStartPageScaleAnimationOnImplThread(IntSize targetPosition, bool useAnchor, float scale, double durationSec);


    OwnPtr<CCTextureUpdateController> m_currentTextureUpdateControllerOnImplThread;

    // Counter incremented every time the impl thread deletes textures, sent to the
    // main thread with each commit.
    int m_contentsTexturesPurgeCount;

    // Value that the main thread sends as an acknowledgement to the impl thread.
    // If this does not equal m_contentsTexturesPurgeCount then the impl layer tree
    // may reference textures that have been purged.
    int m_contentsTexturesPurgeAck;

    // Set when the next draw should post didCommitAndDrawFrame to the main thread.
    bool m_nextFrameIsNewlyCommittedFrameOnImplThread;



    virtual void setNeedsRedrawOnImplThread() OVERRIDE { m_didRequestRedraw = true; }
    virtual void setNeedsCommitOnImplThread() OVERRIDE { m_didRequestCommit = true; }
    virtual void postAnimationEventsToMainThreadOnImplThread(PassOwnPtr<CCAnimationEventsVector>, double wallClockTime) OVERRIDE { }
    virtual void reduceContentsTexturesMemoryOnImplThread() OVERRIDE { }

    PassOwnPtr<CCLayerTreeHostImpl> createLayerTreeHost(bool partialSwap, PassOwnPtr<CCGraphicsContext> graphicsContext, PassOwnPtr<CCLayerImpl> rootPtr)
    {

    }
}

TEST_F(CCLayerTreeHostImplTest, releaseContentsTextureShouldTriggerCommit)
{
    m_hostImpl->releaseContentsTextures();
    EXPECT_TRUE(m_didRequestCommit);
}

struct RenderPassCacheEntry {
    mutable OwnPtr<CCRenderPass> renderPassPtr;
    CCRenderPass* renderPass;

Lines 32-37 a/Source/WebKit/chromium/tests/CCPrioritizedTextureTest.cpp_sec1
- a/Source/WebKit/chromium/tests/CCPrioritizedTextureTest.cpp -16 / +21 lines
32	#include "CCTiledLayerTestCommon.h"	32	#include "CCTiledLayerTestCommon.h"
33	#include "FakeCCGraphicsContext.h"	33	#include "FakeCCGraphicsContext.h"
34	#include <gtest/gtest.h>	34	#include <gtest/gtest.h>
		35	#include <public/WebCompositor.h>
35		36
36	using namespace WebCore;	37	using namespace WebCore;
37	using namespace WebKitTests;	38	using namespace WebKitTests;
Lines 46-59 public: a/Source/WebKit/chromium/tests/CCPrioritizedTextureTest.cpp_sec2
46	, m_textureFormat(GraphicsContext3D::RGBA)	47	, m_textureFormat(GraphicsContext3D::RGBA)
47	, m_context(WebKit::createFakeCCGraphicsContext())	48	, m_context(WebKit::createFakeCCGraphicsContext())
48	{	49	{
		50	WebKit::WebCompositor::initialize(0);
49	DebugScopedSetImplThread implThread;	51	DebugScopedSetImplThread implThread;
50	m_resourceProvider = CCResourceProvider::create(m_context.get());	52	m_resourceProvider = CCResourceProvider::create(m_context.get());
51	}	53	}
52		54
53	virtual ~CCPrioritizedTextureTest()	55	virtual ~CCPrioritizedTextureTest()
54	{	56	{
55	DebugScopedSetImplThread implThread;	57	{
56	m_resourceProvider.clear();	58	DebugScopedSetImplThread implThread;
		59	m_resourceProvider.clear();
		60	}
		61	WebKit::WebCompositor::shutdown();
57	}	62	}
58		63
59	size_t texturesMemorySize(size_t textureCount)	64	size_t texturesMemorySize(size_t textureCount)
Lines 68-79 public: a/Source/WebKit/chromium/tests/CCPrioritizedTextureTest.cpp_sec3
68		73
69	bool validateTexture(OwnPtr<CCPrioritizedTexture>& texture, bool requestLate)	74	bool validateTexture(OwnPtr<CCPrioritizedTexture>& texture, bool requestLate)
70	{	75	{
71	DebugScopedSetImplThread implThread;
72	#if !ASSERT_DISABLED	76	#if !ASSERT_DISABLED
73	texture->textureManager()->assertInvariants();	77	texture->textureManager()->assertInvariants();
74	#endif	78	#endif
75	if (requestLate)	79	if (requestLate)
76	texture->requestLate();	80	texture->requestLate();
		81	DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
77	bool success = texture->canAcquireBackingTexture();	82	bool success = texture->canAcquireBackingTexture();
78	if (success)	83	if (success)
79	texture->acquireBackingTexture(resourceProvider());	84	texture->acquireBackingTexture(resourceProvider());
Lines 128-134 TEST_F(CCPrioritizedTextureTest, requestTextureExceedingMaxLimit) a/Source/WebKit/chromium/tests/CCPrioritizedTextureTest.cpp_sec4
128	EXPECT_EQ(texturesMemorySize(maxTextures), textureManager->memoryAboveCutoffBytes());	133	EXPECT_EQ(texturesMemorySize(maxTextures), textureManager->memoryAboveCutoffBytes());
129	EXPECT_LE(textureManager->memoryUseBytes(), textureManager->memoryAboveCutoffBytes());	134	EXPECT_LE(textureManager->memoryUseBytes(), textureManager->memoryAboveCutoffBytes());
130		135
131	DebugScopedSetImplThread implThread;	136	DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
132	textureManager->clearAllMemory(resourceProvider());	137	textureManager->clearAllMemory(resourceProvider());
133	}	138	}
134		139
Lines 149-155 TEST_F(CCPrioritizedTextureTest, changeMemoryLimits) a/Source/WebKit/chromium/tests/CCPrioritizedTextureTest.cpp_sec5
149	for (size_t i = 0; i < maxTextures; ++i)	154	for (size_t i = 0; i < maxTextures; ++i)
150	validateTexture(textures[i], false);	155	validateTexture(textures[i], false);
151	{	156	{
152	DebugScopedSetImplThread implThread;	157	DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
153	textureManager->reduceMemory(resourceProvider());	158	textureManager->reduceMemory(resourceProvider());
154	}	159	}
155		160
Lines 162-168 TEST_F(CCPrioritizedTextureTest, changeMemoryLimits) a/Source/WebKit/chromium/tests/CCPrioritizedTextureTest.cpp_sec6
162	for (size_t i = 0; i < maxTextures; ++i)	167	for (size_t i = 0; i < maxTextures; ++i)
163	EXPECT_EQ(validateTexture(textures[i], false), i < 5);	168	EXPECT_EQ(validateTexture(textures[i], false), i < 5);
164	{	169	{
165	DebugScopedSetImplThread implThread;	170	DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
166	textureManager->reduceMemory(resourceProvider());	171	textureManager->reduceMemory(resourceProvider());
167	}	172	}
168		173
Lines 175-188 TEST_F(CCPrioritizedTextureTest, changeMemoryLimits) a/Source/WebKit/chromium/tests/CCPrioritizedTextureTest.cpp_sec7
175	for (size_t i = 0; i < maxTextures; ++i)	180	for (size_t i = 0; i < maxTextures; ++i)
176	EXPECT_EQ(validateTexture(textures[i], false), i < 4);	181	EXPECT_EQ(validateTexture(textures[i], false), i < 4);
177	{	182	{
178	DebugScopedSetImplThread implThread;	183	DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
179	textureManager->reduceMemory(resourceProvider());	184	textureManager->reduceMemory(resourceProvider());
180	}	185	}
181		186
182	EXPECT_EQ(texturesMemorySize(4), textureManager->memoryAboveCutoffBytes());	187	EXPECT_EQ(texturesMemorySize(4), textureManager->memoryAboveCutoffBytes());
183	EXPECT_LE(textureManager->memoryUseBytes(), textureManager->memoryAboveCutoffBytes());	188	EXPECT_LE(textureManager->memoryUseBytes(), textureManager->memoryAboveCutoffBytes());
184		189
185	DebugScopedSetImplThread implThread;	190	DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
186	textureManager->clearAllMemory(resourceProvider());	191	textureManager->clearAllMemory(resourceProvider());
187	}	192	}
188		193
Lines 242-248 TEST_F(CCPrioritizedTextureTest, textureManagerPartialUpdateTextures) a/Source/WebKit/chromium/tests/CCPrioritizedTextureTest.cpp_sec8
242	EXPECT_FALSE(textures[2]->haveBackingTexture());	247	EXPECT_FALSE(textures[2]->haveBackingTexture());
243	EXPECT_FALSE(textures[3]->haveBackingTexture());	248	EXPECT_FALSE(textures[3]->haveBackingTexture());
244		249
245	DebugScopedSetImplThread implThread;	250	DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
246	textureManager->clearAllMemory(resourceProvider());	251	textureManager->clearAllMemory(resourceProvider());
247	}	252	}
248		253
Lines 282-288 TEST_F(CCPrioritizedTextureTest, textureManagerPrioritiesAreEqual) a/Source/WebKit/chromium/tests/CCPrioritizedTextureTest.cpp_sec9
282	EXPECT_EQ(texturesMemorySize(8), textureManager->memoryAboveCutoffBytes());	287	EXPECT_EQ(texturesMemorySize(8), textureManager->memoryAboveCutoffBytes());
283	EXPECT_LE(textureManager->memoryUseBytes(), textureManager->memoryAboveCutoffBytes());	288	EXPECT_LE(textureManager->memoryUseBytes(), textureManager->memoryAboveCutoffBytes());
284		289
285	DebugScopedSetImplThread implThread;	290	DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
286	textureManager->clearAllMemory(resourceProvider());	291	textureManager->clearAllMemory(resourceProvider());
287	}	292	}
288		293
Lines 302-308 TEST_F(CCPrioritizedTextureTest, textureManagerDestroyedFirst) a/Source/WebKit/chromium/tests/CCPrioritizedTextureTest.cpp_sec10
302	EXPECT_TRUE(texture->haveBackingTexture());	307	EXPECT_TRUE(texture->haveBackingTexture());
303		308
304	{	309	{
305	DebugScopedSetImplThread implThread;	310	DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
306	textureManager->clearAllMemory(resourceProvider());	311	textureManager->clearAllMemory(resourceProvider());
307	}	312	}
308	textureManager.clear();	313	textureManager.clear();
Lines 330-336 TEST_F(CCPrioritizedTextureTest, textureMovedToNewManager) a/Source/WebKit/chromium/tests/CCPrioritizedTextureTest.cpp_sec11
330	texture->setTextureManager(0);	335	texture->setTextureManager(0);
331		336
332	{	337	{
333	DebugScopedSetImplThread implThread;	338	DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
334	textureManagerOne->clearAllMemory(resourceProvider());	339	textureManagerOne->clearAllMemory(resourceProvider());
335	}	340	}
336	textureManagerOne.clear();	341	textureManagerOne.clear();
Lines 346-352 TEST_F(CCPrioritizedTextureTest, textureMovedToNewManager) a/Source/WebKit/chromium/tests/CCPrioritizedTextureTest.cpp_sec12
346	EXPECT_TRUE(texture->canAcquireBackingTexture());	351	EXPECT_TRUE(texture->canAcquireBackingTexture());
347	EXPECT_TRUE(texture->haveBackingTexture());	352	EXPECT_TRUE(texture->haveBackingTexture());
348		353
349	DebugScopedSetImplThread implThread;	354	DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
350	textureManagerTwo->clearAllMemory(resourceProvider());	355	textureManagerTwo->clearAllMemory(resourceProvider());
351	}	356	}
352		357
Lines 392-398 TEST_F(CCPrioritizedTextureTest, renderSurfacesReduceMemoryAvailableOutsideRootS a/Source/WebKit/chromium/tests/CCPrioritizedTextureTest.cpp_sec13
392	EXPECT_EQ(texturesMemorySize(4), textureManager->memoryForSelfManagedTextures());	397	EXPECT_EQ(texturesMemorySize(4), textureManager->memoryForSelfManagedTextures());
393	EXPECT_LE(textureManager->memoryUseBytes(), textureManager->memoryAboveCutoffBytes());	398	EXPECT_LE(textureManager->memoryUseBytes(), textureManager->memoryAboveCutoffBytes());
394		399
395	DebugScopedSetImplThread implThread;	400	DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
396	textureManager->clearAllMemory(resourceProvider());	401	textureManager->clearAllMemory(resourceProvider());
397	}	402	}
398		403
Lines 429-435 TEST_F(CCPrioritizedTextureTest, renderSurfacesReduceMemoryAvailableForRequestLa a/Source/WebKit/chromium/tests/CCPrioritizedTextureTest.cpp_sec14
429	EXPECT_EQ(texturesMemorySize(4), textureManager->memoryForSelfManagedTextures());	434	EXPECT_EQ(texturesMemorySize(4), textureManager->memoryForSelfManagedTextures());
430	EXPECT_LE(textureManager->memoryUseBytes(), textureManager->memoryAboveCutoffBytes());	435	EXPECT_LE(textureManager->memoryUseBytes(), textureManager->memoryAboveCutoffBytes());
431		436
432	DebugScopedSetImplThread implThread;	437	DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
433	textureManager->clearAllMemory(resourceProvider());	438	textureManager->clearAllMemory(resourceProvider());
434	}	439	}
435		440
Lines 469-475 TEST_F(CCPrioritizedTextureTest, whenRenderSurfaceNotAvailableTexturesAlsoNotAva a/Source/WebKit/chromium/tests/CCPrioritizedTextureTest.cpp_sec15
469	EXPECT_EQ(texturesMemorySize(2), textureManager->memoryForSelfManagedTextures());	474	EXPECT_EQ(texturesMemorySize(2), textureManager->memoryForSelfManagedTextures());
470	EXPECT_LE(textureManager->memoryUseBytes(), textureManager->memoryAboveCutoffBytes());	475	EXPECT_LE(textureManager->memoryUseBytes(), textureManager->memoryAboveCutoffBytes());
471		476
472	DebugScopedSetImplThread implThread;	477	DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
473	textureManager->clearAllMemory(resourceProvider());	478	textureManager->clearAllMemory(resourceProvider());
474	}	479	}
475		480



        , m_textureManager(CCPrioritizedTextureManager::create(60*1024*1024, 1024, CCRenderer::ContentPool))
        , m_occlusion(0)
    {
        WebKit::WebCompositor::initialize(0);
        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
        m_resourceProvider = CCResourceProvider::create(m_context.get());
    }

    virtual ~TiledLayerChromiumTest()
    {
        {
            DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
            m_textureManager->clearAllMemory(m_resourceProvider.get());
            m_resourceProvider.clear();
        }
        WebKit::WebCompositor::shutdown();
    }

    void updateTextures(int count = 500)

                       FakeTiledLayerChromium* layer2 = 0,
                       CCLayerImpl* layerImpl2 = 0)
    {
        {
            DebugScopedSetMainThread mainThread;
            
            // Get textures
            m_textureManager->clearPriorities();
            if (layer1)
                layer1->setTexturePriorities(m_priorityCalculator);
            if (layer2)
                layer2->setTexturePriorities(m_priorityCalculator);     
            m_textureManager->prioritizeTextures();

            // Update content
            if (layer1)
                layer1->update(m_queue, m_occlusion, m_stats);
            if (layer2)
                layer2->update(m_queue, m_occlusion, m_stats);
        }

        bool needsUpdate = false;
        if (layer1)

        return needsUpdate;
    }

    void setTexturePrioritiesAndPrioritizeTexturesOnMainThread(FakeTiledLayerChromium* layer)
    {
        DebugScopedSetMainThread mainThread;
        layer->setTexturePriorities(m_priorityCalculator);
        m_textureManager->prioritizeTextures();
    }

    void updateLayerOnMainThread(FakeTiledLayerChromium* layer, TestCCOcclusionTracker* occluded)
    {
        DebugScopedSetMainThread mainThread;
        layer->update(m_queue, occluded, m_stats);
    }

public:
    OwnPtr<CCGraphicsContext> m_context;
    OwnPtr<CCResourceProvider> m_resourceProvider;

    TestCCOcclusionTracker* m_occlusion;
};

class TiledLayerChromiumTestOnImplThread : public TiledLayerChromiumTest {
public:
    TiledLayerChromiumTestOnImplThread() { }
    virtual ~TiledLayerChromiumTestOnImplThread() { }

private:
     DebugScopedSetImplThreadAndMainThreadBlocked m_implThreadAndMainThreadBlocked;
};

TEST_F(TiledLayerChromiumTestOnImplThread, pushDirtyTiles)
{
    RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
    DebugScopedSetImplThread implThread;
    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));

    // The tile size is 100x100, so this invalidates and then paints two tiles.

    EXPECT_FALSE(layerImpl->hasTileAt(0, 1));
}

TEST_F(TiledLayerChromiumTestOnImplThread, pushOccludedDirtyTiles)
{
    RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
    DebugScopedSetImplThread implThread;
    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
    TestCCOcclusionTracker occluded;
    m_occlusion = &occluded;

    EXPECT_TRUE(layerImpl->hasTileAt(0, 1));
}

TEST_F(TiledLayerChromiumTestOnImplThread, pushDeletedTiles)
{
    RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
    DebugScopedSetImplThread implThread;
    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));

    // The tile size is 100x100, so this invalidates and then paints two tiles.

    EXPECT_TRUE(layerImpl->hasTileAt(0, 0));
    EXPECT_TRUE(layerImpl->hasTileAt(0, 1));

    {
        DebugScopedSetMainThread mainThread;
        m_textureManager->clearPriorities();
    }
    m_textureManager->clearAllMemory(m_resourceProvider.get());
    m_textureManager->setMaxMemoryLimitBytes(4*1024*1024);


    EXPECT_FALSE(layerImpl->hasTileAt(0, 1));
}

TEST_F(TiledLayerChromiumTestOnImplThread, pushIdlePaintTiles)
{
    RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
    DebugScopedSetImplThread implThread;
    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));

    // The tile size is 100x100. Setup 5x5 tiles with one visible tile in the center.

    EXPECT_FALSE(needsUpdate);
}

TEST_F(TiledLayerChromiumTestOnImplThread, pushTilesAfterIdlePaintFailed)
{
    // Start with 2mb of memory, but the test is going to try to use just more than 1mb, so we reduce to 1mb later.
    m_textureManager->setMaxMemoryLimitBytes(2 * 1024 * 1024);    
    DebugScopedSetImplThread implThread;
    RefPtr<FakeTiledLayerChromium> layer1 = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
    OwnPtr<FakeCCTiledLayerImpl> layerImpl1(adoptPtr(new FakeCCTiledLayerImpl(1)));
    RefPtr<FakeTiledLayerChromium> layer2 = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));

    EXPECT_FALSE(layerImpl2->hasTileAt(0, 2));
}

TEST_F(TiledLayerChromiumTestOnImplThread, pushIdlePaintedOccludedTiles)
{
    RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
    DebugScopedSetImplThread implThread;
    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
    TestCCOcclusionTracker occluded;
    m_occlusion = &occluded;

    EXPECT_EQ(1, occluded.overdrawMetrics().tilesCulledForUpload());
}

TEST_F(TiledLayerChromiumTestOnImplThread, pushTilesMarkedDirtyDuringPaint)
{
    RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
    DebugScopedSetImplThread implThread;
    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));

    // The tile size is 100x100, so this invalidates and then paints two tiles.

    EXPECT_TRUE(layerImpl->hasTileAt(0, 1));
}

TEST_F(TiledLayerChromiumTestOnImplThread, pushTilesLayerMarkedDirtyDuringPaintOnNextLayer)
{
    RefPtr<FakeTiledLayerChromium> layer1 = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
    RefPtr<FakeTiledLayerChromium> layer2 = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
    DebugScopedSetImplThread implThread;
    OwnPtr<FakeCCTiledLayerImpl> layer1Impl(adoptPtr(new FakeCCTiledLayerImpl(1)));
    OwnPtr<FakeCCTiledLayerImpl> layer2Impl(adoptPtr(new FakeCCTiledLayerImpl(2)));


    EXPECT_TRUE(layer2Impl->hasTileAt(0, 1));
}

TEST_F(TiledLayerChromiumTestOnImplThread, pushTilesLayerMarkedDirtyDuringPaintOnPreviousLayer)
{
    RefPtr<FakeTiledLayerChromium> layer1 = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
    RefPtr<FakeTiledLayerChromium> layer2 = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
    DebugScopedSetImplThread implThread;
    OwnPtr<FakeCCTiledLayerImpl> layer1Impl(adoptPtr(new FakeCCTiledLayerImpl(1)));
    OwnPtr<FakeCCTiledLayerImpl> layer2Impl(adoptPtr(new FakeCCTiledLayerImpl(2)));


{
    // Create a CCLayerTreeHost that has the right viewportsize,
    // so the layer is considered small enough.
    WebKit::WebCompositor::initialize(0);
    FakeCCLayerTreeHostClient fakeCCLayerTreeHostClient;
    OwnPtr<CCLayerTreeHost> ccLayerTreeHost = CCLayerTreeHost::create(&fakeCCLayerTreeHostClient, CCLayerTreeSettings());

    {
        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
        bool runOutOfMemory[2] = {false, true};
        for (int i = 0; i < 2; i++) {
            // Create a layer with 4x4 tiles.
            int layerWidth  = 4 * FakeTiledLayerChromium::tileSize().width();
            int layerHeight = 4 * FakeTiledLayerChromium::tileSize().height();
            int memoryForLayer = layerWidth * layerHeight * 4;
            IntSize viewportSize = IntSize(layerWidth, layerHeight);
            {
                DebugScopedSetMainThread mainThread;
                ccLayerTreeHost->setViewportSize(viewportSize, viewportSize);
            }

            // Use 8x4 tiles to run out of memory.
            if (runOutOfMemory[i])
                layerWidth *= 2;

            m_textureManager->setMaxMemoryLimitBytes(memoryForLayer);
        DebugScopedSetImplThread implThread;

            RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
            OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));

            {
                DebugScopedSetMainThread mainThread;
        IntRect contentRect(IntPoint::zero(), contentBounds);
        IntRect visibleRect(IntPoint::zero(), IntSize(layerWidth / 2, layerHeight));

                // Full size layer with half being visible.
                IntSize contentBounds(layerWidth, layerHeight);
                IntRect contentRect(IntPoint::zero(), contentBounds);
                IntRect visibleRect(IntPoint::zero(), IntSize(layerWidth / 2, layerHeight));

                // Pretend the layer is animating.
                layer->setDrawTransformIsAnimating(true);
                layer->setBounds(contentBounds);
                layer->setVisibleContentRect(visibleRect);
                layer->invalidateContentRect(contentRect);
                layer->setLayerTreeHost(ccLayerTreeHost.get());
        layer->update(m_queue, 0, m_stats);
        updateTextures();
        layer->pushPropertiesTo(layerImpl.get());

        // We should have all the tiles for the small animated layer.
        // We should still have the visible tiles when we didn't
        // have enough memory for all the tiles.
        if (!runOutOfMemory[i]) {
            for (int i = 0; i < 4; ++i) {
                for (int j = 0; j < 4; ++j)
                    EXPECT_TRUE(layerImpl->hasTileAt(i, j));
            }

            // The layer should paint it's entire contents on the first paint
            // if it is close to the viewport size and has the available memory.
            setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
            updateLayerOnMainThread(layer.get(), 0);
            updateTextures();
            layer->pushPropertiesTo(layerImpl.get());

            // We should have all the tiles for the small animated layer.
            // We should still have the visible tiles when we didn't
            // have enough memory for all the tiles.
            if (!runOutOfMemory[i]) {
                for (int i = 0; i < 4; ++i) {
                    for (int j = 0; j < 4; ++j)
                        EXPECT_TRUE(layerImpl->hasTileAt(i, j));
                }
            } else {
                for (int i = 0; i < 8; ++i) {
                    for (int j = 0; j < 4; ++j)
                        EXPECT_EQ(layerImpl->hasTileAt(i, j), i < 4);
                }
            }
        }
    }
    ccLayerTreeHost.clear();
    WebKit::WebCompositor::shutdown();
}

TEST_F(TiledLayerChromiumTestOnImplThread, idlePaintOutOfMemory)
{
    RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
    DebugScopedSetImplThread implThread;
    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));

    // We have enough memory for only the visible rect, so we will run out of memory in first idle paint.

    EXPECT_TRUE(layerImpl->hasTileAt(1, 1));
}

TEST_F(TiledLayerChromiumTestOnImplThread, idlePaintZeroSizedLayer)
{
    RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
    DebugScopedSetImplThread implThread;
    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));

    bool animating[2] = {false, true};

    }
}

TEST_F(TiledLayerChromiumTestOnImplThread, idlePaintNonVisibleLayers)
{
    RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
    DebugScopedSetImplThread implThread;
    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));

    // Alternate between not visible and visible.

    }
}

TEST_F(TiledLayerChromiumTestOnImplThread, invalidateFromPrepare)
{
    RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
    DebugScopedSetImplThread implThread;
    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));

    // The tile size is 100x100, so this invalidates and then paints two tiles.

    EXPECT_EQ(1, layer->fakeLayerTextureUpdater()->prepareCount());
}

TEST_F(TiledLayerChromiumTestOnImplThread, verifyUpdateRectWhenContentBoundsAreScaled)
{
    // The updateRect (that indicates what was actually painted) should be in
    // layer space, not the content space.
    RefPtr<FakeTiledLayerWithScaledBounds> layer = adoptRef(new FakeTiledLayerWithScaledBounds(m_textureManager.get()));
    DebugScopedSetImplThread implThread;

    IntRect layerBounds(0, 0, 300, 200);
    IntRect contentBounds(0, 0, 200, 250);

    // However, it should still be in layer space, not content space.
    layer->invalidateContentRect(contentBounds);

    setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
    updateLayerOnMainThread(layer.get(), 0);
    layer->update(m_queue, 0, m_stats);
    EXPECT_FLOAT_RECT_EQ(FloatRect(0, 0, 300, 300 * 0.8), layer->updateRect());
    updateTextures();

    // After the tiles are updated once, another invalidate only needs to update the bounds of the layer.
    setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
    m_textureManager->prioritizeTextures();
    layer->invalidateContentRect(contentBounds);
    updateLayerOnMainThread(layer.get(), 0);
    EXPECT_FLOAT_RECT_EQ(FloatRect(layerBounds), layer->updateRect());
    updateTextures();

    // Partial re-paint should also be represented by the updateRect in layer space, not content space.
    IntRect partialDamage(30, 100, 10, 10);
    layer->invalidateContentRect(partialDamage);
    setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
    updateLayerOnMainThread(layer.get(), 0);
    layer->update(m_queue, 0, m_stats);
    EXPECT_FLOAT_RECT_EQ(FloatRect(45, 80, 15, 8), layer->updateRect());
}

TEST_F(TiledLayerChromiumTestOnImplThread, verifyInvalidationWhenContentsScaleChanges)
{
    RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
    DebugScopedSetImplThread implThread;
    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));

    // Create a layer with one tile.

    EXPECT_FLOAT_RECT_EQ(FloatRect(0, 0, 100, 100), layer->lastNeedsDisplayRect());

    // Push the tiles to the impl side and check that there is exactly one.
    setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
    updateLayerOnMainThread(layer.get(), 0);
    layer->update(m_queue, 0, m_stats);
    updateTextures();
    layer->pushPropertiesTo(layerImpl.get());
    EXPECT_TRUE(layerImpl->hasTileAt(0, 0));

    EXPECT_FLOAT_RECT_EQ(FloatRect(0, 0, 100, 100), layer->lastNeedsDisplayRect());

    // The impl side should get 2x2 tiles now.
    setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
    updateLayerOnMainThread(layer.get(), 0);
    layer->update(m_queue, 0, m_stats);
    updateTextures();
    layer->pushPropertiesTo(layerImpl.get());
    EXPECT_TRUE(layerImpl->hasTileAt(0, 0));

    // Invalidate the entire layer again, but do not paint. All tiles should be gone now from the
    // impl side.
    layer->setNeedsDisplay();
    setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
    m_textureManager->prioritizeTextures();

    layer->pushPropertiesTo(layerImpl.get());
    EXPECT_FALSE(layerImpl->hasTileAt(0, 0));
    EXPECT_FALSE(layerImpl->hasTileAt(0, 1));


TEST_F(TiledLayerChromiumTest, skipsDrawGetsReset)
{
    // Initialize without threading support.
    WebKit::WebCompositor::initialize(0);
    FakeCCLayerTreeHostClient fakeCCLayerTreeHostClient;
    OwnPtr<CCLayerTreeHost> ccLayerTreeHost = CCLayerTreeHost::create(&fakeCCLayerTreeHostClient, CCLayerTreeSettings());
    ASSERT_TRUE(ccLayerTreeHost->initializeRendererIfNeeded());

    {
        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
    IntRect contentRect(IntPoint::zero(), contentBounds);

    // We have enough memory for only one of the two layers.
    int memoryLimit = 4 * 300 * 300; // 4 bytes per pixel.

    RefPtr<FakeTiledLayerChromium> rootLayer = adoptRef(new FakeTiledLayerChromium(ccLayerTreeHost->contentsTextureManager()));
    RefPtr<FakeTiledLayerChromium> childLayer = adoptRef(new FakeTiledLayerChromium(ccLayerTreeHost->contentsTextureManager()));
    rootLayer->addChild(childLayer);

    rootLayer->setBounds(contentBounds);
    rootLayer->setVisibleContentRect(contentRect);
    rootLayer->setPosition(FloatPoint(0, 0));
    childLayer->setBounds(contentBounds);
    childLayer->setVisibleContentRect(contentRect);
    childLayer->setPosition(FloatPoint(0, 0));
    rootLayer->invalidateContentRect(contentRect);
    childLayer->invalidateContentRect(contentRect);

    ccLayerTreeHost->setRootLayer(rootLayer);
    ccLayerTreeHost->setViewportSize(IntSize(300, 300), IntSize(300, 300));

    ccLayerTreeHost->updateLayers(m_queue, memoryLimit);

        // Create two 300 x 300 tiled layers.
        IntSize contentBounds(300, 300);
        IntRect contentRect(IntPoint::zero(), contentBounds);

        // We have enough memory for only one of the two layers.
        int memoryLimit = 4 * 300 * 300; // 4 bytes per pixel.

        RefPtr<FakeTiledLayerChromium> rootLayer = adoptRef(new FakeTiledLayerChromium(ccLayerTreeHost->contentsTextureManager()));
        RefPtr<FakeTiledLayerChromium> childLayer = adoptRef(new FakeTiledLayerChromium(ccLayerTreeHost->contentsTextureManager()));
        rootLayer->addChild(childLayer);

        {
            DebugScopedSetMainThread mainThread;
            rootLayer->setBounds(contentBounds);
            rootLayer->setVisibleContentRect(contentRect);
            rootLayer->setPosition(FloatPoint(0, 0));
            childLayer->setBounds(contentBounds);
            childLayer->setVisibleContentRect(contentRect);
            childLayer->setPosition(FloatPoint(0, 0));
            rootLayer->invalidateContentRect(contentRect);
            childLayer->invalidateContentRect(contentRect);

            ccLayerTreeHost->setRootLayer(rootLayer);
            ccLayerTreeHost->setViewportSize(IntSize(300, 300), IntSize(300, 300));
            ccLayerTreeHost->updateLayers(m_queue, memoryLimit);
        }

        // We'll skip the root layer.
        EXPECT_TRUE(rootLayer->skipsDraw());
        EXPECT_FALSE(childLayer->skipsDraw());

        ccLayerTreeHost->commitComplete();
    EXPECT_FALSE(rootLayer->skipsDraw());

        {
            DebugScopedSetMainThread mainThread;
            // Remove the child layer.
            rootLayer->removeAllChildren();
            ccLayerTreeHost->updateLayers(m_queue, memoryLimit);
            EXPECT_FALSE(rootLayer->skipsDraw());
        }
        ccLayerTreeHost->contentsTextureManager()->clearAllMemory(m_resourceProvider.get());
    }
    ccLayerTreeHost->setRootLayer(0);
    ccLayerTreeHost.clear();
    WebKit::WebCompositor::shutdown();
}

TEST_F(TiledLayerChromiumTestOnImplThread, resizeToSmaller)
{
    RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));


    layer->setVisibleContentRect(IntRect(0, 0, 700, 700));
    layer->invalidateContentRect(IntRect(0, 0, 700, 700));

    setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
    updateLayerOnMainThread(layer.get(), 0);
    layer->update(m_queue, 0, m_stats);

    layer->setBounds(IntSize(200, 200));
    layer->invalidateContentRect(IntRect(0, 0, 200, 200));
}

TEST_F(TiledLayerChromiumTestOnImplThread, hugeLayerUpdateCrash)
{
    RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));


    layer->invalidateContentRect(IntRect(0, 0, size, size));

    // Ensure no crash for bounds where size * size would overflow an int.
    setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
    updateLayerOnMainThread(layer.get(), 0);
    layer->update(m_queue, 0, m_stats);
}

TEST_F(TiledLayerChromiumTest, partialUpdates)
{
    // Initialize without threading support.
    WebKit::WebCompositor::initialize(0);

    CCLayerTreeSettings settings;
    settings.maxPartialTextureUpdates = 4;


    OwnPtr<CCLayerTreeHost> ccLayerTreeHost = CCLayerTreeHost::create(&fakeCCLayerTreeHostClient, settings);
    ASSERT_TRUE(ccLayerTreeHost->initializeRendererIfNeeded());

    {
        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
    IntRect contentRect(IntPoint::zero(), contentBounds);

        // Create one 300 x 200 tiled layer with 3 x 2 tiles.
        IntSize contentBounds(300, 200);
        IntRect contentRect(IntPoint::zero(), contentBounds);
    layer->setVisibleContentRect(contentRect);
    layer->invalidateContentRect(contentRect);

        RefPtr<FakeTiledLayerChromium> layer(adoptRef(new FakeTiledLayerChromium(ccLayerTreeHost->contentsTextureManager())));
    ccLayerTreeHost->setViewportSize(IntSize(300, 200), IntSize(300, 200));

        {
            DebugScopedSetMainThread mainThread;
            layer->setBounds(contentBounds);
            layer->setPosition(FloatPoint(0, 0));
            layer->setVisibleContentRect(contentRect);
            layer->invalidateContentRect(contentRect);
        EXPECT_EQ(4, layer->fakeLayerTextureUpdater()->updateCount());
        EXPECT_TRUE(m_queue.hasMoreUpdates());
        layer->fakeLayerTextureUpdater()->clearUpdateCount();
        updateTextures(4);
        EXPECT_EQ(2, layer->fakeLayerTextureUpdater()->updateCount());
        EXPECT_FALSE(m_queue.hasMoreUpdates());
        layer->fakeLayerTextureUpdater()->clearUpdateCount();
        layer->pushPropertiesTo(layerImpl.get());
    }
    ccLayerTreeHost->commitComplete();

            ccLayerTreeHost->setRootLayer(layer);
            ccLayerTreeHost->setViewportSize(IntSize(300, 200), IntSize(300, 200));
    ccLayerTreeHost->updateLayers(m_queue, std::numeric_limits<size_t>::max());
    {
        DebugScopedSetImplThread implThread;
        OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
        updateTextures(4);
        EXPECT_EQ(3, layer->fakeLayerTextureUpdater()->updateCount());
        EXPECT_TRUE(m_queue.hasMoreUpdates());
        layer->fakeLayerTextureUpdater()->clearUpdateCount();
        updateTextures(4);
        EXPECT_EQ(3, layer->fakeLayerTextureUpdater()->updateCount());
        EXPECT_FALSE(m_queue.hasMoreUpdates());
        layer->fakeLayerTextureUpdater()->clearUpdateCount();
        layer->pushPropertiesTo(layerImpl.get());
    }
    ccLayerTreeHost->commitComplete();

    // Partial update of 6 tiles.
    layer->invalidateContentRect(IntRect(50, 50, 200, 100));
    {
        DebugScopedSetImplThread implThread;
        OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
        ccLayerTreeHost->updateLayers(m_queue, std::numeric_limits<size_t>::max());
        updateTextures(4);
        EXPECT_EQ(2, layer->fakeLayerTextureUpdater()->updateCount());
        EXPECT_TRUE(m_queue.hasMoreUpdates());
        layer->fakeLayerTextureUpdater()->clearUpdateCount();
        updateTextures(4);
        EXPECT_EQ(4, layer->fakeLayerTextureUpdater()->updateCount());
        EXPECT_FALSE(m_queue.hasMoreUpdates());
        layer->fakeLayerTextureUpdater()->clearUpdateCount();
        layer->pushPropertiesTo(layerImpl.get());
    }
    ccLayerTreeHost->commitComplete();

            // Full update of all 6 tiles.
            ccLayerTreeHost->updateLayers(m_queue, std::numeric_limits<size_t>::max());
        }
        DebugScopedSetImplThread implThread;
        OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
        layer->pushPropertiesTo(layerImpl.get());
    }
    ccLayerTreeHost->commitComplete();

        {
            OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
            updateTextures(4);
            EXPECT_EQ(4, layer->fakeLayerTextureUpdater()->updateCount());
            EXPECT_TRUE(m_queue.hasMoreUpdates());
            layer->fakeLayerTextureUpdater()->clearUpdateCount();
            updateTextures(4);
            EXPECT_EQ(2, layer->fakeLayerTextureUpdater()->updateCount());
            EXPECT_FALSE(m_queue.hasMoreUpdates());
            layer->fakeLayerTextureUpdater()->clearUpdateCount();
            layer->pushPropertiesTo(layerImpl.get());
        }
        ccLayerTreeHost->commitComplete();
        layer->fakeLayerTextureUpdater()->clearUpdateCount();
        layer->pushPropertiesTo(layerImpl.get());
    }
    ccLayerTreeHost->commitComplete();

        // Full update of 3 tiles and partial update of 3 tiles.
        layer->invalidateContentRect(IntRect(0, 0, 300, 150));
        {
            DebugScopedSetMainThread mainThread;
            ccLayerTreeHost->updateLayers(m_queue, std::numeric_limits<size_t>::max());
        }
        {
            OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
            updateTextures(4);
            EXPECT_EQ(3, layer->fakeLayerTextureUpdater()->updateCount());
            EXPECT_TRUE(m_queue.hasMoreUpdates());
            layer->fakeLayerTextureUpdater()->clearUpdateCount();
            updateTextures(4);
            EXPECT_EQ(3, layer->fakeLayerTextureUpdater()->updateCount());
            EXPECT_FALSE(m_queue.hasMoreUpdates());
            layer->fakeLayerTextureUpdater()->clearUpdateCount();
            layer->pushPropertiesTo(layerImpl.get());
        }
        ccLayerTreeHost->commitComplete();

        // Partial update of 6 tiles.
        layer->invalidateContentRect(IntRect(50, 50, 200, 100));
        {
            OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
            {
                DebugScopedSetMainThread mainThread;
                ccLayerTreeHost->updateLayers(m_queue, std::numeric_limits<size_t>::max());
            }
            updateTextures(4);
            EXPECT_EQ(2, layer->fakeLayerTextureUpdater()->updateCount());
            EXPECT_TRUE(m_queue.hasMoreUpdates());
            layer->fakeLayerTextureUpdater()->clearUpdateCount();
            updateTextures(4);
            EXPECT_EQ(4, layer->fakeLayerTextureUpdater()->updateCount());
            EXPECT_FALSE(m_queue.hasMoreUpdates());
            layer->fakeLayerTextureUpdater()->clearUpdateCount();
            layer->pushPropertiesTo(layerImpl.get());
        }
        ccLayerTreeHost->commitComplete();

        // Checkerboard all tiles.
        layer->invalidateContentRect(IntRect(0, 0, 300, 200));
        {
            OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
            layer->pushPropertiesTo(layerImpl.get());
        }
        ccLayerTreeHost->commitComplete();

        // Partial update of 6 checkerboard tiles.
        layer->invalidateContentRect(IntRect(50, 50, 200, 100));
        {
            OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
            {
                DebugScopedSetMainThread mainThread;
                ccLayerTreeHost->updateLayers(m_queue, std::numeric_limits<size_t>::max());
            }
            updateTextures(4);
            EXPECT_EQ(4, layer->fakeLayerTextureUpdater()->updateCount());
            EXPECT_TRUE(m_queue.hasMoreUpdates());
            layer->fakeLayerTextureUpdater()->clearUpdateCount();
            updateTextures(4);
            EXPECT_EQ(2, layer->fakeLayerTextureUpdater()->updateCount());
            EXPECT_FALSE(m_queue.hasMoreUpdates());
            layer->fakeLayerTextureUpdater()->clearUpdateCount();
            layer->pushPropertiesTo(layerImpl.get());
        }
        ccLayerTreeHost->commitComplete();

        // Partial update of 4 tiles.
        layer->invalidateContentRect(IntRect(50, 50, 100, 100));
        {
            OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
            {
                DebugScopedSetMainThread mainThread;
                ccLayerTreeHost->updateLayers(m_queue, std::numeric_limits<size_t>::max());
            }
            updateTextures(4);
            EXPECT_EQ(4, layer->fakeLayerTextureUpdater()->updateCount());
            EXPECT_FALSE(m_queue.hasMoreUpdates());
            layer->fakeLayerTextureUpdater()->clearUpdateCount();
            layer->pushPropertiesTo(layerImpl.get());
        }
        ccLayerTreeHost->commitComplete();
        ccLayerTreeHost->contentsTextureManager()->clearAllMemory(m_resourceProvider.get());
    }
    ccLayerTreeHost->setRootLayer(0);
    ccLayerTreeHost.clear();
    WebKit::WebCompositor::shutdown();
}

TEST_F(TiledLayerChromiumTest, tilesPaintedWithoutOcclusion)
{
    DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
    RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));

    // The tile size is 100x100, so this invalidates and then paints two tiles.

    layer->setVisibleContentRect(IntRect(0, 0, 100, 200));
    layer->invalidateContentRect(IntRect(0, 0, 100, 200));


    setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
    updateLayerOnMainThread(layer.get(), 0);
    EXPECT_EQ(2, layer->fakeLayerTextureUpdater()->prepareRectCount());
}

TEST_F(TiledLayerChromiumTest, tilesPaintedWithOcclusion)
{
    DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
    RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
    TestCCOcclusionTracker occluded;


    layer->setVisibleContentRect(IntRect(IntPoint(), layer->contentBounds()));
    layer->invalidateContentRect(IntRect(0, 0, 600, 600));

    setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
    updateLayerOnMainThread(layer.get(), &occluded);
    layer->update(m_queue, &occluded, m_stats);
    EXPECT_EQ(36-3, layer->fakeLayerTextureUpdater()->prepareRectCount());

    EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);

    EXPECT_EQ(3, occluded.overdrawMetrics().tilesCulledForUpload());

    layer->fakeLayerTextureUpdater()->clearPrepareRectCount();
    setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
    m_textureManager->prioritizeTextures();

    occluded.setOcclusion(IntRect(250, 200, 300, 100));
    layer->invalidateContentRect(IntRect(0, 0, 600, 600));
    updateLayerOnMainThread(layer.get(), &occluded);
    EXPECT_EQ(36-2, layer->fakeLayerTextureUpdater()->prepareRectCount());

    EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);

    EXPECT_EQ(3 + 2, occluded.overdrawMetrics().tilesCulledForUpload());

    layer->fakeLayerTextureUpdater()->clearPrepareRectCount();
    setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
    m_textureManager->prioritizeTextures();

    occluded.setOcclusion(IntRect(250, 250, 300, 100));
    layer->invalidateContentRect(IntRect(0, 0, 600, 600));
    updateLayerOnMainThread(layer.get(), &occluded);
    EXPECT_EQ(36, layer->fakeLayerTextureUpdater()->prepareRectCount());

    EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);


TEST_F(TiledLayerChromiumTest, tilesPaintedWithOcclusionAndVisiblityConstraints)
{
    DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
    RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
    TestCCOcclusionTracker occluded;


    layer->setVisibleContentRect(IntRect(0, 0, 600, 360));
    layer->invalidateContentRect(IntRect(0, 0, 600, 600));

    setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
    updateLayerOnMainThread(layer.get(), &occluded);
    layer->update(m_queue, &occluded, m_stats);
    EXPECT_EQ(24-3, layer->fakeLayerTextureUpdater()->prepareRectCount());

    EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);

    layer->setDrawableContentRect(IntRect(0, 0, 600, 350));
    layer->setVisibleContentRect(IntRect(0, 0, 600, 350));
    layer->invalidateContentRect(IntRect(0, 0, 600, 600));
    setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
    updateLayerOnMainThread(layer.get(), &occluded);
    layer->update(m_queue, &occluded, m_stats);
    EXPECT_EQ(24-6, layer->fakeLayerTextureUpdater()->prepareRectCount());

    EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);

    layer->setDrawableContentRect(IntRect(0, 0, 600, 340));
    layer->setVisibleContentRect(IntRect(0, 0, 600, 340));
    layer->invalidateContentRect(IntRect(0, 0, 600, 600));
    setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
    updateLayerOnMainThread(layer.get(), &occluded);
    layer->update(m_queue, &occluded, m_stats);
    EXPECT_EQ(24-6, layer->fakeLayerTextureUpdater()->prepareRectCount());

    EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);


TEST_F(TiledLayerChromiumTest, tilesNotPaintedWithoutInvalidation)
{
    DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
    RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
    TestCCOcclusionTracker occluded;


    layer->setDrawableContentRect(IntRect(0, 0, 600, 600));
    layer->setVisibleContentRect(IntRect(0, 0, 600, 600));
    layer->invalidateContentRect(IntRect(0, 0, 600, 600));
    setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
    updateLayerOnMainThread(layer.get(), &occluded);
    layer->update(m_queue, &occluded, m_stats);
    EXPECT_EQ(36-3, layer->fakeLayerTextureUpdater()->prepareRectCount());
    updateTextures();
        DebugScopedSetImplThread implThread;
        updateTextures();
    }

    EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
    EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 330000, 1);
    EXPECT_EQ(3, occluded.overdrawMetrics().tilesCulledForUpload());

    layer->fakeLayerTextureUpdater()->clearPrepareRectCount();
    setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
    m_textureManager->prioritizeTextures();

    // Repaint without marking it dirty. The 3 culled tiles will be pre-painted now.
    updateLayerOnMainThread(layer.get(), &occluded);
    EXPECT_EQ(3, layer->fakeLayerTextureUpdater()->prepareRectCount());

    EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);


TEST_F(TiledLayerChromiumTest, tilesPaintedWithOcclusionAndTransforms)
{
    DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
    RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
    TestCCOcclusionTracker occluded;


    layer->setDrawableContentRect(IntRect(IntPoint(), layer->contentBounds()));
    layer->setVisibleContentRect(IntRect(IntPoint(), layer->contentBounds()));
    layer->invalidateContentRect(IntRect(0, 0, 600, 600));
    setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
    updateLayerOnMainThread(layer.get(), &occluded);
    layer->update(m_queue, &occluded, m_stats);
    EXPECT_EQ(36-3, layer->fakeLayerTextureUpdater()->prepareRectCount());

    EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);


TEST_F(TiledLayerChromiumTest, tilesPaintedWithOcclusionAndScaling)
{
    DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
    RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
    TestCCOcclusionTracker occluded;


    layer->setDrawableContentRect(IntRect(IntPoint(), layer->contentBounds()));
    layer->setVisibleContentRect(IntRect(IntPoint(), layer->contentBounds()));
    layer->invalidateContentRect(IntRect(0, 0, 600, 600));
    setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
    updateLayerOnMainThread(layer.get(), &occluded);
    layer->update(m_queue, &occluded, m_stats);
    // The content is half the size of the layer (so the number of tiles is fewer).
    // In this case, the content is 300x300, and since the tile size is 100, the
    // number of tiles 3x3.

    layer->setDrawableContentRect(IntRect(IntPoint(), layer->contentBounds()));
    layer->setVisibleContentRect(IntRect(IntPoint(), layer->contentBounds()));
    layer->invalidateContentRect(IntRect(0, 0, 600, 600));
    setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
    updateLayerOnMainThread(layer.get(), &occluded);
    layer->update(m_queue, &occluded, m_stats);
    EXPECT_EQ(9-1, layer->fakeLayerTextureUpdater()->prepareRectCount());

    EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);

    layer->setDrawableContentRect(IntRect(IntPoint(), layer->contentBounds()));
    layer->setVisibleContentRect(IntRect(IntPoint(), layer->contentBounds()));
    layer->invalidateContentRect(IntRect(0, 0, 600, 600));
    setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
    updateLayerOnMainThread(layer.get(), &occluded);
    layer->update(m_queue, &occluded, m_stats);
    EXPECT_EQ(9-1, layer->fakeLayerTextureUpdater()->prepareRectCount());

    EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);


TEST_F(TiledLayerChromiumTest, visibleContentOpaqueRegion)
{
    DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
    RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
    TestCCOcclusionTracker occluded;
    DebugScopedSetImplThread implThread;

    // The tile size is 100x100, so this invalidates and then paints two tiles in various ways.


    layer->setVisibleContentRect(visibleBounds);
    layer->setDrawOpacity(1);

    setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
    m_textureManager->prioritizeTextures();

    // If the layer doesn't paint opaque content, then the visibleContentOpaqueRegion should be empty.
    layer->fakeLayerTextureUpdater()->setOpaquePaintRect(IntRect());
    layer->invalidateContentRect(contentBounds);
    updateLayerOnMainThread(layer.get(), &occluded);
    opaqueContents = layer->visibleContentOpaqueRegion();
    EXPECT_TRUE(opaqueContents.isEmpty());


    opaquePaintRect = IntRect(10, 10, 90, 190);
    layer->fakeLayerTextureUpdater()->setOpaquePaintRect(opaquePaintRect);
    layer->invalidateContentRect(contentBounds);
    updateLayerOnMainThread(layer.get(), &occluded);
    updateTextures();
    opaqueContents = layer->visibleContentOpaqueRegion();
    EXPECT_EQ_RECT(intersection(opaquePaintRect, visibleBounds), opaqueContents.bounds());


    // If we paint again without invalidating, the same stuff should be opaque.
    layer->fakeLayerTextureUpdater()->setOpaquePaintRect(IntRect());
    updateLayerOnMainThread(layer.get(), &occluded);
    updateTextures();
    opaqueContents = layer->visibleContentOpaqueRegion();
    EXPECT_EQ_RECT(intersection(opaquePaintRect, visibleBounds), opaqueContents.bounds());

    // not be affected.
    layer->fakeLayerTextureUpdater()->setOpaquePaintRect(IntRect());
    layer->invalidateContentRect(IntRect(0, 0, 1, 1));
    updateLayerOnMainThread(layer.get(), &occluded);
    updateTextures();
    opaqueContents = layer->visibleContentOpaqueRegion();
    EXPECT_EQ_RECT(intersection(opaquePaintRect, visibleBounds), opaqueContents.bounds());

    // not be affected.
    layer->fakeLayerTextureUpdater()->setOpaquePaintRect(IntRect());
    layer->invalidateContentRect(IntRect(10, 10, 1, 1));
    updateLayerOnMainThread(layer.get(), &occluded);
    updateTextures();
    opaqueContents = layer->visibleContentOpaqueRegion();
    EXPECT_EQ_RECT(intersection(IntRect(10, 100, 90, 100), visibleBounds), opaqueContents.bounds());


TEST_F(TiledLayerChromiumTest, pixelsPaintedMetrics)
{
    DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
    RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
    TestCCOcclusionTracker occluded;
    DebugScopedSetImplThread implThread;

    // The tile size is 100x100, so this invalidates and then paints two tiles in various ways.


    layer->setVisibleContentRect(visibleBounds);
    layer->setDrawOpacity(1);

    setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
    m_textureManager->prioritizeTextures();

    // Invalidates and paints the whole layer.
    layer->fakeLayerTextureUpdater()->setOpaquePaintRect(IntRect());
    layer->invalidateContentRect(contentBounds);
    updateLayerOnMainThread(layer.get(), &occluded);
    updateTextures();
    opaqueContents = layer->visibleContentOpaqueRegion();
    EXPECT_TRUE(opaqueContents.isEmpty());

    layer->fakeLayerTextureUpdater()->setOpaquePaintRect(IntRect());
    layer->invalidateContentRect(IntRect(0, 0, 1, 1));
    layer->invalidateContentRect(IntRect(50, 200, 10, 10));
    updateLayerOnMainThread(layer.get(), &occluded);
    updateTextures();
    opaqueContents = layer->visibleContentOpaqueRegion();
    EXPECT_TRUE(opaqueContents.isEmpty());


TEST_F(TiledLayerChromiumTest, dontAllocateContentsWhenTargetSurfaceCantBeAllocated)
{
    // Initialize without threading support.
    WebKit::WebCompositor::initialize(0);

    // Tile size is 100x100.
    IntRect rootRect(0, 0, 300, 200);
    IntRect childRect(0, 0, 300, 100);

    OwnPtr<CCLayerTreeHost> ccLayerTreeHost = CCLayerTreeHost::create(&fakeCCLayerTreeHostClient, settings);
    ASSERT_TRUE(ccLayerTreeHost->initializeRendererIfNeeded());

    RefPtr<FakeTiledLayerChromium> root = adoptRef(new FakeTiledLayerChromium(ccLayerTreeHost->contentsTextureManager()));
    RefPtr<LayerChromium> surface = LayerChromium::create();
    RefPtr<FakeTiledLayerChromium> child = adoptRef(new FakeTiledLayerChromium(ccLayerTreeHost->contentsTextureManager()));
    RefPtr<FakeTiledLayerChromium> child2 = adoptRef(new FakeTiledLayerChromium(ccLayerTreeHost->contentsTextureManager()));

    root->setBounds(rootRect.size());
    root->setAnchorPoint(FloatPoint());
    root->setDrawableContentRect(rootRect);
    root->setVisibleContentRect(rootRect);
    root->addChild(surface);

    surface->setForceRenderSurface(true);
    surface->setAnchorPoint(FloatPoint());
    surface->setOpacity(0.5);
    surface->addChild(child);
    surface->addChild(child2);

    child->setBounds(childRect.size());
    child->setAnchorPoint(FloatPoint());
    child->setPosition(childRect.location());
    child->setVisibleContentRect(childRect);
    child->setDrawableContentRect(rootRect);

    child2->setBounds(child2Rect.size());
    child2->setAnchorPoint(FloatPoint());
    child2->setPosition(child2Rect.location());
    child2->setVisibleContentRect(child2Rect);
    child2->setDrawableContentRect(rootRect);

    ccLayerTreeHost->setRootLayer(root);
    ccLayerTreeHost->setViewportSize(rootRect.size(), rootRect.size());

    // With a huge memory limit, all layers should update and push their textures.
    root->invalidateContentRect(rootRect);
    child->invalidateContentRect(childRect);
    child2->invalidateContentRect(child2Rect);
    ccLayerTreeHost->updateLayers(m_queue, std::numeric_limits<size_t>::max());
    {
        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
        RefPtr<FakeTiledLayerChromium> root = adoptRef(new FakeTiledLayerChromium(ccLayerTreeHost->contentsTextureManager()));
        RefPtr<LayerChromium> surface = LayerChromium::create();
        RefPtr<FakeTiledLayerChromium> child = adoptRef(new FakeTiledLayerChromium(ccLayerTreeHost->contentsTextureManager()));
        RefPtr<FakeTiledLayerChromium> child2 = adoptRef(new FakeTiledLayerChromium(ccLayerTreeHost->contentsTextureManager()));

        {
            DebugScopedSetMainThread mainThread;

            root->setBounds(rootRect.size());
            root->setAnchorPoint(FloatPoint());
            root->setDrawableContentRect(rootRect);
            root->setVisibleContentRect(rootRect);
            root->addChild(surface);

            surface->setForceRenderSurface(true);
            surface->setAnchorPoint(FloatPoint());
            surface->setOpacity(0.5);
            surface->addChild(child);
            surface->addChild(child2);

            child->setBounds(childRect.size());
            child->setAnchorPoint(FloatPoint());
            child->setPosition(childRect.location());
            child->setVisibleContentRect(childRect);
            child->setDrawableContentRect(rootRect);

            child2->setBounds(child2Rect.size());
            child2->setAnchorPoint(FloatPoint());
            child2->setPosition(child2Rect.location());
            child2->setVisibleContentRect(child2Rect);
            child2->setDrawableContentRect(rootRect);

            ccLayerTreeHost->setRootLayer(root);
            ccLayerTreeHost->setViewportSize(rootRect.size(), rootRect.size());

            // With a huge memory limit, all layers should update and push their textures.
            root->invalidateContentRect(rootRect);
            child->invalidateContentRect(childRect);
            child2->invalidateContentRect(child2Rect);
            ccLayerTreeHost->updateLayers(m_queue, std::numeric_limits<size_t>::max());
        }

        updateTextures(1000);
        EXPECT_EQ(6, root->fakeLayerTextureUpdater()->updateCount());
        EXPECT_EQ(3, child->fakeLayerTextureUpdater()->updateCount());

        child->fakeLayerTextureUpdater()->clearUpdateCount();
        child2->fakeLayerTextureUpdater()->clearUpdateCount();

        {
            OwnPtr<FakeCCTiledLayerImpl> rootImpl(adoptPtr(new FakeCCTiledLayerImpl(root->id())));
            OwnPtr<FakeCCTiledLayerImpl> childImpl(adoptPtr(new FakeCCTiledLayerImpl(child->id())));
            OwnPtr<FakeCCTiledLayerImpl> child2Impl(adoptPtr(new FakeCCTiledLayerImpl(child2->id())));
            root->pushPropertiesTo(rootImpl.get());
            child->pushPropertiesTo(childImpl.get());
            child2->pushPropertiesTo(child2Impl.get());

            for (unsigned i = 0; i < 3; ++i) {
                for (unsigned j = 0; j < 2; ++j)
                    EXPECT_TRUE(rootImpl->hasTextureIdForTileAt(i, j));
                EXPECT_TRUE(childImpl->hasTextureIdForTileAt(i, 0));
                EXPECT_TRUE(child2Impl->hasTextureIdForTileAt(i, 0));
            }
        }
        ccLayerTreeHost->commitComplete();

        // With a memory limit that includes only the root layer (3x2 tiles) and half the surface that
        // the child layers draw into, the child layers will not be allocated. If the surface isn't
        // accounted for, then one of the children would fit within the memory limit.
        {
            DebugScopedSetMainThread mainThread;
            root->invalidateContentRect(rootRect);
            child->invalidateContentRect(childRect);
            child2->invalidateContentRect(child2Rect);
            ccLayerTreeHost->updateLayers(m_queue, (3 * 2 + 3 * 1) * (100 * 100) * 4);
        }

        updateTextures(1000);
        EXPECT_EQ(6, root->fakeLayerTextureUpdater()->updateCount());
        EXPECT_EQ(0, child->fakeLayerTextureUpdater()->updateCount());

        child->fakeLayerTextureUpdater()->clearUpdateCount();
        child2->fakeLayerTextureUpdater()->clearUpdateCount();

        {
            OwnPtr<FakeCCTiledLayerImpl> rootImpl(adoptPtr(new FakeCCTiledLayerImpl(root->id())));
            OwnPtr<FakeCCTiledLayerImpl> childImpl(adoptPtr(new FakeCCTiledLayerImpl(child->id())));
            OwnPtr<FakeCCTiledLayerImpl> child2Impl(adoptPtr(new FakeCCTiledLayerImpl(child2->id())));
            root->pushPropertiesTo(rootImpl.get());
            child->pushPropertiesTo(childImpl.get());
            child2->pushPropertiesTo(child2Impl.get());

            for (unsigned i = 0; i < 3; ++i) {
                for (unsigned j = 0; j < 2; ++j)
                    EXPECT_TRUE(rootImpl->hasTextureIdForTileAt(i, j));
                EXPECT_FALSE(childImpl->hasTextureIdForTileAt(i, 0));
                EXPECT_FALSE(child2Impl->hasTextureIdForTileAt(i, 0));
            }
        }
        ccLayerTreeHost->commitComplete();

        // With a memory limit that includes only half the root layer, no contents will be
        // allocated. If render surface memory wasn't accounted for, there is enough space
        // for one of the children layers, but they draw into a surface that can't be
        // allocated.
        {
            DebugScopedSetMainThread mainThread;
            root->invalidateContentRect(rootRect);
            child->invalidateContentRect(childRect);
            child2->invalidateContentRect(child2Rect);
            ccLayerTreeHost->updateLayers(m_queue, (3 * 1) * (100 * 100) * 4);
        DebugScopedSetImplThread implThread;
        updateTextures(1000);
        EXPECT_EQ(0, root->fakeLayerTextureUpdater()->updateCount());
        EXPECT_EQ(0, child->fakeLayerTextureUpdater()->updateCount());
        EXPECT_EQ(0, child2->fakeLayerTextureUpdater()->updateCount());
        EXPECT_FALSE(m_queue.hasMoreUpdates());

        root->fakeLayerTextureUpdater()->clearUpdateCount();
        child->fakeLayerTextureUpdater()->clearUpdateCount();
        child2->fakeLayerTextureUpdater()->clearUpdateCount();

        OwnPtr<FakeCCTiledLayerImpl> rootImpl(adoptPtr(new FakeCCTiledLayerImpl(root->id())));
        OwnPtr<FakeCCTiledLayerImpl> childImpl(adoptPtr(new FakeCCTiledLayerImpl(child->id())));
        OwnPtr<FakeCCTiledLayerImpl> child2Impl(adoptPtr(new FakeCCTiledLayerImpl(child2->id())));
        root->pushPropertiesTo(rootImpl.get());
        child->pushPropertiesTo(childImpl.get());
        child2->pushPropertiesTo(child2Impl.get());

        for (unsigned i = 0; i < 3; ++i) {
            for (unsigned j = 0; j < 2; ++j)
                EXPECT_FALSE(rootImpl->hasTextureIdForTileAt(i, j));
            EXPECT_FALSE(childImpl->hasTextureIdForTileAt(i, 0));
            EXPECT_FALSE(child2Impl->hasTextureIdForTileAt(i, 0));
        }
        {
            updateTextures(1000);
            EXPECT_EQ(0, root->fakeLayerTextureUpdater()->updateCount());
            EXPECT_EQ(0, child->fakeLayerTextureUpdater()->updateCount());
            EXPECT_EQ(0, child2->fakeLayerTextureUpdater()->updateCount());
            EXPECT_FALSE(m_queue.hasMoreUpdates());

            root->fakeLayerTextureUpdater()->clearUpdateCount();
            child->fakeLayerTextureUpdater()->clearUpdateCount();
            child2->fakeLayerTextureUpdater()->clearUpdateCount();

            OwnPtr<FakeCCTiledLayerImpl> rootImpl(adoptPtr(new FakeCCTiledLayerImpl(root->id())));
            OwnPtr<FakeCCTiledLayerImpl> childImpl(adoptPtr(new FakeCCTiledLayerImpl(child->id())));
            OwnPtr<FakeCCTiledLayerImpl> child2Impl(adoptPtr(new FakeCCTiledLayerImpl(child2->id())));
            root->pushPropertiesTo(rootImpl.get());
            child->pushPropertiesTo(childImpl.get());
            child2->pushPropertiesTo(child2Impl.get());

            for (unsigned i = 0; i < 3; ++i) {
                for (unsigned j = 0; j < 2; ++j)
                    EXPECT_FALSE(rootImpl->hasTextureIdForTileAt(i, j));
                EXPECT_FALSE(childImpl->hasTextureIdForTileAt(i, 0));
                EXPECT_FALSE(child2Impl->hasTextureIdForTileAt(i, 0));
            }
        }
        ccLayerTreeHost->commitComplete();
        ccLayerTreeHost->contentsTextureManager()->clearAllMemory(m_resourceProvider.get());
    }
    ccLayerTreeHost->setRootLayer(0);
    ccLayerTreeHost.clear();
    WebKit::WebCompositor::shutdown();
}

class TrackingLayerPainter : public LayerPainterChromium {


TEST_F(TiledLayerChromiumTest, nonIntegerContentsScaleIsNotDistortedDuringPaint)
{
    DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
    RefPtr<UpdateTrackingTiledLayerChromium> layer = adoptRef(new UpdateTrackingTiledLayerChromium(m_textureManager.get()));

    IntRect layerRect(0, 0, 30, 31);

    layer->setVisibleContentRect(contentRect);
    layer->setDrawableContentRect(contentRect);

    setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
    m_textureManager->prioritizeTextures();

    // Update the whole tile.
    updateLayerOnMainThread(layer.get(), 0);
    layer->trackingLayerPainter()->resetPaintedRect();

    EXPECT_INT_RECT_EQ(IntRect(), layer->trackingLayerPainter()->paintedRect());

    updateTextures();
        DebugScopedSetImplThread implThread;
        updateTextures();
    }

    // Invalidate the entire layer in content space. When painting, the rect given to webkit should match the layer's bounds.
    layer->invalidateContentRect(contentRect);
    updateLayerOnMainThread(layer.get(), 0);

    EXPECT_INT_RECT_EQ(layerRect, layer->trackingLayerPainter()->paintedRect());
}

TEST_F(TiledLayerChromiumTest, nonIntegerContentsScaleIsNotDistortedDuringInvalidation)
{
    DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
    RefPtr<UpdateTrackingTiledLayerChromium> layer = adoptRef(new UpdateTrackingTiledLayerChromium(m_textureManager.get()));

    IntRect layerRect(0, 0, 30, 31);

    layer->setVisibleContentRect(contentRect);
    layer->setDrawableContentRect(contentRect);

    setTexturePrioritiesAndPrioritizeTexturesOnMainThread(layer.get());
    m_textureManager->prioritizeTextures();

    // Update the whole tile.
    updateLayerOnMainThread(layer.get(), 0);
    layer->trackingLayerPainter()->resetPaintedRect();

    EXPECT_INT_RECT_EQ(IntRect(), layer->trackingLayerPainter()->paintedRect());

    updateTextures();
        DebugScopedSetImplThread implThread;
        updateTextures();
    }

    // Invalidate the entire layer in layer space. When painting, the rect given to webkit should match the layer's bounds.
    layer->setNeedsDisplayRect(layerRect);
    updateLayerOnMainThread(layer.get(), 0);

    EXPECT_INT_RECT_EQ(layerRect, layer->trackingLayerPainter()->paintedRect());
}

Return to Bug 95057

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +110 lines
		1	2012-08-27 Christopher Cameron <ccameron@chromium.org>
		2
		3	[chromium] Allow impl-thread deletion of only some resources
		4	https://bugs.webkit.org/show_bug.cgi?id=95057
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Towards allowing the impl thread to delete just some resources (as
		9	opposed to deleting all resources).
		10
		11	Do impl-thread deletion through CCPrioritizedTextureManager instead of
		12	CCResourceProvider. In subsequent changes the impl thread will be able
		13	to set a threshold for what to delete). Put all state that can
		14	be concurrently accessed by the main and impl threads into a separate
		15	SharedState sub-class which has a mutex. Add a set of textures that
		16	have been deleted by the impl thread, but have not had their related
		17	structures clear by the main thread yet. Add helper functions to delete
		18	a backing's resource.
		19
		20	Allow multiple in-flight texture purges. In CCThreadProxy, make the
		21	acknowledgement of texture deletion be an integer counter instead of a
		22	bool, because we may have multiple in-flight purges. Remove many
		23	instances where texture purges were avoided when there was an
		24	outstanding text.
		25
		26	Add the ability to clear only the references to deleted textures from
		27	the texture upload queue.
		28
		29	Add assertions that resources be freed to CCPrioritizedTextureManager.
		30
		31	Add lots of asserts to CCPrioritizedTextureManager to ensure and
		32	illuminate supported multithreaded access.
		33
		34	Fix a dozen places where CCThreadProxy and CCSingleThreadProxy hold
		35	the main thread blocked, but don't notify the debug structures of
		36	this.
		37
		38	No new tests (OOPS!).
		39
		40	* platform/graphics/chromium/LayerTextureUpdater.h:
		41	(WebCore::LayerTextureUpdater::Texture::backingWasAsynchronouslyDeleted):
		42	* platform/graphics/chromium/cc/CCLayerTreeHost.cpp:
		43	(WebCore::CCLayerTreeHost::deleteContentsTexturesResourcesOnImplThread):
		44	(WebCore):
		45	(WebCore::CCLayerTreeHost::destroyTexturesDeletedByImplThread):
		46	* platform/graphics/chromium/cc/CCLayerTreeHost.h:
		47	(CCLayerTreeHost):
		48	* platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp:
		49	(WebCore::CCLayerTreeHostImpl::releaseContentsTextures):
		50	* platform/graphics/chromium/cc/CCLayerTreeHostImpl.h:
		51	(CCLayerTreeHostImplClient):
		52	(WebCore::CCLayerTreeHostImpl::setContentsTexturesPurged):
		53	(CCLayerTreeHostImpl):
		54	* platform/graphics/chromium/cc/CCPrioritizedTexture.cpp:
		55	(WebCore::CCPrioritizedTexture::upload):
		56	(WebCore::CCPrioritizedTexture::backingWasAsynchronouslyDeleted):
		57	(WebCore):
		58	* platform/graphics/chromium/cc/CCPrioritizedTexture.h:
		59	(CCPrioritizedTexture):
		60	(WebCore::CCPrioritizedTexture::Backing::Backing):
		61	(WebCore::CCPrioritizedTexture::Backing::~Backing):
		62	(Backing):
		63	(WebCore::CCPrioritizedTexture::Backing::owner):
		64	(WebCore::CCPrioritizedTexture::Backing::resourceDeleted):
65	* platform/graphics/chromium/cc/CCPrioritizedTextureManager.cpp:
66	(WebCore::CCPrioritizedTextureManager::~CCPrioritizedTextureManager):
67	(WebCore::CCPrioritizedTextureManager::prioritizeTextures):
68	(WebCore::CCPrioritizedTextureManager::requestLate):
69	(WebCore::CCPrioritizedTextureManager::acquireBackingTextureIfNeeded):
70	(WebCore::CCPrioritizedTextureManager::reduceMemory):
71	(WebCore::CCPrioritizedTextureManager::deleteBackingsResourcesOnImplThread):
72	(WebCore::CCPrioritizedTextureManager::destroyBackingsFreedByImplThread):
73	(WebCore):
74	(WebCore::CCPrioritizedTextureManager::clearAllMemory):
75	(WebCore::CCPrioritizedTextureManager::registerTexture):
76	(WebCore::CCPrioritizedTextureManager::returnBackingTexture):
77	(WebCore::CCPrioritizedTextureManager::createBacking):
78	(WebCore::CCPrioritizedTextureManager::destroyBacking):
79	(WebCore::CCPrioritizedTextureManager::assertInvariants):
80	* platform/graphics/chromium/cc/CCPrioritizedTextureManager.h:
81	(CCPrioritizedTextureManager):
82	* platform/graphics/chromium/cc/CCScheduler.cpp:
83	(WebCore::CCScheduler::beginFrameAborted):
84	* platform/graphics/chromium/cc/CCSingleThreadProxy.cpp:
85	(WebCore::CCSingleThreadProxy::recreateContext):
86	(WebCore::CCSingleThreadProxy::stop):
87	(WebCore::CCSingleThreadProxy::deleteContentsTexturesOnImplThread):
88	(WebCore):
89	(WebCore::CCSingleThreadProxy::commitAndComposite):
90	* platform/graphics/chromium/cc/CCSingleThreadProxy.h:
91	* platform/graphics/chromium/cc/CCTextureUpdateQueue.cpp:
92	(WebCore::CCTextureUpdateQueue::clearUploadsToDeletedResources):
93	(WebCore):
94	* platform/graphics/chromium/cc/CCTextureUpdateQueue.h:
95	(CCTextureUpdateQueue):
96	* platform/graphics/chromium/cc/CCThreadProxy.cpp:
97	(WebCore::CCThreadProxy::CCThreadProxy):
98	(WebCore::CCThreadProxy::deleteContentsTexturesOnImplThread):
99	(WebCore):
100	(WebCore::CCThreadProxy::scheduledActionBeginFrame):
101	(WebCore::CCThreadProxy::beginFrame):
102	(WebCore::CCThreadProxy::beginFrameCompleteOnImplThread):
103	(WebCore::CCThreadProxy::scheduledActionCommit):
104	(WebCore::CCThreadProxy::layerTreeHostClosedOnImplThread):
105	(WebCore::CCThreadProxy::recreateContextOnImplThread):
106	* platform/graphics/chromium/cc/CCThreadProxy.h:
107	(WebCore::CCThreadProxy::BeginFrameAndCommitState::BeginFrameAndCommitState):
108	(BeginFrameAndCommitState):
109	(CCThreadProxy):
110
1	2012-08-24 Robert Kroeger <rjkroege@chromium.org>	111	2012-08-24 Robert Kroeger <rjkroege@chromium.org>
2		112
3	[chromium] CCLayerTreeHostImpl::scrollBy always assumes screen space deltas	113	[chromium] CCLayerTreeHostImpl::scrollBy always assumes screen space deltas

Lines 1-3 a/Source/WebKit/chromium/ChangeLog_sec1
- a/Source/WebKit/chromium/ChangeLog +22 lines
		1	2012-08-27 Christopher Cameron <ccameron@chromium.org>
		2
		3	[chromium] Allow impl-thread deletion of only some resources
		4	https://bugs.webkit.org/show_bug.cgi?id=95057
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	In CCLayerTreeHostImplTest, remove the test
		9	releaseContentsTextureShouldTriggerCommit because it is no longer valid
		10	and is redundant. A releaseContentsTexture will only trigger a commit
		11	if the releaseContentsTexture actually deletes any textures, and
		12	CCLayerTreeHostTestEvictTextures already tests that the commit is
		13	issued upon eviction.
		14
		15	Update TiledLayerChromiumTest to adhere to threading requirements and
		16	not leak resources.
		17
		18	Update CCPrioritizedTextureTest to adhere to threading requirments.
		19
		20	* tests/CCLayerTreeHostImplTest.cpp:
		21	* tests/TiledLayerChromiumTest.cpp:
		22
1	2012-08-24 Cris Neckar <cdn@chromium.org>	23	2012-08-24 Cris Neckar <cdn@chromium.org>
2		24
3	Plumb consumeUserGesture() to the chromium platform layer.	25	Plumb consumeUserGesture() to the chromium platform layer.

Lines 192-204 CCLayerTreeHost::RecreateResult CCLayerTreeHost::recreateContext() a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp_sec1
- a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp -3 / +11 lines
192	return RecreateFailedAndGaveUp;	192	return RecreateFailedAndGaveUp;
193	}	193	}
194		194
195	void CCLayerTreeHost::deleteContentsTexturesOnImplThread(CCResourceProvider* resourceProvider)	195	void CCLayerTreeHost::deleteAllContentsTexturesOnImplThread(CCResourceProvider* resourceProvider)
196	{	196	{
197	ASSERT(CCProxy::isImplThread());	197	ASSERT(CCProxy::isImplThread());
198	if (m_rendererInitialized)	198	if (m_rendererInitialized)
199	m_contentsTextureManager->clearAllMemory(resourceProvider);	199	m_contentsTextureManager->clearAllMemory(resourceProvider);
200	}	200	}
201		201
		202	bool CCLayerTreeHost::reduceContentsTexturesMemoryOnImplThread(CCResourceProvider* resourceProvider)
		203	{
		204	ASSERT(CCProxy::isImplThread());
		205	return m_contentsTextureManager->reduceMemoryOnImplThreadAsync(resourceProvider);
		206	return false;
		207	}
		208
202	void CCLayerTreeHost::acquireLayerTextures()	209	void CCLayerTreeHost::acquireLayerTextures()
203	{	210	{
204	ASSERT(CCProxy::isMainThread());	211	ASSERT(CCProxy::isMainThread());
Lines 411-421 void CCLayerTreeHost::setVisible(bool visible) a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp_sec2
411	m_proxy->setVisible(visible);	418	m_proxy->setVisible(visible);
412	}	419	}
413		420
414	void CCLayerTreeHost::evictAllContentTextures()	421
		422	void CCLayerTreeHost::destroyContentsTexturesEvictedByImplThread()
415	{	423	{
416	ASSERT(CCProxy::isMainThread());	424	ASSERT(CCProxy::isMainThread());
417	ASSERT(m_contentsTextureManager.get());	425	ASSERT(m_contentsTextureManager.get());
418	m_contentsTextureManager->allBackingTexturesWereDeleted();	426	m_contentsTextureManager->destroyBackingsAsynchronouslyEvicted();
419	}	427	}
420		428
421	void CCLayerTreeHost::startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, double durationSec)	429	void CCLayerTreeHost::startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, double durationSec)

Lines 175-181 public: a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.h_sec1
- a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.h -6 / +10 lines
175	RecreateResult recreateContext();	175	RecreateResult recreateContext();
176	void didCommitAndDrawFrame() { m_client->didCommitAndDrawFrame(); }	176	void didCommitAndDrawFrame() { m_client->didCommitAndDrawFrame(); }
177	void didCompleteSwapBuffers() { m_client->didCompleteSwapBuffers(); }	177	void didCompleteSwapBuffers() { m_client->didCompleteSwapBuffers(); }
178	void deleteContentsTexturesOnImplThread(CCResourceProvider*);
179	virtual void acquireLayerTextures();	178	virtual void acquireLayerTextures();
180	// Returns false if we should abort this frame due to initialization failure.	179	// Returns false if we should abort this frame due to initialization failure.
181	bool initializeRendererIfNeeded();	180	bool initializeRendererIfNeeded();
Lines 233-243 public: a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.h_sec2
233		232
234	CCPrioritizedTextureManager* contentsTextureManager() const;	233	CCPrioritizedTextureManager* contentsTextureManager() const;
235		234
236	// This will cause contents texture manager to evict all textures, but	235	void deleteAllContentsTexturesOnImplThread(CCResourceProvider*);
237	// without deleting them. This happens after all content textures have	236
238	// already been deleted on impl, after getting a 0 allocation limit.	237	// This will cause contents texture manager to free some resources used
239	// Set during a commit, but before updateLayers.	238	// by textures, but will not delete the texture backings objects. The
240	void evictAllContentTextures();	239	// function returns true if some resources were indeed destroyed.
		240	bool reduceContentsTexturesMemoryOnImplThread(CCResourceProvider*);
		241
		242	// This will destroy the backings that had their GPU resources freed
		243	// by deleteContentsTexturesResourcesOnImplThread.
		244	void destroyContentsTexturesEvictedByImplThread();
241		245
242	bool visible() const { return m_visible; }	246	bool visible() const { return m_visible; }
243	void setVisible(bool);	247	void setVisible(bool);

Lines 525-535 bool CCLayerTreeHostImpl::prepareToDraw(FrameData& frame) a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp_sec1
- a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp -5 / +1 lines
525		525
526	void CCLayerTreeHostImpl::releaseContentsTextures()	526	void CCLayerTreeHostImpl::releaseContentsTextures()
527	{	527	{
528	if (m_contentsTexturesPurged)	528	m_client->reduceContentsTexturesMemoryOnImplThread();
529	return;
530	m_resourceProvider->deleteOwnedResources(CCRenderer::ContentPool);
531	m_contentsTexturesPurged = true;
532	m_client->setNeedsCommitOnImplThread();
533	}	529	}
534		530
535	void CCLayerTreeHostImpl::setMemoryAllocationLimitBytes(size_t bytes)	531	void CCLayerTreeHostImpl::setMemoryAllocationLimitBytes(size_t bytes)

Lines 28-33 a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTextureManager.cpp_sec1
- a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTextureManager.cpp -28 / +96 lines
28		28
29	#include "CCPrioritizedTexture.h"	29	#include "CCPrioritizedTexture.h"
30	#include "CCPriorityCalculator.h"	30	#include "CCPriorityCalculator.h"
		31	#include "CCProxy.h"
31	#include "TraceEvent.h"	32	#include "TraceEvent.h"
32	#include <algorithm>	33	#include <algorithm>
33		34
Lines 49-63 CCPrioritizedTextureManager::~CCPrioritizedTextureManager() a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTextureManager.cpp_sec2
49	while (m_textures.size() > 0)	50	while (m_textures.size() > 0)
50	unregisterTexture(*m_textures.begin());	51	unregisterTexture(*m_textures.begin());
51		52
52	// Each remaining backing is a leaked opengl texture. We don't have the resourceProvider	53	// Remove any backings that were evicted.
53	// to delete the textures at this time so clearMemory() needs to be called before this.	54	clearEvictedBackings();
54	while (m_backings.size() > 0)	55
55	destroyBacking(*m_backings.begin(), 0);	56	// Each remaining backing is real memory leak. This shouldn't happen.
		57	ASSERT(m_backings.isEmpty());
56	}	58	}
57		59
58	void CCPrioritizedTextureManager::prioritizeTextures()	60	void CCPrioritizedTextureManager::prioritizeTextures()
59	{	61	{
60	TRACE_EVENT0("cc", "CCPrioritizedTextureManager::prioritizeTextures");	62	TRACE_EVENT0("cc", "CCPrioritizedTextureManager::prioritizeTextures");
		63	ASSERT(CCProxy::isMainThread());
61		64
62	#if !ASSERT_DISABLED	65	#if !ASSERT_DISABLED
63	assertInvariants();	66	assertInvariants();
Lines 137-142 void CCPrioritizedTextureManager::prioritizeTextures() a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTextureManager.cpp_sec3
137		140
138	void CCPrioritizedTextureManager::clearPriorities()	141	void CCPrioritizedTextureManager::clearPriorities()
139	{	142	{
		143	ASSERT(CCProxy::isMainThread());
140	for (TextureSet::iterator it = m_textures.begin(); it != m_textures.end(); ++it) {	144	for (TextureSet::iterator it = m_textures.begin(); it != m_textures.end(); ++it) {
141	// FIXME: We should remove this and just set all priorities to	145	// FIXME: We should remove this and just set all priorities to
142	// CCPriorityCalculator::lowestPriority() once we have priorities	146	// CCPriorityCalculator::lowestPriority() once we have priorities
Lines 148-153 void CCPrioritizedTextureManager::clearPriorities() a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTextureManager.cpp_sec4
148		152
149	bool CCPrioritizedTextureManager::requestLate(CCPrioritizedTexture* texture)	153	bool CCPrioritizedTextureManager::requestLate(CCPrioritizedTexture* texture)
150	{	154	{
		155	ASSERT(CCProxy::isMainThread());
		156
151	// This is already above cutoff, so don't double count it's memory below.	157	// This is already above cutoff, so don't double count it's memory below.
152	if (texture->isAbovePriorityCutoff())	158	if (texture->isAbovePriorityCutoff())
153	return true;	159	return true;
Lines 170-175 bool CCPrioritizedTextureManager::requestLate(CCPrioritizedTexture* texture) a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTextureManager.cpp_sec5
170		176
171	void CCPrioritizedTextureManager::acquireBackingTextureIfNeeded(CCPrioritizedTexture* texture, CCResourceProvider* resourceProvider)	177	void CCPrioritizedTextureManager::acquireBackingTextureIfNeeded(CCPrioritizedTexture* texture, CCResourceProvider* resourceProvider)
172	{	178	{
		179	ASSERT(CCProxy::isImplThread() && CCProxy::isMainThreadBlocked());
		180	ASSERT(resourceProvider);
173	ASSERT(!texture->isSelfManaged());	181	ASSERT(!texture->isSelfManaged());
174	ASSERT(texture->isAbovePriorityCutoff());	182	ASSERT(texture->isAbovePriorityCutoff());
175	if (texture->backing() \|\| !texture->isAbovePriorityCutoff())	183	if (texture->backing() \|\| !texture->isAbovePriorityCutoff())
Lines 204-223 void CCPrioritizedTextureManager::acquireBackingTextureIfNeeded(CCPrioritizedTex a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTextureManager.cpp_sec6
204		212
205	void CCPrioritizedTextureManager::reduceMemory(size_t limitBytes, CCResourceProvider* resourceProvider)	213	void CCPrioritizedTextureManager::reduceMemory(size_t limitBytes, CCResourceProvider* resourceProvider)
206	{	214	{
		215	ASSERT(CCProxy::isImplThread() && CCProxy::isMainThreadBlocked());
		216	ASSERT(resourceProvider);
207	if (memoryUseBytes() <= limitBytes)	217	if (memoryUseBytes() <= limitBytes)
208	return;	218	return;
209	// Destroy backings until we are below the limit,	219	// Destroy backings until we are below the limit,
210	// or until all backings remaining are above the cutoff.	220	// or until all backings remaining are above the cutoff.
211	while (memoryUseBytes() > limitBytes && m_backings.size() > 0) {	221	while (memoryUseBytes() > limitBytes && m_backings.size() > 0) {
212	BackingSet::iterator it = m_backings.begin();	222	CCPrioritizedTexture::Backing* backing = *m_backings.begin();
213	if ((it)->owner() && (it)->owner()->isAbovePriorityCutoff())	223	if (backing->owner() && backing->owner()->isAbovePriorityCutoff())
214	break;	224	break;
215	destroyBacking((*it), resourceProvider);	225	m_sharedState.removeBackingOnImplThread(backing);
		226	if (!backing->resourceDeleted())
		227	backing->deleteResource(resourceProvider);
		228	destroyBacking(backing);
216	}	229	}
217	}	230	}
218		231
219	void CCPrioritizedTextureManager::reduceMemory(CCResourceProvider* resourceProvider)	232	void CCPrioritizedTextureManager::reduceMemory(CCResourceProvider* resourceProvider)
220	{	233	{
		234	ASSERT(CCProxy::isImplThread() && CCProxy::isMainThreadBlocked());
221	reduceMemory(m_memoryAvailableBytes, resourceProvider);	235	reduceMemory(m_memoryAvailableBytes, resourceProvider);
222	ASSERT(memoryUseBytes() <= maxMemoryLimitBytes());	236	ASSERT(memoryUseBytes() <= maxMemoryLimitBytes());
223		237
Lines 238-264 void CCPrioritizedTextureManager::reduceMemory(CCResourceProvider* resourceProvi a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTextureManager.cpp_sec7
238	reduceMemory(memoryUseBytes() - (wastedMemory - tenPercentOfMemory), resourceProvider);	252	reduceMemory(memoryUseBytes() - (wastedMemory - tenPercentOfMemory), resourceProvider);
239	}	253	}
240		254
241	void CCPrioritizedTextureManager::clearAllMemory(CCResourceProvider* resourceProvider)	255	bool CCPrioritizedTextureManager::reduceMemoryOnImplThreadAsync(CCResourceProvider* resourceProvider)
242	{	256	{
243	// Unlink and destroy all backing textures.	257	ASSERT(CCProxy::isImplThread());
244	while (m_backings.size() > 0) {	258	ASSERT(resourceProvider);
245	BackingSet::iterator it = m_backings.begin();	259	return m_sharedState.evictBackingsResourcesOnImplThreadAsync(resourceProvider);
246	if ((*it)->owner())
247	(*it)->owner()->unlink();
248	destroyBacking((*it), resourceProvider);
249	}
250	}	260	}
251		261
252	void CCPrioritizedTextureManager::allBackingTexturesWereDeleted()	262	void CCPrioritizedTextureManager::destroyBackingsAsynchronouslyEvicted()
253	{	263	{
254	// Same as clearAllMemory, except all our textures were already	264	ASSERT(CCProxy::isMainThread());
255	// deleted externally, so we don't delete them. Passing no	265	clearEvictedBackings();
256	// resourceProvider results in leaking the (now invalid) texture ids.	266	}
257	clearAllMemory(0);	267
		268	void CCPrioritizedTextureManager::clearEvictedBackings()
		269	{
		270	BackingSet evictedBackings;
		271	m_sharedState.getAndClearEvictedBackings(evictedBackings);
		272	for (BackingSet::iterator it = evictedBackings.begin(); it != evictedBackings.end(); ++it)
		273	destroyBacking((*it));
		274	}
		275
		276	void CCPrioritizedTextureManager::clearAllMemory(CCResourceProvider* resourceProvider)
		277	{
		278	ASSERT(CCProxy::isImplThread() && CCProxy::isMainThreadBlocked());
		279	ASSERT(resourceProvider);
		280	reduceMemoryOnImplThreadAsync(resourceProvider);
		281	clearEvictedBackings();
258	}	282	}
259		283
260	void CCPrioritizedTextureManager::registerTexture(CCPrioritizedTexture* texture)	284	void CCPrioritizedTextureManager::registerTexture(CCPrioritizedTexture* texture)
261	{	285	{
		286	ASSERT(CCProxy::isMainThread());
262	ASSERT(texture);	287	ASSERT(texture);
263	ASSERT(!texture->textureManager());	288	ASSERT(!texture->textureManager());
264	ASSERT(!texture->backing());	289	ASSERT(!texture->backing());
Lines 266-276 void CCPrioritizedTextureManager::registerTexture(CCPrioritizedTexture* texture) a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTextureManager.cpp_sec8
266		291
267	texture->setManagerInternal(this);	292	texture->setManagerInternal(this);
268	m_textures.add(texture);	293	m_textures.add(texture);
269
270	}	294	}
271		295
272	void CCPrioritizedTextureManager::unregisterTexture(CCPrioritizedTexture* texture)	296	void CCPrioritizedTextureManager::unregisterTexture(CCPrioritizedTexture* texture)
273	{	297	{
		298	ASSERT(CCProxy::isMainThread() \|\| (CCProxy::isImplThread() && CCProxy::isMainThreadBlocked()));
274	ASSERT(texture);	299	ASSERT(texture);
275	ASSERT(m_textures.find(texture) != m_textures.end());	300	ASSERT(m_textures.find(texture) != m_textures.end());
276		301
Lines 280-288 void CCPrioritizedTextureManager::unregisterTexture(CCPrioritizedTexture* textur a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTextureManager.cpp_sec9
280	texture->setAbovePriorityCutoff(false);	305	texture->setAbovePriorityCutoff(false);
281	}	306	}
282		307
283
284	void CCPrioritizedTextureManager::returnBackingTexture(CCPrioritizedTexture* texture)	308	void CCPrioritizedTextureManager::returnBackingTexture(CCPrioritizedTexture* texture)
285	{	309	{
		310	ASSERT(CCProxy::isMainThread() \|\| (CCProxy::isImplThread() && CCProxy::isMainThreadBlocked()));
286	if (texture->backing()) {	311	if (texture->backing()) {
287	// Move the backing texture to the front for eviction/recycling and unlink it.	312	// Move the backing texture to the front for eviction/recycling and unlink it.
288	m_backings.remove(texture->backing());	313	m_backings.remove(texture->backing());
Lines 293-317 void CCPrioritizedTextureManager::returnBackingTexture(CCPrioritizedTexture* tex a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTextureManager.cpp_sec10
293		318
294	CCPrioritizedTexture::Backing* CCPrioritizedTextureManager::createBacking(IntSize size, GC3Denum format, CCResourceProvider* resourceProvider)	319	CCPrioritizedTexture::Backing* CCPrioritizedTextureManager::createBacking(IntSize size, GC3Denum format, CCResourceProvider* resourceProvider)
295	{	320	{
		321	ASSERT(CCProxy::isImplThread() && CCProxy::isMainThreadBlocked());
296	ASSERT(resourceProvider);	322	ASSERT(resourceProvider);
297
298	CCResourceProvider::ResourceId resourceId = resourceProvider->createResource(m_pool, size, format, CCResourceProvider::TextureUsageAny);	323	CCResourceProvider::ResourceId resourceId = resourceProvider->createResource(m_pool, size, format, CCResourceProvider::TextureUsageAny);
299	CCPrioritizedTexture::Backing* backing = new CCPrioritizedTexture::Backing(resourceId, size, format);	324	CCPrioritizedTexture::Backing* backing = new CCPrioritizedTexture::Backing(resourceId, size, format);
300	m_memoryUseBytes += backing->bytes();	325	m_memoryUseBytes += backing->bytes();
301	// Put backing texture at the front for eviction, since it isn't in use yet.	326	// Put backing texture at the front for eviction, since it isn't in use yet.
302	m_backings.insertBefore(m_backings.begin(), backing);	327	m_backings.insertBefore(m_backings.begin(), backing);
		328	m_sharedState.addBackingOnImplThread(backing);
303	return backing;	329	return backing;
304	}	330	}
305		331
306	void CCPrioritizedTextureManager::destroyBacking(CCPrioritizedTexture::Backing* backing, CCResourceProvider* resourceProvider)	332	void CCPrioritizedTextureManager::destroyBacking(CCPrioritizedTexture::Backing* backing)
307	{	333	{
308	ASSERT(backing);	334	ASSERT(backing);
309	ASSERT(!backing->owner() \|\| !backing->owner()->isAbovePriorityCutoff());
310	ASSERT(!backing->owner() \|\| !backing->owner()->isSelfManaged());	335	ASSERT(!backing->owner() \|\| !backing->owner()->isSelfManaged());
311	ASSERT(m_backings.find(backing) != m_backings.end());	336	ASSERT(m_backings.find(backing) != m_backings.end());
312		337
313	if (resourceProvider)
314	resourceProvider->deleteResource(backing->id());
315	if (backing->owner())	338	if (backing->owner())
316	backing->owner()->unlink();	339	backing->owner()->unlink();
317	m_memoryUseBytes -= backing->bytes();	340	m_memoryUseBytes -= backing->bytes();
Lines 320-329 void CCPrioritizedTextureManager::destroyBacking(CCPrioritizedTexture::Backing* a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTextureManager.cpp_sec11
320	delete backing;	343	delete backing;
321	}	344	}
322		345
323
324	#if !ASSERT_DISABLED	346	#if !ASSERT_DISABLED
325	void CCPrioritizedTextureManager::assertInvariants()	347	void CCPrioritizedTextureManager::assertInvariants()
326	{	348	{
		349	ASSERT(CCProxy::isMainThread());
		350
327	// If we hit any of these asserts, there is a bug in this class. To see	351	// If we hit any of these asserts, there is a bug in this class. To see
328	// where the bug is, call this function at the beginning and end of	352	// where the bug is, call this function at the beginning and end of
329	// every public function.	353	// every public function.
Lines 355-359 void CCPrioritizedTextureManager::assertInvariants() a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTextureManager.cpp_sec12
355	}	379	}
356	#endif	380	#endif
357		381
		382	CCPrioritizedTextureManager::SharedState::~SharedState()
		383	{
		384	ASSERT(m_evictedBackings.isEmpty());
		385	ASSERT(m_unevictedBackings.isEmpty());
		386	}
		387
		388	void CCPrioritizedTextureManager::SharedState::addBackingOnImplThread(CCPrioritizedTexture::Backing* backing)
		389	{
		390	ASSERT(CCProxy::isImplThread() && CCProxy::isMainThreadBlocked());
		391	m_unevictedBackings.add(backing);
		392	}
		393
		394	void CCPrioritizedTextureManager::SharedState::removeBackingOnImplThread(CCPrioritizedTexture::Backing* backing)
		395	{
		396	ASSERT(CCProxy::isImplThread() && CCProxy::isMainThreadBlocked());
		397	if (backing->resourceDeleted()) {
		398	ASSERT(m_evictedBackings.find(backing) != m_evictedBackings.end());
		399	m_evictedBackings.remove(backing);
		400	} else {
		401	ASSERT(m_unevictedBackings.find(backing) != m_unevictedBackings.end());
		402	m_unevictedBackings.remove(backing);
		403	}
		404	}
		405
		406	bool CCPrioritizedTextureManager::SharedState::evictBackingsResourcesOnImplThreadAsync(CCResourceProvider* resourceProvider)
		407	{
		408	bool result = false;
		409	ASSERT(CCProxy::isImplThread());
		410	MutexLocker lock(m_mutex);
		411	for (BackingSet::iterator it = m_unevictedBackings.begin(); it != m_unevictedBackings.end(); ++it) {
		412	result = true;
		413	(*it)->deleteResource(resourceProvider);
		414	m_evictedBackings.add((*it));
		415	}
		416	m_unevictedBackings.clear();
		417	return result;
		418	}
		419
		420	void CCPrioritizedTextureManager::SharedState::getAndClearEvictedBackings(BackingSet& evictedBackings)
		421	{
		422	evictedBackings.clear();
		423	MutexLocker lock(m_mutex);
		424	evictedBackings.swap(m_evictedBackings);
		425	}
358		426
359	} // namespace WebCore	427	} // namespace WebCore

Lines 33-38 a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTextureManager.h_sec1
- a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTextureManager.h -4 / +44 lines
33	#include "IntSize.h"	33	#include "IntSize.h"
34	#include <wtf/HashSet.h>	34	#include <wtf/HashSet.h>
35	#include <wtf/ListHashSet.h>	35	#include <wtf/ListHashSet.h>
		36	#include <wtf/ThreadingPrimitives.h>
36	#include <wtf/Vector.h>	37	#include <wtf/Vector.h>
37		38
38	namespace WebCore {	39	namespace WebCore {
Lines 77-84 public: a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTextureManager.h_sec2
77	bool requestLate(CCPrioritizedTexture*);	78	bool requestLate(CCPrioritizedTexture*);
78		79
79	void reduceMemory(CCResourceProvider*);	80	void reduceMemory(CCResourceProvider*);
		81
		82	// Returns true if resources are deleted as a result of this call.
		83	// This can be called concurrently with the main thread accessing this
		84	// structure, and only touches data in the quarantined m_sharedState.
		85	bool reduceMemoryOnImplThreadAsync(CCResourceProvider*);
		86
		87	// Remove the backings whose resources were destroyed by
		88	// reduceMemoryOnImplThreadAsync
		89	void destroyBackingsAsynchronouslyEvicted();
		90
		91	// Delete all textures and frm the impl thread (at thread exit and
		92	// context lost).
80	void clearAllMemory(CCResourceProvider*);	93	void clearAllMemory(CCResourceProvider*);
81	void allBackingTexturesWereDeleted();
82		94
83	void acquireBackingTextureIfNeeded(CCPrioritizedTexture, CCResourceProvider);	95	void acquireBackingTextureIfNeeded(CCPrioritizedTexture, CCResourceProvider);
84		96
Lines 91-96 public: a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTextureManager.h_sec3
91	#endif	103	#endif
92		104
93	private:	105	private:
		106
94	// Compare textures. Highest priority first.	107	// Compare textures. Highest priority first.
95	static inline bool compareTextures(CCPrioritizedTexture* a, CCPrioritizedTexture* b)	108	static inline bool compareTextures(CCPrioritizedTexture* a, CCPrioritizedTexture* b)
96	{	109	{
Lines 109-119 private: a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTextureManager.h_sec4
109	}	122	}
110		123
111	CCPrioritizedTextureManager(size_t maxMemoryLimitBytes, int maxTextureSize, int pool);	124	CCPrioritizedTextureManager(size_t maxMemoryLimitBytes, int maxTextureSize, int pool);
112
113	void reduceMemory(size_t limit, CCResourceProvider*);	125	void reduceMemory(size_t limit, CCResourceProvider*);
114
115	CCPrioritizedTexture::Backing* createBacking(IntSize, GC3Denum format, CCResourceProvider*);	126	CCPrioritizedTexture::Backing* createBacking(IntSize, GC3Denum format, CCResourceProvider*);
116	void destroyBacking(CCPrioritizedTexture::Backing, CCResourceProvider);	127	void clearEvictedBackings();
		128	void destroyBacking(CCPrioritizedTexture::Backing*);
117		129
118	size_t m_maxMemoryLimitBytes;	130	size_t m_maxMemoryLimitBytes;
119	unsigned m_priorityCutoff;	131	unsigned m_priorityCutoff;
Lines 132-137 private: a/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTextureManager.h_sec5
132		144
133	TextureVector m_tempTextureVector;	145	TextureVector m_tempTextureVector;
134	BackingVector m_tempBackingVector;	146	BackingVector m_tempBackingVector;
		147
		148	// This state that can be concurrently accessed by the main and impl thread,
		149	// and needs protection by a mutex.
		150	class SharedState {
		151	public:
		152	SharedState() { }
		153	~SharedState();
		154
		155	// Called on the impl thread while the main thread is blocked
		156	void addBackingOnImplThread(CCPrioritizedTexture::Backing*);
		157	void removeBackingOnImplThread(CCPrioritizedTexture::Backing*);
		158
		159	// Called on the impl thread while the main thread may not be
		160	// blocked
		161	bool evictBackingsResourcesOnImplThreadAsync(CCResourceProvider*);
		162
		163	// Called on the main thread, possibly concurrently with
		164	// evictBackingsResourcesOnImplThreadAsync.
		165	// Also called on the impl thread during thread-shutdown and
		166	// context-lost
		167	void getAndClearEvictedBackings(BackingSet&);
		168
		169	private:
		170	Mutex m_mutex;
		171	BackingSet m_unevictedBackings;
		172	BackingSet m_evictedBackings;
		173	};
		174	SharedState m_sharedState;
135	};	175	};
136		176
137	} // WebCore	177	} // WebCore

Lines 155-163 bool CCSingleThreadProxy::recreateContext() a/Source/WebCore/platform/graphics/chromium/cc/CCSingleThreadProxy.cpp_sec1
- a/Source/WebCore/platform/graphics/chromium/cc/CCSingleThreadProxy.cpp -7 / +13 lines
155		155
156	bool initialized;	156	bool initialized;
157	{	157	{
		158	DebugScopedSetMainThreadBlocked mainThreadBlocked;
158	DebugScopedSetImplThread impl;	159	DebugScopedSetImplThread impl;
159	if (!m_layerTreeHostImpl->contentsTexturesPurged())	160	m_layerTreeHost->deleteAllContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
160	m_layerTreeHost->deleteContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
161	initialized = m_layerTreeHostImpl->initializeRenderer(context.release(), UnthrottledUploader);	161	initialized = m_layerTreeHostImpl->initializeRenderer(context.release(), UnthrottledUploader);
162	if (initialized) {	162	if (initialized) {
163	m_RendererCapabilitiesForMainThread = m_layerTreeHostImpl->rendererCapabilities();	163	m_RendererCapabilitiesForMainThread = m_layerTreeHostImpl->rendererCapabilities();
Lines 260-268 void CCSingleThreadProxy::stop() a/Source/WebCore/platform/graphics/chromium/cc/CCSingleThreadProxy.cpp_sec2
260	{	260	{
261	DebugScopedSetMainThreadBlocked mainThreadBlocked;	261	DebugScopedSetMainThreadBlocked mainThreadBlocked;
262	DebugScopedSetImplThread impl;	262	DebugScopedSetImplThread impl;
263		263	m_layerTreeHost->deleteAllContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
264	if (!m_layerTreeHostImpl->contentsTexturesPurged())
265	m_layerTreeHost->deleteContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
266	m_layerTreeHostImpl.clear();	264	m_layerTreeHostImpl.clear();
267	}	265	}
268	m_layerTreeHost = 0;	266	m_layerTreeHost = 0;
Lines 275-280 void CCSingleThreadProxy::postAnimationEventsToMainThreadOnImplThread(PassOwnPtr a/Source/WebCore/platform/graphics/chromium/cc/CCSingleThreadProxy.cpp_sec3
275	m_layerTreeHost->setAnimationEvents(events, wallClockTime);	273	m_layerTreeHost->setAnimationEvents(events, wallClockTime);
276	}	274	}
277		275
		276	void CCSingleThreadProxy::reduceContentsTexturesMemoryOnImplThread()
		277	{
		278	ASSERT(CCProxy::isImplThread());
		279	if (m_layerTreeHost->reduceContentsTexturesMemoryOnImplThread(m_layerTreeHostImpl->resourceProvider())) {
		280	m_layerTreeHostImpl->setContentsTexturesPurged();
		281	setNeedsCommitOnImplThread();
		282	}
		283	}
		284
278	// Called by the legacy scheduling path (e.g. where render_widget does the scheduling)	285	// Called by the legacy scheduling path (e.g. where render_widget does the scheduling)
279	void CCSingleThreadProxy::compositeImmediately()	286	void CCSingleThreadProxy::compositeImmediately()
280	{	287	{
Lines 301-308 bool CCSingleThreadProxy::commitAndComposite() a/Source/WebCore/platform/graphics/chromium/cc/CCSingleThreadProxy.cpp_sec4
301	if (!m_layerTreeHost->initializeRendererIfNeeded())	308	if (!m_layerTreeHost->initializeRendererIfNeeded())
302	return false;	309	return false;
303		310
304	if (m_layerTreeHostImpl->contentsTexturesPurged())	311	m_layerTreeHost->destroyContentsTexturesEvictedByImplThread();
305	m_layerTreeHost->evictAllContentTextures();
306		312
307	CCTextureUpdateQueue queue;	313	CCTextureUpdateQueue queue;
308	m_layerTreeHost->updateLayers(queue, m_layerTreeHostImpl->memoryAllocationLimitBytes());	314	m_layerTreeHost->updateLayers(queue, m_layerTreeHostImpl->memoryAllocationLimitBytes());

Lines 54-63 void CCTextureUpdateQueue::appendCopy(TextureCopier::Parameters copy) a/Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateQueue.cpp_sec1
- a/Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateQueue.cpp -3 / +14 lines
54	m_copyEntries.append(copy);	54	m_copyEntries.append(copy);
55	}	55	}
56		56
57	void CCTextureUpdateQueue::clearUploads()	57	void CCTextureUpdateQueue::clearUploadsToDeletedResources()
58	{	58	{
59	m_fullEntries.clear();	59	clearUploadsToDeletedResources(m_fullEntries);
60	m_partialEntries.clear();	60	clearUploadsToDeletedResources(m_partialEntries);
		61	}
		62
		63	void CCTextureUpdateQueue::clearUploadsToDeletedResources(Deque<TextureUploader::Parameters>& entryQueue)
		64	{
		65	Deque<TextureUploader::Parameters> temp;
		66	entryQueue.swap(temp);
		67	while (temp.size()) {
		68	TextureUploader::Parameters upload = temp.takeFirst();
		69	if (!upload.texture->backingWasAsynchronouslyDeleted())
		70	entryQueue.append(upload);
		71	}
61	}	72	}
62		73
63	TextureUploader::Parameters CCTextureUpdateQueue::takeFirstFullUpload()	74	TextureUploader::Parameters CCTextureUpdateQueue::takeFirstFullUpload()

Lines 43-49 public: a/Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateQueue.h_sec1
- a/Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateQueue.h -1 / +2 lines
43	void appendPartialUpload(TextureUploader::Parameters);	43	void appendPartialUpload(TextureUploader::Parameters);
44	void appendCopy(TextureCopier::Parameters);	44	void appendCopy(TextureCopier::Parameters);
45		45
46	void clearUploads();	46	void clearUploadsToDeletedResources();
47		47
48	TextureUploader::Parameters takeFirstFullUpload();	48	TextureUploader::Parameters takeFirstFullUpload();
49	TextureUploader::Parameters takeFirstPartialUpload();	49	TextureUploader::Parameters takeFirstPartialUpload();
Lines 56-61 public: a/Source/WebCore/platform/graphics/chromium/cc/CCTextureUpdateQueue.h_sec2
56	bool hasMoreUpdates() const;	56	bool hasMoreUpdates() const;
57		57
58	private:	58	private:
		59	void clearUploadsToDeletedResources(Deque<TextureUploader::Parameters>& entryQueue);
59	Deque<TextureUploader::Parameters> m_fullEntries;	60	Deque<TextureUploader::Parameters> m_fullEntries;
60	Deque<TextureUploader::Parameters> m_partialEntries;	61	Deque<TextureUploader::Parameters> m_partialEntries;
61	Deque<TextureCopier::Parameters> m_copyEntries;	62	Deque<TextureCopier::Parameters> m_copyEntries;

Lines 86-91 public: a/Source/WebKit/chromium/tests/CCLayerTreeHostImplTest.cpp_sec1
- a/Source/WebKit/chromium/tests/CCLayerTreeHostImplTest.cpp -6 / +1 lines
86	virtual void setNeedsRedrawOnImplThread() OVERRIDE { m_didRequestRedraw = true; }	86	virtual void setNeedsRedrawOnImplThread() OVERRIDE { m_didRequestRedraw = true; }
87	virtual void setNeedsCommitOnImplThread() OVERRIDE { m_didRequestCommit = true; }	87	virtual void setNeedsCommitOnImplThread() OVERRIDE { m_didRequestCommit = true; }
88	virtual void postAnimationEventsToMainThreadOnImplThread(PassOwnPtr<CCAnimationEventsVector>, double wallClockTime) OVERRIDE { }	88	virtual void postAnimationEventsToMainThreadOnImplThread(PassOwnPtr<CCAnimationEventsVector>, double wallClockTime) OVERRIDE { }
		89	virtual void reduceContentsTexturesMemoryOnImplThread() OVERRIDE { }
89		90
90	PassOwnPtr<CCLayerTreeHostImpl> createLayerTreeHost(bool partialSwap, PassOwnPtr<CCGraphicsContext> graphicsContext, PassOwnPtr<CCLayerImpl> rootPtr)	91	PassOwnPtr<CCLayerTreeHostImpl> createLayerTreeHost(bool partialSwap, PassOwnPtr<CCGraphicsContext> graphicsContext, PassOwnPtr<CCLayerImpl> rootPtr)
91	{	92	{
Lines 3772-3783 TEST_F(CCLayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap) a/Source/WebKit/chromium/tests/CCLayerTreeHostImplTest.cpp_sec2
3772	}	3773	}
3773	}	3774	}
3774		3775
3775	TEST_F(CCLayerTreeHostImplTest, releaseContentsTextureShouldTriggerCommit)
3776	{
3777	m_hostImpl->releaseContentsTextures();
3778	EXPECT_TRUE(m_didRequestCommit);
3779	}
3780
3781	struct RenderPassCacheEntry {	3776	struct RenderPassCacheEntry {
3782	mutable OwnPtr<CCRenderPass> renderPassPtr;	3777	mutable OwnPtr<CCRenderPass> renderPassPtr;
3783	CCRenderPass* renderPass;	3778	CCRenderPass* renderPass;