Implement SkCondVar for windows.

Only works on Vista or later, since it uses condition variables.

Review URL: https://codereview.appspot.com/6812062

git-svn-id: http://skia.googlecode.com/svn/trunk@6225 2bbb7eff-a529-9590-31e7-b0007b416f81

gyp/utils.gyp

@@ -156,15 +156,6 @@
             '../src/utils/SkThreadUtils_pthread.cpp',
             '../src/utils/SkThreadUtils_pthread.h',
             '../src/utils/SkThreadUtils_pthread_other.cpp',
-
-            # SkThreadPool and related currently depend on pthread.
-            '../include/utils/SkCondVar.h',
-            '../include/utils/SkCountdown.h',
-            '../include/utils/SkRunnable.h',
-            '../include/utils/SkThreadPool.h',
-            '../src/utils/SkCondVar.cpp',
-            '../src/utils/SkCountdown.cpp',
-            '../src/utils/SkThreadPool.cpp',
           ],
         },{ #else if 'skia_os != "win"'
           'include_dirs!': [

include/utils/SkCondVar.h

@@ -8,19 +8,38 @@
 #ifndef SkCondVar_DEFINED
 #define SkCondVar_DEFINED
 
+#ifdef SK_USE_POSIX_THREADS
 #include <pthread.h>
+#elif defined(SK_BUILD_FOR_WIN32)
+#include <Windows.h>
+#endif
 
+/**
+ * Condition variable for blocking access to shared data from other threads and
+ * controlling which threads are awake.
+ *
+ * Currently only supported on platforms with posix threads and Windows Vista and
+ * above.
+ */
 class SkCondVar {
 public:
     SkCondVar();
     ~SkCondVar();
 
+    /**
+     * Lock a mutex. Must be done before calling the other functions on this object.
+     */
     void lock();
+
+    /**
+     * Unlock the mutex.
+     */
     void unlock();
 
     /**
-     * Pause the calling thread. Will be awoken when signal() is called.
-     * Must be called while lock() is held (but gives it up while waiting).
+     * Pause the calling thread. Will be awoken when signal() or broadcast() is called.
+     * Must be called while lock() is held (but gives it up while waiting). Once awoken,
+     * the calling thread will hold the lock once again.
      */
     void wait();
 
@@ -37,9 +56,13 @@ public:
     void broadcast();
 
 private:
-    // FIXME: Make this independent of pthreads.
+#ifdef SK_USE_POSIX_THREADS
     pthread_mutex_t  fMutex;
     pthread_cond_t   fCond;
+#elif defined(SK_BUILD_FOR_WIN32)
+    CRITICAL_SECTION   fCriticalSection;
+    CONDITION_VARIABLE fCondition;
+#endif
 };
 
 #endif

src/utils/SkCondVar.cpp

@@ -8,31 +8,61 @@
 #include "SkCondVar.h"
 
 SkCondVar::SkCondVar() {
+#ifdef SK_USE_POSIX_THREADS
     pthread_mutex_init(&fMutex, NULL /* default mutex attr */);
     pthread_cond_init(&fCond, NULL /* default cond attr */);
+#elif defined(SK_BUILD_FOR_WIN32)
+    InitializeCriticalSection(&fCriticalSection);
+    InitializeConditionVariable(&fCondition);
+#endif
 }
 
 SkCondVar::~SkCondVar() {
+#ifdef SK_USE_POSIX_THREADS
     pthread_mutex_destroy(&fMutex);
     pthread_cond_destroy(&fCond);
+#elif defined(SK_BUILD_FOR_WIN32)
+    DeleteCriticalSection(&fCriticalSection);
+    // No need to clean up fCondition.
+#endif
 }
 
 void SkCondVar::lock() {
+#ifdef SK_USE_POSIX_THREADS
     pthread_mutex_lock(&fMutex);
+#elif defined(SK_BUILD_FOR_WIN32)
+    EnterCriticalSection(&fCriticalSection);
+#endif
 }
 
 void SkCondVar::unlock() {
+#ifdef SK_USE_POSIX_THREADS
     pthread_mutex_unlock(&fMutex);
+#elif defined(SK_BUILD_FOR_WIN32)
+    LeaveCriticalSection(&fCriticalSection);
+#endif
 }
 
 void SkCondVar::wait() {
+#ifdef SK_USE_POSIX_THREADS
     pthread_cond_wait(&fCond, &fMutex);
+#elif defined(SK_BUILD_FOR_WIN32)
+    SleepConditionVariableCS(&fCondition, &fCriticalSection, INFINITE);
+#endif
 }
 
 void SkCondVar::signal() {
+#ifdef SK_USE_POSIX_THREADS
     pthread_cond_signal(&fCond);
+#elif defined(SK_BUILD_FOR_WIN32)
+    WakeConditionVariable(&fCondition);
+#endif
 }
 
 void SkCondVar::broadcast() {
+#ifdef SK_USE_POSIX_THREADS
     pthread_cond_broadcast(&fCond);
+#elif defined(SK_BUILD_FOR_WIN32)
+    WakeAllConditionVariable(&fCondition);
+#endif
 }