Bug 1070308. Add Acquire and Release semantics to SharedSurface. r=jgilbert

This is needed for D3D11 keyed mutex support. The added assertions
also ensure we're doing things at the right times.

--HG--
extra : rebase_source : 7af4dccca745ee62e4ae97972de8a8eb83f2e8d3

gfx/gl/GLScreenBuffer.cpp

@@ -440,7 +440,10 @@ GLScreenBuffer::Swap(const gfx::IntSize& size)
 
     // Fence before copying.
     if (mFront) {
-        mFront->Surf()->Fence();
+        mFront->Surf()->ProducerRelease();
+    }
+    if (mBack) {
+        mBack->Surf()->ProducerAcquire();
     }
 
     if (ShouldPreserveBuffer() &&
@@ -474,7 +477,13 @@ GLScreenBuffer::Resize(const gfx::IntSize& size)
     if (!Attach(newBack->Surf(), size))
         return false;
 
+    if (mBack)
+        mBack->Surf()->ProducerRelease();
+
     mBack = newBack;
+
+    mBack->Surf()->ProducerAcquire();
+
     return true;
 }
 

gfx/gl/SharedSurface.cpp

@@ -210,6 +210,8 @@ SharedSurface::SharedSurface(SharedSurfaceType type,
     , mSize(size)
     , mHasAlpha(hasAlpha)
     , mIsLocked(false)
+    , mIsProducerAcquired(false)
+    , mIsConsumerAcquired(false)
 #ifdef DEBUG
     , mOwningThread(NS_GetCurrentThread())
 #endif

gfx/gl/SharedSurface.h

@@ -53,6 +53,8 @@ public:
     const bool mHasAlpha;
 protected:
     bool mIsLocked;
+    bool mIsProducerAcquired;
+    bool mIsConsumerAcquired;
     DebugOnly<nsIThread* const> mOwningThread;
 
     SharedSurface(SharedSurfaceType type,
@@ -80,7 +82,37 @@ protected:
     virtual void LockProdImpl() = 0;
     virtual void UnlockProdImpl() = 0;
 
+    virtual void ProducerAcquireImpl() {}
+    virtual void ProducerReleaseImpl() {
+        Fence();
+    }
+    virtual void ConsumerAcquireImpl() {
+        WaitSync();
+    }
+    virtual void ConsumerReleaseImpl() {}
+
 public:
+    void ProducerAcquire() {
+        MOZ_ASSERT(!mIsProducerAcquired);
+        ProducerAcquireImpl();
+        mIsProducerAcquired = true;
+    }
+    void ProducerRelease() {
+        MOZ_ASSERT(mIsProducerAcquired);
+        ProducerReleaseImpl();
+        mIsProducerAcquired = false;
+    }
+    void ConsumerAcquire() {
+        MOZ_ASSERT(!mIsConsumerAcquired);
+        ConsumerAcquireImpl();
+        mIsConsumerAcquired = true;
+    }
+    void ConsumerRelease() {
+        MOZ_ASSERT(mIsConsumerAcquired);
+        ConsumerReleaseImpl();
+        mIsConsumerAcquired = false;
+    }
+
     virtual void Fence() = 0;
     virtual bool WaitSync() = 0;
     virtual bool PollSync() = 0;

gfx/layers/client/TextureClient.cpp

@@ -816,7 +816,6 @@ SharedSurfaceTextureClient::SharedSurfaceTextureClient(TextureFlags aFlags,
   , mSurf(surf)
   , mGL(mSurf->mGL)
 {
-  mSurf->Fence();
 }
 
 SharedSurfaceTextureClient::~SharedSurfaceTextureClient()

gfx/layers/composite/TextureHost.cpp

@@ -917,11 +917,33 @@ SharedSurfaceTextureHost::EnsureTexSource()
   if (mTexSource)
     return;
 
-  mSurf->WaitSync();
   mTexSource = SharedSurfaceToTexSource(mSurf, mCompositor);
   MOZ_ASSERT(mTexSource);
 }
 
+bool
+SharedSurfaceTextureHost::Lock()
+{
+  MOZ_ASSERT(!mIsLocked);
+
+  mSurf->ConsumerAcquire();
+
+  mIsLocked = true;
+
+  EnsureTexSource();
+
+  return true;
+}
+
+void
+SharedSurfaceTextureHost::Unlock()
+{
+  MOZ_ASSERT(mIsLocked);
+  mSurf->ConsumerRelease();
+  mIsLocked = false;
+}
+
+
 ////////////////////////////////////////////////////////////////////////////////
 
 } // namespace

gfx/layers/composite/TextureHost.h

@@ -653,7 +653,9 @@ public:
   SharedSurfaceTextureHost(TextureFlags aFlags,
                            const SharedSurfaceDescriptor& aDesc);
 
-  virtual ~SharedSurfaceTextureHost() {};
+  virtual ~SharedSurfaceTextureHost() {
+    MOZ_ASSERT(!mIsLocked);
+  }
 
   virtual void DeallocateDeviceData() MOZ_OVERRIDE {};
 
@@ -672,17 +674,9 @@ public:
   }
 
 public:
-  virtual bool Lock() MOZ_OVERRIDE {
-    MOZ_ASSERT(!mIsLocked);
-    mIsLocked = true;
-    EnsureTexSource();
-    return true;
-  }
 
-  virtual void Unlock() MOZ_OVERRIDE {
-    MOZ_ASSERT(mIsLocked);
-    mIsLocked = false;
-  }
+  virtual bool Lock() MOZ_OVERRIDE;
+  virtual void Unlock() MOZ_OVERRIDE;
 
   virtual TextureSource* GetTextureSources() MOZ_OVERRIDE {
     MOZ_ASSERT(mIsLocked);