cc: Enforce correct recycling in resource pool.

cc/layer_tree_host_impl.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/layer_tree_host_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
@@ skipping 823 matching lines @@
 {
     DCHECK(m_proxy->isImplThread());
     return m_renderer && m_renderer->isContextLost();
 }
 
 const RendererCapabilities& LayerTreeHostImpl::rendererCapabilities() const
 {
     return m_renderer->capabilities();
 }
 
+namespace {
+// This implements a simple fence based on client side swaps.
+// This is to isolate the ResourceProvider from 'frames' which
+// it shouldn't need to care about, while still allowing us to
+// enforce correct texture recycling behavior strictly throughout
+// the compositor. The reason textures are recycled is so that
+// we can avoid writing to them while they are in use on the GPU.
+class SimpleSwapFence : public ResourceProvider::Fence {
+public:
+    SimpleSwapFence() : m_passed(false) {}
+    virtual bool hasPassed() OVERRIDE { return m_passed; }
+    bool setToPassed() { m_passed = true; }

[nduca, 2013/02/05 22:39:05]

m_passed -> m_hasPassed

setHasPassed()

[epenner, 2013/02/05 23:27:36]

Done.

+private:
+    bool m_passed;
+};
+}
+
 bool LayerTreeHostImpl::swapBuffers()

[nduca, 2013/02/05 22:39:05]

what if output_surface.h had a scoped<RefPtr> ResourceProvider::Fence 
getFenceForWorkToThisPoint() call? It knows about swapbuffers. Effectively, move
your LTHI changes to output surface.

[piman, 2013/02/05 22:46:47]

Sadly I don't think it knows about it yet, though we definitely want that and
talked about it!
That's why I suggested renderer in the mean time (though I support moing the
swapBuffers to OutputSurface!)

[epenner, 2013/02/05 23:27:36]

Done.

 {
     DCHECK(m_renderer);
     bool result = m_renderer->swapBuffers();
 
+    scoped_refptr<ResourceProvider::Fence> lastSwapFence = m_resourceProvider->getReadLockFence();
+    if (lastSwapFence)
+        static_cast<SimpleSwapFence*>(lastSwapFence.get())->setToPassed();
+    m_resourceProvider->setReadLockFence(new SimpleSwapFence());
+

[piman, 2013/02/05 22:19:07]

Can we move that logic to the renderer? It shouldn't apply to the software
renderer, and the logic is likely different for the delegated renderer.
Also that lets us later more easily tune the logic based on GPU logic (e.g.
proper fence).

[epenner, 2013/02/05 23:27:36]

Done.

     if (m_settings.implSidePainting &&
         !activeTree()->AreVisibleResourcesReady()) {
         m_client->didSwapUseIncompleteTileOnImplThread();
     }
 
     return result;
 }
 
 const gfx::Size& LayerTreeHostImpl::deviceViewportSize() const
 {
@@ skipping 854 matching lines @@
     LayerImpl* layer = getNonCompositedContentLayerRecursive(tree->RootLayer());
     return layer ? layer->getPicture() : skia::RefPtr<SkPicture>();
 }
 
 void LayerTreeHostImpl::savePaintTime(const base::TimeDelta& totalPaintTime)
 {
     m_paintTimeCounter->SavePaintTime(totalPaintTime);
 }
 
 }  // namespace cc