Merge lp:~compiz-team/compiz/compiz.fix_1051286 into lp:compiz/0.9.8

[Sam Spilsbury]

Refactored the vsync code to get it under test. DoubleBuffer now dispatches to two separate VSync strategies depending on what type of swap we are doing. It also makes the unthrottledFrames code a lot clearer by specifying that this is for detecting broken hardware framelimiting.

This was originally going to be "deliver a big performance win on nvidia", however it seems like the local code where I had curtailed our use of glXSwapIntervalEXT delivering a performance boost is not reproducing the same conditions anymore.

Nevertheless, calling into opengGL redundantly is bad. And perhaps it is a condition on some hardware or other circumstances.

The main point of this branch is now as follows:

Refactored the vsync code to get it under test. DoubleBuffer now dispatches to two separate VSync strategies depending on what type of swap we are doing. It also makes the unthrottledFrames code a lot clearer by specifying that this is for detecting broken hardware framelimiting.

Take it or leave it I guess.

[jenkins (martin-mrazik+qa)]

FAILED: Continuous integration, rev:3386
http://jenkins.qa.ubuntu.com/job/compiz-ci/88/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-ci/./build=pbuilder,distribution=quantal,flavor=amd64/88/console

review: Needs Fixing (continuous-integration)

[Daniel van Vugt (vanvugt)]

Forgive me for deferring this till after we branch (which should be very soon), if there is no good reason (any more) to risk a 1477 line diff in 0.9.8.

[Daniel van Vugt (vanvugt)]

Please resubmit after we branch.

review: Needs Resubmitting

[Sam Spilsbury (smspillaz)]

As above. Resubmitted locally to get CI to run again.

review: Needs Resubmitting

[jenkins (martin-mrazik+qa)]

FAILED: Continuous integration, rev:3386
http://jenkins.qa.ubuntu.com/job/compiz-ci/93/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-ci/./build=pbuilder,distribution=quantal,flavor=amd64/93/console

review: Needs Fixing (continuous-integration)

[Daniel van Vugt (vanvugt)]

Resubmit after branching...

review: Needs Resubmitting

[Martin Mrazik (mrazik)]

This is the jenkins error:
pplying patch ccp_plugin.patch
patching file src/main.cpp
Hunk #1 succeeded at 147 (offset 1 line).

Applying patch workaround_broken_drivers.patch
patching file plugins/opengl/src/screen.cpp
Hunk #1 succeeded at 43 (offset 6 lines).
Hunk #2 FAILED at 289.
Hunk #3 succeeded at 913 (offset 84 lines).
1 out of 3 hunks FAILED -- rejects in file plugins/opengl/src/screen.cpp
Patch workaround_broken_drivers.patch does not apply (enforce with -f)
dh_quilt_patch: quilt --quiltrc /dev/null push -a || test $? = 2 returned exit code 1

[Daniel van Vugt (vanvugt)]

Hmm, then again, bug 1051286 sounds important :/

[Sam Spilsbury (smspillaz)]

I can't reproduce the condition in that bug anymore, so this can wait.

[Sam Spilsbury (smspillaz)]

Set to WIP as there will be conflicts

review: Needs Resubmitting

[lp:~compiz-team/compiz/compiz.fix_1051286]

3387. By Sam Spilsbury on 2012-10-02

Merge lp:compiz

Unmerged revisions

3387. By Sam Spilsbury on 2012-10-02

Merge lp:compiz

3386. By Sam Spilsbury on 2012-09-19

Put the bind pixmap handler after the double buffer handler so that the
latter can use it indirectly

3385. By Sam Spilsbury on 2012-09-19

Merge lp:compiz

3384. By Sam Spilsbury on 2012-09-19

Implement the vsync code in terms of the newer refactored code

3383. By Sam Spilsbury on 2012-09-19

Move the vsync hook into DoubleBuffer::render

3382. By Sam Spilsbury on 2012-09-19

Make all the tests pass - the logic is now implemented and just
needs to be hooked up

3381. By Sam Spilsbury on 2012-09-19

Refactored the double buffer classes somewhat to take a list of vsync
methods, test for their usage as appropriate

3380. By Sam Spilsbury on 2012-09-19

Added some unit tests, make them pass

3379. By Sam Spilsbury on 2012-09-19

Added test fixture from the video sync strategies code

=== modified file 'plugins/opengl/CMakeLists.txt'
--- plugins/opengl/CMakeLists.txt	2012-09-17 13:48:33 +0000
+++ plugins/opengl/CMakeLists.txt	2012-09-22 03:12:18 +0000
@@ -6,13 +6,16 @@
     compiz_opengl_double_buffer
     compiz_opengl_fsregion
     compiz_opengl_glx_tfp_bind
+    compiz_opengl_vsync_methods
 )
 
 add_subdirectory (src/doublebuffer)
 add_subdirectory (src/fsregion)
 add_subdirectory (src/glxtfpbind)
+add_subdirectory (src/vsyncmethod)
 
 include_directories (src/glxtfpbind/include)
+include_directories (src/vsyncmethod/include)
 
 if (USE_GLES)
     compiz_plugin(opengl PLUGINDEPS composite CFLAGSADD "-DUSE_GLES -std=c++0x" LIBRARIES ${OPENGLES2_LIBRARIES} ${INTERNAL_LIBRARIES} dl INCDIRS ${OPENGLES2_INCLUDE_DIR})

=== modified file 'plugins/opengl/include/opengl/doublebuffer.h'
--- plugins/opengl/include/opengl/doublebuffer.h	2012-09-12 03:55:21 +0000
+++ plugins/opengl/include/opengl/doublebuffer.h	2012-09-22 03:12:18 +0000
@@ -2,6 +2,7 @@
 #define _COMPIZ_OPENGL_BUFFERBLIT_H
 
 #include <core/region.h>
+#include <vsyncmethod.h>
 
 namespace compiz
 {
@@ -11,7 +12,7 @@
 class DoubleBuffer
 {
     public:
-	DoubleBuffer ();
+	DoubleBuffer (const std::list <VSyncMethod::Ptr> &vsyncMethods);
 	virtual ~DoubleBuffer ();
 
 	virtual void swap () const = 0;
@@ -31,9 +32,17 @@
 
 	void set (Setting name, bool value);
 	void render (const CompRegion &region, bool fullscreen);
+	void vsync (BufferSwapType swapType);
+
+	bool hardwareVSyncFunctional ();
 
     protected:
 	bool setting[_NSETTINGS];
+
+    private:
+	unsigned int                 unthrottledFrames;
+	std::list <VSyncMethod::Ptr> vsyncMethods;
+	VSyncMethod::Ptr	     lastSuccessfulVSyncMethod;
 };
 
 }

=== modified file 'plugins/opengl/src/doublebuffer/CMakeLists.txt'
--- plugins/opengl/src/doublebuffer/CMakeLists.txt	2012-07-05 08:17:49 +0000
+++ plugins/opengl/src/doublebuffer/CMakeLists.txt	2012-09-22 03:12:18 +0000
@@ -1,6 +1,7 @@
 INCLUDE_DIRECTORIES (  
   ${compiz_SOURCE_DIR}/src/logmessage/include
   ${CMAKE_CURRENT_SOURCE_DIR}/../../include
+  ${CMAKE_CURRENT_SOURCE_DIR}/../../src
   ${CMAKE_CURRENT_SOURCE_DIR}/src
     
   ${Boost_INCLUDE_DIRS}

=== modified file 'plugins/opengl/src/doublebuffer/src/double-buffer.cpp'
--- plugins/opengl/src/doublebuffer/src/double-buffer.cpp	2012-09-12 03:55:21 +0000
+++ plugins/opengl/src/doublebuffer/src/double-buffer.cpp	2012-09-22 03:12:18 +0000
@@ -38,7 +38,9 @@
 namespace opengl
 {
 
-DoubleBuffer::DoubleBuffer ()
+DoubleBuffer::DoubleBuffer (const std::list <VSyncMethod::Ptr> &vsyncMethods) :
+    unthrottledFrames (0),
+    vsyncMethods (vsyncMethods)
 {
     setting[VSYNC] = true;
     setting[HAVE_PERSISTENT_BACK_BUFFER] = false;
@@ -61,23 +63,74 @@
 {
     if (fullscreen)
     {
+	if (setting[VSYNC])
+	    vsync (Flip);
+
 	swap ();
+
 	if (setting[NEED_PERSISTENT_BACK_BUFFER] &&
 	    !setting[HAVE_PERSISTENT_BACK_BUFFER])
 	{
 	    copyFrontToBack ();
 	}
     }
-    else if (blitAvailable ())
-	blit (region);
-    else if (fallbackBlitAvailable ())
-	fallbackBlit (region);
-    else
-    {
-	// This will never happen unless you make a porting mistake...
-	assert (false);
-	abort ();
-    }
+    else
+    {
+	if (setting[VSYNC])
+	    vsync (PartialCopy);
+
+	if (blitAvailable ())
+	    blit (region);
+	else if (fallbackBlitAvailable ())
+	    fallbackBlit (region);
+	else
+	{
+	    // This will never happen unless you make a porting mistake...
+	    assert (false);
+	    abort ();
+	}
+    }
+}
+
+void
+DoubleBuffer::vsync (BufferSwapType swapType)
+{
+    bool throttled = true;
+
+    for (std::list <VSyncMethod::Ptr>::iterator it = vsyncMethods.begin ();
+	 it != vsyncMethods.end ();
+	 ++it)
+    {
+	VSyncMethod::Ptr &method (*it);
+
+	/* Try and use this method, check if this method
+	 * throttled us too */
+	if (method->enableForBufferSwapType (swapType, throttled))
+	{
+	    if (lastSuccessfulVSyncMethod &&
+		lastSuccessfulVSyncMethod != method)
+		lastSuccessfulVSyncMethod->disable ();
+
+	    lastSuccessfulVSyncMethod = method;
+	    break;
+	}
+	else
+	{
+	    throttled = false;
+	    method->disable ();
+	}
+    }
+
+    if (!throttled)
+	unthrottledFrames++;
+    else
+	unthrottledFrames = 0;
+}
+
+bool
+DoubleBuffer::hardwareVSyncFunctional ()
+{
+    return unthrottledFrames < 5;
 }
 
 } // namespace opengl

=== modified file 'plugins/opengl/src/doublebuffer/tests/test-opengl-double-buffer.cpp'
--- plugins/opengl/src/doublebuffer/tests/test-opengl-double-buffer.cpp	2012-09-12 10:45:58 +0000
+++ plugins/opengl/src/doublebuffer/tests/test-opengl-double-buffer.cpp	2012-09-22 03:12:18 +0000
@@ -2,17 +2,24 @@
 #include <gmock/gmock.h>
 
 #include <opengl/doublebuffer.h>
+#include <vsyncmethod.h>
 
 using namespace compiz::opengl;
 using testing::_;
 using testing::StrictMock;
 using testing::Return;
+using testing::SetArgReferee;
 
 class MockDoubleBuffer :
     public DoubleBuffer
 {
     public:
 
+	MockDoubleBuffer (const std::list <VSyncMethod::Ptr> &vsyncMethods) :
+	    DoubleBuffer (vsyncMethods)
+	{
+	}
+
 	MOCK_CONST_METHOD0 (swap, void ());
 	MOCK_CONST_METHOD0 (blitAvailable, bool ());
 	MOCK_CONST_METHOD1 (blit, void (const CompRegion &));
@@ -21,13 +28,28 @@
 	MOCK_CONST_METHOD0 (copyFrontToBack, void ());
 };
 
+class MockVSyncMethod :
+    public VSyncMethod
+{
+    public:
+
+	MOCK_METHOD2 (enableForBufferSwapType, bool (BufferSwapType, bool &));
+	MOCK_METHOD0 (disable, void ());
+};
+
 class DoubleBufferTest :
     public ::testing::Test
 {
     public:
 
-	MockDoubleBuffer db;
-	CompRegion	 blitRegion;
+	DoubleBufferTest () :
+	    db (vsyncMethods)
+	{
+	}
+
+	std::list <VSyncMethod::Ptr> vsyncMethods;
+	MockDoubleBuffer             db;
+	CompRegion	             blitRegion;
 
 };
 
@@ -102,7 +124,8 @@
 
 TEST_F(CompizOpenGLDoubleBufferDeathTest, TestNoPaintedFullscreenOrFBODoesNotBlitOrCopyIfNotSupportedAndDies)
 {
-    StrictMock <MockDoubleBuffer> dbStrict;
+    std::list <VSyncMethod::Ptr> vsyncMethods;
+    StrictMock <MockDoubleBuffer> dbStrict (vsyncMethods);
 
     ON_CALL (dbStrict, blitAvailable ()).WillByDefault (Return (false));
     ON_CALL (dbStrict, fallbackBlitAvailable ()).WillByDefault (Return (false));
@@ -115,7 +138,8 @@
 
 TEST_F(DoubleBufferTest, TestSubBufferCopyIfNoFBOAndNoSubBufferBlit)
 {
-    StrictMock <MockDoubleBuffer> dbStrict;
+    std::list <VSyncMethod::Ptr> vsyncMethods;
+    StrictMock <MockDoubleBuffer> dbStrict (vsyncMethods);
 
     EXPECT_CALL (dbStrict, blitAvailable ()).WillOnce (Return (false));
     EXPECT_CALL (dbStrict, fallbackBlitAvailable ()).WillOnce (Return (true));
@@ -123,3 +147,141 @@
 
     dbStrict.render (blitRegion, false);
 }
+
+TEST (DoubleBufferVSyncTest, TestCallWorkingStrategy)
+{
+    boost::shared_ptr <MockVSyncMethod> mockVSyncMethod (new MockVSyncMethod ());
+    std::list <VSyncMethod::Ptr>        vsyncMethods;
+
+    vsyncMethods.push_back (mockVSyncMethod);
+
+    MockDoubleBuffer doubleBuffer (vsyncMethods);
+
+    EXPECT_CALL (*mockVSyncMethod, enableForBufferSwapType (Flip, _))
+	    .WillOnce (Return (true));
+
+    doubleBuffer.vsync (Flip);
+}
+
+TEST (DoubleBufferVSyncTest, TestCallNextWorkingStrategy)
+{
+    boost::shared_ptr <MockVSyncMethod> mockVSyncMethod (new MockVSyncMethod ());
+    boost::shared_ptr <MockVSyncMethod> mockVSyncMethodSafer (new MockVSyncMethod ());
+    std::list <VSyncMethod::Ptr>        vsyncMethods;
+
+    vsyncMethods.push_back (mockVSyncMethod);
+    vsyncMethods.push_back (mockVSyncMethodSafer);
+
+    MockDoubleBuffer doubleBuffer (vsyncMethods);
+
+    /* This one fails */
+    EXPECT_CALL (*mockVSyncMethod, enableForBufferSwapType (PartialCopy, _))
+	    .WillOnce (Return (false));
+    /* It needs to be deactivated */
+    EXPECT_CALL (*mockVSyncMethod, disable ());
+    /* Try the next one */
+    EXPECT_CALL (*mockVSyncMethodSafer, enableForBufferSwapType (PartialCopy, _))
+	    .WillOnce (Return (true));
+
+    doubleBuffer.vsync (PartialCopy);
+}
+
+TEST (DoubleBufferVSyncTest, TestCallPrevCallNextPrevDeactivated)
+{
+    boost::shared_ptr <MockVSyncMethod> mockVSyncMethod (new MockVSyncMethod ());
+    boost::shared_ptr <MockVSyncMethod> mockVSyncMethodSafer (new MockVSyncMethod ());
+    std::list <VSyncMethod::Ptr>        vsyncMethods;
+
+    vsyncMethods.push_back (mockVSyncMethod);
+    vsyncMethods.push_back (mockVSyncMethodSafer);
+
+    MockDoubleBuffer doubleBuffer (vsyncMethods);
+
+    /* This one fails */
+    EXPECT_CALL (*mockVSyncMethod, enableForBufferSwapType (PartialCopy, _))
+	    .WillOnce (Return (false));
+    /* It needs to be deactivated */
+    EXPECT_CALL (*mockVSyncMethod, disable ());
+    /* Try the next one */
+    EXPECT_CALL (*mockVSyncMethodSafer, enableForBufferSwapType (PartialCopy, _))
+	    .WillOnce (Return (true));
+
+    doubleBuffer.vsync (PartialCopy);
+
+    /* Now the previous one works */
+    EXPECT_CALL (*mockVSyncMethod, enableForBufferSwapType (PartialCopy, _))
+	    .WillOnce (Return (true));
+    /* Previous one must be deactivated */
+    EXPECT_CALL (*mockVSyncMethodSafer, disable ());
+
+    doubleBuffer.vsync (PartialCopy);
+}
+
+TEST (DoubleBufferVSyncTest, TestReportNoHardwareVSyncIfMoreThan5UnthrottledFrames)
+{
+    boost::shared_ptr <MockVSyncMethod> mockVSyncMethod (new MockVSyncMethod ());
+    std::list <VSyncMethod::Ptr>        vsyncMethods;
+
+    vsyncMethods.push_back (mockVSyncMethod);
+
+    /* Always succeed */
+    ON_CALL (*mockVSyncMethod, enableForBufferSwapType (PartialCopy, _)).WillByDefault (Return (true));
+
+    MockDoubleBuffer doubleBuffer (vsyncMethods);
+
+    /* This one succeeds but fails to throttle */
+    for (unsigned int i = 0; i < 5; ++i)
+    {
+	EXPECT_CALL (*mockVSyncMethod, enableForBufferSwapType (PartialCopy, _))
+		.WillOnce (SetArgReferee <1> (false));
+
+	doubleBuffer.vsync (PartialCopy);
+    }
+
+    EXPECT_FALSE (doubleBuffer.hardwareVSyncFunctional ());
+}
+
+TEST (DoubleBufferVSyncTest, TestRestoreReportHardwareVSync)
+{
+    boost::shared_ptr <MockVSyncMethod> mockVSyncMethod (new MockVSyncMethod ());
+    std::list <VSyncMethod::Ptr>        vsyncMethods;
+
+    vsyncMethods.push_back (mockVSyncMethod);
+
+    MockDoubleBuffer doubleBuffer (vsyncMethods);
+
+    /* Always succeed */
+    ON_CALL (*mockVSyncMethod, enableForBufferSwapType (PartialCopy, _)).WillByDefault (Return (true));
+
+    /* This one succeeds but fails to throttle */
+    for (unsigned int i = 0; i < 5; ++i)
+    {
+	EXPECT_CALL (*mockVSyncMethod, enableForBufferSwapType (PartialCopy, _))
+		.WillOnce (SetArgReferee <1> (false));
+
+	EXPECT_TRUE (doubleBuffer.hardwareVSyncFunctional ());
+
+	doubleBuffer.vsync (PartialCopy);
+    }
+
+    EXPECT_FALSE (doubleBuffer.hardwareVSyncFunctional ());
+
+    /* It works again */
+    EXPECT_CALL (*mockVSyncMethod, enableForBufferSwapType (PartialCopy, _))
+	    .WillOnce (SetArgReferee <1> (true));
+
+    doubleBuffer.vsync (PartialCopy);
+
+    /* And should report to work for another 5 bad frames */
+    for (unsigned int i = 0; i < 5; ++i)
+    {
+	EXPECT_CALL (*mockVSyncMethod, enableForBufferSwapType (PartialCopy, _))
+		.WillOnce (SetArgReferee <1> (false));
+
+	EXPECT_TRUE (doubleBuffer.hardwareVSyncFunctional ());
+
+	doubleBuffer.vsync (PartialCopy);
+    }
+
+    EXPECT_FALSE (doubleBuffer.hardwareVSyncFunctional ());
+}

=== modified file 'plugins/opengl/src/privates.h'
--- plugins/opengl/src/privates.h	2012-09-20 09:35:40 +0000
+++ plugins/opengl/src/privates.h	2012-09-22 03:12:18 +0000
@@ -28,6 +28,8 @@
 #ifndef _OPENGL_PRIVATES_H
 #define _OPENGL_PRIVATES_H
 
+#include <memory>
+
 #include <composite/composite.h>
 #include <opengl/opengl.h>
 #include <core/atoms.h>
@@ -44,13 +46,23 @@
 
 extern CompOutput *targetOutput;
 
+namespace compiz
+{
+    namespace opengl
+    {
+	class VSyncMethod;
+	typedef boost::shared_ptr <VSyncMethod> VSyncMethodPtr;
+    }
+}
+
 class GLDoubleBuffer :
     public compiz::opengl::DoubleBuffer
 {
     public:
 
-	GLDoubleBuffer (Display *,
-			const CompSize &);
+	GLDoubleBuffer (Display                                          *,
+			const CompSize                                   &,
+			const std::list <compiz::opengl::VSyncMethodPtr> &vsyncMethods);
 
     protected:
 
@@ -65,9 +77,10 @@
 {
     public:
 
-	GLXDoubleBuffer (Display *,
-		       const CompSize &,
-		       Window);
+	GLXDoubleBuffer (Display                                          *,
+			 const CompSize                                   &,
+			 Window                                            ,
+			 const std::list <compiz::opengl::VSyncMethodPtr> &vsyncMethods);
 
 	void swap () const;
 	bool blitAvailable () const;
@@ -88,9 +101,10 @@
 {
     public:
 
-	EGLDoubleBuffer (Display *,
-		       const CompSize &,
-		       EGLSurface const &);
+	EGLDoubleBuffer (Display                                          *,
+			 const CompSize                                   &,
+			 EGLSurface const                                 &,
+			 const std::list <compiz::opengl::VSyncMethodPtr> &vsyncMethods);
 
 	void swap () const;
 	bool blitAvailable () const;
@@ -181,12 +195,12 @@
 	#ifdef USE_GLES
 	EGLContext ctx;
 	EGLSurface surface;
-	EGLDoubleBuffer doubleBuffer;
+	std::auto_ptr <EGLDoubleBuffer> doubleBuffer;
 	#else
 	GLXContext ctx;
 
 	GL::GLXGetProcAddressProc getProcAddress;
-	GLXDoubleBuffer doubleBuffer;
+	std::auto_ptr <GLXDoubleBuffer> doubleBuffer;
 	#endif
 
 	GLFramebufferObject *scratchFbo;

=== modified file 'plugins/opengl/src/screen.cpp'
--- plugins/opengl/src/screen.cpp	2012-09-20 09:35:40 +0000
+++ plugins/opengl/src/screen.cpp	2012-09-22 03:12:18 +0000
@@ -32,7 +32,13 @@
 #endif
 #include <errno.h>
 
+#include <boost/bind.hpp>
+#include <boost/make_shared.hpp>
+
 #include "privates.h"
+#include "vsyncmethod.h"
+#include "vsync-method-swap-interval.h"
+#include "vsync-method-wait-video-sync.h"
 
 #include <dlfcn.h>
 #include <math.h>
@@ -162,7 +168,6 @@
     bool canDoSlightlySaturated = false;
 
     unsigned int vsyncCount = 0;
-    unsigned int unthrottledFrames = 0;
 
     bool stencilBuffer = false;
 #ifndef USE_GLES
@@ -271,9 +276,70 @@
     GLScreen *gScreen;
 };
 
+#ifndef USE_GLES
+
+namespace compiz
+{
+    namespace opengl
+    {
+	void swapIntervalGLX (int interval)
+	{
+	    // Docs: http://www.opengl.org/registry/specs/SGI/swap_control.txt
+	    if (GL::swapInterval)
+		(*GL::swapInterval) (interval);
+	}
+
+	int waitVSyncGLX (int          wait,
+			  int          remainder,
+			  unsigned int *count)
+	{
+	    /*
+	     * While glXSwapBuffers/glXCopySubBufferMESA are meant to do a
+	     * flush before they blit, it is best to not let that happen.
+	     * Because that flush would occur after GL::waitVideoSync, causing
+	     * a delay and the final blit to be slightly out of sync resulting
+	     * in tearing. So we need to do a glFinish before we wait for
+	     * vsync, to absolutely minimize tearing.
+	     */
+	    glFinish ();
+
+	    // Docs: http://www.opengl.org/registry/specs/SGI/video_sync.txt
+	    if (GL::waitVideoSync)
+		return (*GL::waitVideoSync) (wait, remainder, count);
+
+	    return 0;
+	}
+    }
+}
+
+#else
+
+namespace compiz
+{
+    namespace opengl
+    {
+	void swapIntervalEGL (Display *display, int interval)
+	{
+	    eglSwapInterval (eglGetDisplay (display), interval);
+	}
+
+	int waitVSyncEGL (int wait,
+			  int remainder,
+			  int *count)
+	{
+	    /* not supported */
+	    return 0;
+	}
+    }
+}
+
+#endif
+
 bool
 GLScreen::glInitContext (XVisualInfo *visinfo)
 {
+    std::list <compiz::opengl::VSyncMethod::Ptr> availableVSyncMethods;
+
     #ifdef USE_GLES
     Display             *xdpy;
     Window               overlay;
@@ -497,6 +563,14 @@
     priv->filter[SCREEN_TRANS_FILTER]  = GLTexture::Good;
     priv->filter[WINDOW_TRANS_FILTER]  = GLTexture::Good;
 
+    availableVSyncMethods.push_back (boost::make_shared <impl::SwapIntervalVSyncMethod> (
+					 boost::bind (swapIntervalEGL, screen->dpy (), _1)));
+
+    priv->doubleBuffer.reset (new EGLDoubleBuffer (screen->dpy (),
+						   *screen,
+						   priv->surface,
+						   availableVSyncMethods));
+
     if (GL::textureFromPixmap)
 	registerBindPixmap (EglTexture::bindPixmapToTexture);
 
@@ -794,6 +868,16 @@
     priv->filter[SCREEN_TRANS_FILTER]  = GLTexture::Good;
     priv->filter[WINDOW_TRANS_FILTER]  = GLTexture::Good;
 
+    availableVSyncMethods.push_back (boost::make_shared <impl::SwapIntervalVSyncMethod> (
+					 boost::bind (swapIntervalGLX, _1)));
+    availableVSyncMethods.push_back (boost::make_shared <impl::WaitVSyncMethod> (
+					 boost::bind (waitVSyncGLX, _1, _2, _3)));
+
+    priv->doubleBuffer.reset (new GLXDoubleBuffer (screen->dpy (),
+						   *screen,
+						   priv->cScreen->output (),
+						   availableVSyncMethods));
+
     if (GL::textureFromPixmap)
 	registerBindPixmap (TfpTexture::bindPixmapToTexture);
 #endif
@@ -1120,9 +1204,6 @@
     lighting (false),
     #ifndef USE_GLES
     getProcAddress (0),
-    doubleBuffer (screen->dpy (), *screen, cScreen->output ()),
-    #else
-    doubleBuffer (screen->dpy (), *screen, surface),
     #endif
     scratchFbo (NULL),
     outputRegion (),
@@ -1670,61 +1751,17 @@
     return &priv->shaderCache.getShaderData(params);
 }
 
+
+
 namespace GL
 {
 
-void
-waitForVideoSync ()
-{
-#ifndef USE_GLES
-    GL::unthrottledFrames++;
-    if (GL::waitVideoSync)
-    {
-	// Don't wait twice. Just in case.
-	if (GL::swapInterval)
-	    (*GL::swapInterval) (0);
-
-	/*
-	 * While glXSwapBuffers/glXCopySubBufferMESA are meant to do a
-	 * flush before they blit, it is best to not let that happen.
-	 * Because that flush would occur after GL::waitVideoSync, causing
-	 * a delay and the final blit to be slightly out of sync resulting
-	 * in tearing. So we need to do a glFinish before we wait for
-	 * vsync, to absolutely minimize tearing.
-	 */
-	glFinish ();
-
-	// Docs: http://www.opengl.org/registry/specs/SGI/video_sync.txt
-	unsigned int oldCount = GL::vsyncCount;
-	(*GL::waitVideoSync) (1, 0, &GL::vsyncCount);
-
-	if (GL::vsyncCount != oldCount)
-	    GL::unthrottledFrames = 0;
-    }
-#endif
-}
-
-void
-controlSwapVideoSync (bool sync)
-{
-#ifndef USE_GLES
-    // Docs: http://www.opengl.org/registry/specs/SGI/swap_control.txt
-    if (GL::swapInterval)
-    {
-	(*GL::swapInterval) (sync ? 1 : 0);
-	GL::unthrottledFrames++;
-    }
-    else if (sync)
-	waitForVideoSync ();
-#else
-    eglSwapInterval (eglGetDisplay (screen->dpy ()), sync ? 1 : 0);
-    GL::unthrottledFrames++;
-#endif
-}
-
 } // namespace GL
 
-GLDoubleBuffer::GLDoubleBuffer (Display *d, const CompSize &s) :
+GLDoubleBuffer::GLDoubleBuffer (Display                            *d,
+				const CompSize                     &s,
+				const std::list <VSyncMethod::Ptr> &vsyncMethods) :
+    compiz::opengl::DoubleBuffer (vsyncMethods),
     mDpy (d),
     mSize (s)
 {
@@ -1757,10 +1794,11 @@
     glMatrixMode (GL_MODELVIEW);
 }
 
-GLXDoubleBuffer::GLXDoubleBuffer (Display *d,
-			      const CompSize &s,
-			      Window output) :
-    GLDoubleBuffer (d, s),
+GLXDoubleBuffer::GLXDoubleBuffer (Display                          *d,
+				  const CompSize                   &s,
+				  Window                           output,
+				  const std::list <VSyncMethodPtr> &vsyncMethods) :
+    GLDoubleBuffer (d, s, vsyncMethods),
     mOutput (output)
 {
 }
@@ -1768,8 +1806,6 @@
 void
 GLXDoubleBuffer::swap () const
 {
-    GL::controlSwapVideoSync (setting[VSYNC]);
-
     glXSwapBuffers (mDpy, mOutput);
 }
 
@@ -1784,9 +1820,6 @@
 {
     const CompRect::vector &blitRects (region.rects ());
 
-    if (setting[VSYNC])
-        GL::waitForVideoSync ();
-
     foreach (const CompRect &r, blitRects)
     {
 	int y = mSize.height () - r.y2 ();
@@ -1808,9 +1841,6 @@
     int w = screen->width ();
     int h = screen->height ();
 
-    if (setting[VSYNC])
-	GL::waitForVideoSync ();
-
     glMatrixMode (GL_PROJECTION);
     glPushMatrix ();
     glLoadIdentity ();
@@ -1840,10 +1870,11 @@
 
 #else
 
-EGLDoubleBuffer::EGLDoubleBuffer (Display *d,
-			      const CompSize &s,
-			      EGLSurface const & surface) :
-    GLDoubleBuffer (d, s),
+EGLDoubleBuffer::EGLDoubleBuffer (Display                          *d,
+				  const CompSize                   &s,
+				  EGLSurface const                 &surface,
+				  const std::list <VSyncMethodPtr> &vsyncMethods) :
+    GLDoubleBuffer (d, s, vsyncMethods),
     mSurface (surface)
 {
 }
@@ -1851,8 +1882,6 @@
 void
 EGLDoubleBuffer::swap () const
 {
-    GL::controlSwapVideoSync (setting[VSYNC]);
-
     eglSwapBuffers (eglGetDisplay (mDpy), mSurface);
     eglWaitGL ();
     XFlush (mDpy);
@@ -1870,8 +1899,6 @@
     CompRect::vector blitRects (region.rects ());
     int		     y = 0;
 
-    GL::controlSwapVideoSync (setting[VSYNC]);
-
     foreach (const CompRect &r, blitRects)
     {
 	y = mSize.height () - r.y2 ();
@@ -2052,10 +2079,10 @@
                       ((mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) &&
                        commonFrontbuffer);
 
-    doubleBuffer.set (DoubleBuffer::VSYNC, optionGetSyncToVblank ());
-    doubleBuffer.set (DoubleBuffer::HAVE_PERSISTENT_BACK_BUFFER, useFbo);
-    doubleBuffer.set (DoubleBuffer::NEED_PERSISTENT_BACK_BUFFER, alwaysSwap);
-    doubleBuffer.render (tmpRegion, fullscreen);
+    doubleBuffer->set (DoubleBuffer::VSYNC, optionGetSyncToVblank ());
+    doubleBuffer->set (DoubleBuffer::HAVE_PERSISTENT_BACK_BUFFER, useFbo);
+    doubleBuffer->set (DoubleBuffer::NEED_PERSISTENT_BACK_BUFFER, alwaysSwap);
+    doubleBuffer->render (tmpRegion, fullscreen);
 
     lastMask = mask;
 }
@@ -2066,8 +2093,8 @@
    #ifdef USE_GLES
    return false;
    #else
-    return GL::waitVideoSync && optionGetSyncToVblank () && 
-           GL::unthrottledFrames < 5;
+   return GL::waitVideoSync && optionGetSyncToVblank () &&
+	  doubleBuffer->hardwareVSyncFunctional ();
    #endif
 }
 

=== added directory 'plugins/opengl/src/vsyncmethod'
=== added file 'plugins/opengl/src/vsyncmethod.h'
--- plugins/opengl/src/vsyncmethod.h	1970-01-01 00:00:00 +0000
+++ plugins/opengl/src/vsyncmethod.h	2012-09-22 03:12:18 +0000
@@ -0,0 +1,61 @@
+/*
+ * Compiz, opengl plugin, vsync methods
+ *
+ * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2008 Dennis Kasprzyk
+ * Copyright © 2007 Novell, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Dennis Kasprzyk not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Dennis Kasprzyk makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DENNIS KASPRZYK DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DENNIS KASPRZYK BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authors: Dennis Kasprzyk <[e-mail]>
+ *          David Reveman <[e-mail]>
+ *	    Daniel van Vugt <[e-mail]>
+ *	    Sam Spilsbury <[e-mail]>
+ */
+#ifndef _COMPIZ_OPENGL_VSYNC_METHOD_H
+#define _COMPIZ_OPENGL_VSYNC_METHOD_H
+
+#include <boost/shared_ptr.hpp>
+
+namespace compiz
+{
+    namespace opengl
+    {
+	typedef enum _BufferSwapType
+	{
+	    Flip,
+	    PartialCopy
+	} BufferSwapType;
+
+	class VSyncMethod
+	{
+	    public:
+
+		typedef boost::shared_ptr <VSyncMethod> Ptr;
+
+		virtual bool enableForBufferSwapType (BufferSwapType type,
+						      bool           &throttledFrame) = 0;
+		virtual void disable () = 0;
+	};
+    }
+}
+
+#endif
+

=== added file 'plugins/opengl/src/vsyncmethod/CMakeLists.txt'
--- plugins/opengl/src/vsyncmethod/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/opengl/src/vsyncmethod/CMakeLists.txt	2012-09-22 03:12:18 +0000
@@ -0,0 +1,25 @@
+INCLUDE_DIRECTORIES (
+  ${CMAKE_CURRENT_SOURCE_DIR}/../../src
+  ${CMAKE_CURRENT_SOURCE_DIR}/include
+  ${CMAKE_CURRENT_SOURCE_DIR}/src
+    
+  ${Boost_INCLUDE_DIRS}
+)
+
+LINK_DIRECTORIES (${COMPIZ_LIBRARY_DIRS}) 
+
+SET( 
+  SRCS 
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/vsync-method-swap-interval.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/vsync-method-wait-video-sync.cpp
+)
+
+ADD_LIBRARY( 
+  compiz_opengl_vsync_methods STATIC
+  
+  ${SRCS}
+)
+
+if (COMPIZ_BUILD_TESTING)
+ADD_SUBDIRECTORY( ${CMAKE_CURRENT_SOURCE_DIR}/tests )
+endif (COMPIZ_BUILD_TESTING)

=== added directory 'plugins/opengl/src/vsyncmethod/include'
=== added file 'plugins/opengl/src/vsyncmethod/include/vsync-method-swap-interval.h'
--- plugins/opengl/src/vsyncmethod/include/vsync-method-swap-interval.h	1970-01-01 00:00:00 +0000
+++ plugins/opengl/src/vsyncmethod/include/vsync-method-swap-interval.h	2012-09-22 03:12:18 +0000
@@ -0,0 +1,67 @@
+/*
+ * Compiz, opengl plugin, vsync methods
+ *
+ * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2008 Dennis Kasprzyk
+ * Copyright © 2007 Novell, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Dennis Kasprzyk not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Dennis Kasprzyk makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DENNIS KASPRZYK DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DENNIS KASPRZYK BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authors: Dennis Kasprzyk <[e-mail]>
+ *          David Reveman <[e-mail]>
+ *	    Daniel van Vugt <[e-mail]>
+ *	    Sam Spilsbury <[e-mail]>
+ */
+#ifndef _COMPIZ_OPENGL_VSYNC_METHOD_SWAP_INTERVAL_H
+#define _COMPIZ_OPENGL_VSYNC_METHOD_SWAP_INTERVAL_H
+
+#include <memory>
+#include <boost/function.hpp>
+#include <vsyncmethod.h>
+
+namespace compiz
+{
+    namespace opengl
+    {
+	namespace impl
+	{
+	    namespace cgl = compiz::opengl;
+	    typedef boost::function <void (int)> GLXSwapIntervalEXTFunc;
+
+	    class PrivateSwapIntervalVSyncMethod;
+	    class SwapIntervalVSyncMethod :
+		public cgl::VSyncMethod
+	    {
+		public:
+
+		    SwapIntervalVSyncMethod (const GLXSwapIntervalEXTFunc &swapIntervalEXT);
+
+		    bool enableForBufferSwapType (cgl::BufferSwapType type,
+						  bool		      &throttledFrame);
+		    void disable ();
+
+		private:
+
+		    std::auto_ptr <PrivateSwapIntervalVSyncMethod> priv;
+	    };
+	}
+    } // namespace opengl
+} // namespace compiz
+#endif

=== added file 'plugins/opengl/src/vsyncmethod/include/vsync-method-wait-video-sync.h'
--- plugins/opengl/src/vsyncmethod/include/vsync-method-wait-video-sync.h	1970-01-01 00:00:00 +0000
+++ plugins/opengl/src/vsyncmethod/include/vsync-method-wait-video-sync.h	2012-09-22 03:12:18 +0000
@@ -0,0 +1,67 @@
+/*
+ * Compiz, opengl plugin, vsync methods
+ *
+ * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2008 Dennis Kasprzyk
+ * Copyright © 2007 Novell, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Dennis Kasprzyk not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Dennis Kasprzyk makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DENNIS KASPRZYK DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DENNIS KASPRZYK BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authors: Dennis Kasprzyk <[e-mail]>
+ *          David Reveman <[e-mail]>
+ *	    Daniel van Vugt <[e-mail]>
+ *	    Sam Spilsbury <[e-mail]>
+ */
+#ifndef _COMPIZ_OPENGL_VSYNC_METHOD_WAIT_VIDEO_SYNC_H
+#define _COMPIZ_OPENGL_VSYNC_METHOD_WAIT_VIDEO_SYNC_H
+
+#include <memory>
+#include <boost/function.hpp>
+#include <vsyncmethod.h>
+
+namespace compiz
+{
+    namespace opengl
+    {
+	namespace impl
+	{
+	    namespace cgl = compiz::opengl;
+	    typedef boost::function <int (int, int, unsigned int *)> GLXWaitVideoSyncSGIFunc;
+
+	    class PrivateWaitVSyncMethod;
+	    class WaitVSyncMethod :
+		public cgl::VSyncMethod
+	    {
+		public:
+
+		    WaitVSyncMethod (const GLXWaitVideoSyncSGIFunc &);
+
+		    bool enableForBufferSwapType (cgl::BufferSwapType type,
+						  bool		      &throttledFrame);
+		    void disable ();
+
+		private:
+
+		    std::auto_ptr <PrivateWaitVSyncMethod> priv;
+	    };
+	}
+    } // namespace opengl
+} // namespace compiz
+#endif

=== added directory 'plugins/opengl/src/vsyncmethod/src'
=== added file 'plugins/opengl/src/vsyncmethod/src/vsync-method-swap-interval.cpp'
--- plugins/opengl/src/vsyncmethod/src/vsync-method-swap-interval.cpp	1970-01-01 00:00:00 +0000
+++ plugins/opengl/src/vsyncmethod/src/vsync-method-swap-interval.cpp	2012-09-22 03:12:18 +0000
@@ -0,0 +1,100 @@
+/*
+ * Compiz, opengl plugin, vsync methods
+ *
+ * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2008 Dennis Kasprzyk
+ * Copyright © 2007 Novell, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Dennis Kasprzyk not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Dennis Kasprzyk makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DENNIS KASPRZYK DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DENNIS KASPRZYK BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authors: Dennis Kasprzyk <[e-mail]>
+ *          David Reveman <[e-mail]>
+ *	    Daniel van Vugt <[e-mail]>
+ *	    Sam Spilsbury <[e-mail]>
+ */
+#include <vsyncmethod.h>
+#include <vsync-method-swap-interval.h>
+
+namespace compiz
+{
+    namespace opengl
+    {
+	namespace impl
+	{
+	    class PrivateSwapIntervalVSyncMethod
+	    {
+		public:
+
+		    PrivateSwapIntervalVSyncMethod (const GLXSwapIntervalEXTFunc &);
+
+		    GLXSwapIntervalEXTFunc swapInterval;
+		    bool		   enabled;
+	    };
+	}
+    }
+}
+
+namespace cgl = compiz::opengl;
+namespace cgli = compiz::opengl::impl;
+
+cgli::PrivateSwapIntervalVSyncMethod::PrivateSwapIntervalVSyncMethod (const GLXSwapIntervalEXTFunc &swapInterval) :
+    swapInterval (swapInterval),
+    enabled (false)
+{
+}
+
+cgli::SwapIntervalVSyncMethod::SwapIntervalVSyncMethod (const GLXSwapIntervalEXTFunc &swapInterval) :
+    priv (new cgli::PrivateSwapIntervalVSyncMethod (swapInterval))
+{
+
+}
+
+bool
+cgli::SwapIntervalVSyncMethod::enableForBufferSwapType (cgl::BufferSwapType swapType,
+							bool		    &throttledFrame)
+{
+    /* Always consider these frames as un-throttled as the buffer
+     * swaps are done asynchronously */
+    throttledFrame = false;
+
+    /* Can't use swapInterval unless using SwapBuffers */
+    if (swapType != cgl::Flip)
+	return false;
+
+    /* Enable if not enabled */
+    if (!priv->enabled)
+    {
+	priv->swapInterval (1);
+	priv->enabled = true;
+    }
+
+    return true;
+}
+
+void
+cgli::SwapIntervalVSyncMethod::disable ()
+{
+    /* Disable if enabled */
+    if (priv->enabled)
+    {
+	priv->swapInterval (0);
+	priv->enabled = false;
+    }
+}

=== added file 'plugins/opengl/src/vsyncmethod/src/vsync-method-wait-video-sync.cpp'
--- plugins/opengl/src/vsyncmethod/src/vsync-method-wait-video-sync.cpp	1970-01-01 00:00:00 +0000
+++ plugins/opengl/src/vsyncmethod/src/vsync-method-wait-video-sync.cpp	2012-09-22 03:12:18 +0000
@@ -0,0 +1,87 @@
+/*
+ * Compiz, opengl plugin, vsync methods
+ *
+ * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2008 Dennis Kasprzyk
+ * Copyright © 2007 Novell, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Dennis Kasprzyk not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Dennis Kasprzyk makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DENNIS KASPRZYK DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DENNIS KASPRZYK BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authors: Dennis Kasprzyk <[e-mail]>
+ *          David Reveman <[e-mail]>
+ *	    Daniel van Vugt <[e-mail]>
+ *	    Sam Spilsbury <[e-mail]>
+ */
+#include <vsyncmethod.h>
+#include <vsync-method-wait-video-sync.h>
+
+namespace compiz
+{
+    namespace opengl
+    {
+	namespace impl
+	{
+	    class PrivateWaitVSyncMethod
+	    {
+		public:
+
+		    PrivateWaitVSyncMethod (const GLXWaitVideoSyncSGIFunc &);
+
+		    GLXWaitVideoSyncSGIFunc waitVideoSync;
+		    unsigned int            lastVSyncCounter;
+	    };
+	}
+    }
+}
+
+namespace cgl = compiz::opengl;
+namespace cgli = compiz::opengl::impl;
+
+cgli::PrivateWaitVSyncMethod::PrivateWaitVSyncMethod (const cgli::GLXWaitVideoSyncSGIFunc &waitVideoSync) :
+    waitVideoSync (waitVideoSync),
+    lastVSyncCounter (0)
+{
+}
+
+cgli::WaitVSyncMethod::WaitVSyncMethod (const cgli::GLXWaitVideoSyncSGIFunc &waitVideoSync) :
+    priv (new cgli::PrivateWaitVSyncMethod (waitVideoSync))
+{
+}
+
+bool
+cgli::WaitVSyncMethod::enableForBufferSwapType (cgl::BufferSwapType swapType,
+						bool		    &throttledFrame)
+{
+    unsigned int oldVideoSyncCounter = priv->lastVSyncCounter;
+    priv->waitVideoSync (1, 0, &priv->lastVSyncCounter);
+
+    /* Check if this frame was actually throttled */
+    if (priv->lastVSyncCounter == oldVideoSyncCounter)
+	throttledFrame = false;
+    else
+	throttledFrame = true;
+
+    return true;
+}
+
+void
+cgli::WaitVSyncMethod::disable ()
+{
+}

=== added directory 'plugins/opengl/src/vsyncmethod/tests'
=== added file 'plugins/opengl/src/vsyncmethod/tests/CMakeLists.txt'
--- plugins/opengl/src/vsyncmethod/tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/opengl/src/vsyncmethod/tests/CMakeLists.txt	2012-09-22 03:12:18 +0000
@@ -0,0 +1,24 @@
+find_library (GMOCK_LIBRARY gmock)
+find_library (GMOCK_MAIN_LIBRARY gmock_main)
+
+if (NOT GMOCK_LIBRARY OR NOT GMOCK_MAIN_LIBRARY OR NOT GTEST_FOUND)
+  message ("Google Mock and Google Test not found - cannot build tests!")
+  set (COMPIZ_BUILD_TESTING OFF)
+endif (NOT GMOCK_LIBRARY OR NOT GMOCK_MAIN_LIBRARY OR NOT GTEST_FOUND)
+
+include_directories (${GTEST_INCLUDE_DIRS})
+
+link_directories (${COMPIZ_LIBRARY_DIRS})
+
+add_executable (compiz_test_opengl_vsync_methods
+                ${CMAKE_CURRENT_SOURCE_DIR}/test-opengl-vsync-methods.cpp)
+
+target_link_libraries (compiz_test_opengl_vsync_methods
+                       compiz_opengl_vsync_methods
+                       ${GTEST_BOTH_LIBRARIES}
+		       ${GMOCK_LIBRARY}
+		       ${GMOCK_MAIN_LIBRARY}
+		       ${CMAKE_THREAD_LIBS_INIT} # Link in pthread.
+                       )
+
+compiz_discover_tests (compiz_test_opengl_vsync_methods COVERAGE compiz_opengl_vsync_methods)

=== added file 'plugins/opengl/src/vsyncmethod/tests/test-opengl-vsync-methods.cpp'
--- plugins/opengl/src/vsyncmethod/tests/test-opengl-vsync-methods.cpp	1970-01-01 00:00:00 +0000
+++ plugins/opengl/src/vsyncmethod/tests/test-opengl-vsync-methods.cpp	2012-09-22 03:12:18 +0000
@@ -0,0 +1,215 @@
+/*
+ * Compiz, opengl plugin, vsync methods
+ *
+ * Copyright © 2012 Canonical Ltd.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Dennis Kasprzyk not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Dennis Kasprzyk makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DENNIS KASPRZYK DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DENNIS KASPRZYK BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authors: Sam Spilsbury <[e-mail]>
+ */
+#include <boost/bind.hpp>
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <vsync-method-wait-video-sync.h>
+#include <vsync-method-swap-interval.h>
+
+namespace cgl = compiz::opengl;
+namespace cgli = compiz::opengl::impl;
+
+using ::testing::Return;
+using ::testing::DoAll;
+using ::testing::SetArgPointee;
+using ::testing::_;
+
+namespace
+{
+    class MockOpenGLFunctionsTable
+    {
+	public:
+
+	    MOCK_METHOD3 (waitVideoSyncSGI, int (int, int, unsigned int *));
+	    MOCK_METHOD1 (swapIntervalEXT, void (int));
+    };
+
+    cgli::GLXWaitVideoSyncSGIFunc
+    GetWaitVideoSyncFuncFromMock (MockOpenGLFunctionsTable &mock)
+    {
+	return boost::bind (&MockOpenGLFunctionsTable::waitVideoSyncSGI, &mock, _1, _2, _3);
+    }
+
+    cgli::GLXSwapIntervalEXTFunc
+    GetSwapIntervalFuncFromMock (MockOpenGLFunctionsTable &mock)
+    {
+	return boost::bind (&MockOpenGLFunctionsTable::swapIntervalEXT, &mock, _1);
+    }
+}
+
+class OpenGLSwapIntervalTest :
+    public ::testing::Test
+{
+    public:
+
+	OpenGLSwapIntervalTest () :
+	    swapIntervalMethod (GetSwapIntervalFuncFromMock (functions))
+	{
+	}
+
+	MockOpenGLFunctionsTable      functions;
+	cgli::SwapIntervalVSyncMethod swapIntervalMethod;
+};
+
+class OpenGLWaitVideoSyncTest :
+    public ::testing::Test
+{
+    public:
+
+	OpenGLWaitVideoSyncTest () :
+	    waitVideoSyncMethod (GetWaitVideoSyncFuncFromMock (functions))
+	{
+	}
+
+	MockOpenGLFunctionsTable      functions;
+	cgli::WaitVSyncMethod         waitVideoSyncMethod;
+};
+
+TEST_F (OpenGLSwapIntervalTest, TestSwapIntervalOnEnableForFlip)
+{
+    bool throttled;
+    EXPECT_CALL (functions, swapIntervalEXT (1));
+    EXPECT_TRUE (swapIntervalMethod.enableForBufferSwapType (cgl::Flip, throttled));
+}
+
+TEST_F (OpenGLSwapIntervalTest, TestSwapIntervalOnEnableForFlipOnlyOnce)
+{
+    bool throttled;
+    EXPECT_CALL (functions, swapIntervalEXT (1)).Times (1);
+    EXPECT_TRUE (swapIntervalMethod.enableForBufferSwapType (cgl::Flip, throttled));
+    /* This is still meant to return true even though it does
+     * nothing it just means the operation succeeded */
+    EXPECT_TRUE (swapIntervalMethod.enableForBufferSwapType (cgl::Flip, throttled));
+}
+
+TEST_F (OpenGLSwapIntervalTest, TestSwapIntervalOnEnableForFlipAndZeroForDisable)
+{
+    bool throttled;
+    EXPECT_CALL (functions, swapIntervalEXT (1));
+    EXPECT_TRUE (swapIntervalMethod.enableForBufferSwapType (cgl::Flip, throttled));
+    EXPECT_CALL (functions, swapIntervalEXT (0));
+    swapIntervalMethod.disable ();
+}
+
+TEST_F (OpenGLSwapIntervalTest, TestSwapIntervalZeroForDisableOnce)
+{
+    bool throttled;
+    /* Enable it */
+    EXPECT_CALL (functions, swapIntervalEXT (1)).Times (1);
+    swapIntervalMethod.enableForBufferSwapType (cgl::Flip, throttled);
+
+    /* Disable it twice */
+    EXPECT_CALL (functions, swapIntervalEXT (0)).Times (1);
+    swapIntervalMethod.disable ();
+    swapIntervalMethod.disable ();
+}
+
+TEST_F (OpenGLSwapIntervalTest, TestSwapIntervalFailsToEnableForCopy)
+{
+    bool throttled;
+    EXPECT_FALSE (swapIntervalMethod.enableForBufferSwapType (cgl::PartialCopy, throttled));
+}
+
+TEST_F (OpenGLSwapIntervalTest, TestSwapIntervalUnthrottledWhereFailure)
+{
+    bool throttled;
+    EXPECT_FALSE (swapIntervalMethod.enableForBufferSwapType (cgl::PartialCopy, throttled));
+    EXPECT_FALSE (throttled);
+}
+
+TEST_F (OpenGLSwapIntervalTest, TestSwapIntervalUnthrottledWhereSuccess)
+{
+    bool throttled;
+    EXPECT_TRUE (swapIntervalMethod.enableForBufferSwapType (cgl::Flip, throttled));
+    EXPECT_FALSE (throttled);
+}
+
+TEST_F (OpenGLWaitVideoSyncTest, TestCallsGetVideoSyncAndWaitVideoSyncForCopy)
+{
+    bool throttled;
+    EXPECT_CALL (functions, waitVideoSyncSGI (_, _, _));
+    EXPECT_TRUE (waitVideoSyncMethod.enableForBufferSwapType (cgl::PartialCopy, throttled));
+}
+
+TEST_F (OpenGLWaitVideoSyncTest, TestCallsGetVideoSyncAndWaitVideoSyncForFlip)
+{
+    bool throttled;
+    EXPECT_CALL (functions, waitVideoSyncSGI (_, _, _));
+    EXPECT_TRUE (waitVideoSyncMethod.enableForBufferSwapType (cgl::Flip, throttled));
+}
+
+TEST_F (OpenGLWaitVideoSyncTest, TestCallsWaitVideoSyncAndThrottled)
+{
+    bool throttled = false;
+
+    /* Frame 0 to frame 1 */
+    EXPECT_CALL (functions, waitVideoSyncSGI (1, _, _)).WillOnce (DoAll (SetArgPointee<2> (1),
+									 Return (0)));
+    /* Returned next frame, this frame was throttled */
+    EXPECT_TRUE (waitVideoSyncMethod.enableForBufferSwapType (cgl::PartialCopy, throttled));
+    EXPECT_TRUE (throttled);
+}
+
+TEST_F (OpenGLWaitVideoSyncTest, TestCallsWaitVideoSyncAndThrottledEveryFrame)
+{
+    bool throttled = false;
+
+    /* Frame 0 to frame 1 */
+    EXPECT_CALL (functions, waitVideoSyncSGI (1, 0, _)).WillOnce (DoAll (SetArgPointee<2> (1),
+									 Return (0)));
+    /* Returned next frame, this frame was throttled */
+    EXPECT_TRUE (waitVideoSyncMethod.enableForBufferSwapType (cgl::PartialCopy, throttled));
+    EXPECT_TRUE (throttled);
+
+    /* Frame 1 to frame 2 */
+    EXPECT_CALL (functions, waitVideoSyncSGI (1, 0, _)).WillOnce (DoAll (SetArgPointee<2> (2),
+									 Return (0)));
+    /* Returned next frame, this frame was throttled */
+    EXPECT_TRUE (waitVideoSyncMethod.enableForBufferSwapType (cgl::PartialCopy, throttled));
+    EXPECT_TRUE (throttled);
+}
+
+TEST_F (OpenGLWaitVideoSyncTest, TestCallsWaitVideoSyncAndUnthrottledDueToBrokenWaitVSync)
+{
+    bool throttled = false;
+
+    /* Frame 0 to frame 1 */
+    EXPECT_CALL (functions, waitVideoSyncSGI (1, 0, _)).WillOnce (DoAll (SetArgPointee<2> (1),
+									 Return (0)));
+    /* Returned next frame, this frame was throttled */
+    EXPECT_TRUE (waitVideoSyncMethod.enableForBufferSwapType (cgl::PartialCopy, throttled));
+    EXPECT_TRUE (throttled);
+
+    /* Frame 1 to frame 1 (eg, broken waitVideoSyncSGI */
+    EXPECT_CALL (functions, waitVideoSyncSGI (1, 0, _)).WillOnce (DoAll (SetArgPointee<2> (1),
+									 Return (0)));
+    /* Returned next frame, this frame was throttled */
+    EXPECT_TRUE (waitVideoSyncMethod.enableForBufferSwapType (cgl::PartialCopy, throttled));
+    EXPECT_FALSE (throttled);
+}