Bug 1083101 - rename gfx::Mutex into gfx::CriticalSection and move it to its own file. r=jrmuizel

gfx/2d/CriticalSection.h

@@ -0,0 +1,80 @@
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef MOZILLA_GFX_CRITICALSECTION_H_
+#define MOZILLA_GFX_CRITICALSECTION_H_
+
+#ifdef WIN32
+#include <windows.h>
+#else
+#include <pthread.h>
+#include "mozilla/DebugOnly.h"
+#endif
+
+namespace mozilla {
+namespace gfx {
+
+#ifdef WIN32
+
+class CriticalSection {
+public:
+  CriticalSection() { ::InitializeCriticalSection(&mCriticalSection); }
+
+  ~CriticalSection() { ::DeleteCriticalSection(&mCriticalSection); }
+
+  void Enter() { ::EnterCriticalSection(&mCriticalSection); }
+
+  void Leave() { ::LeaveCriticalSection(&mCriticalSection); }
+
+protected:
+  CRITICAL_SECTION mCriticalSection;
+};
+
+#else
+// posix
+
+class PosixCondvar;
+class CriticalSection {
+public:
+  CriticalSection() {
+    DebugOnly<int> err = pthread_mutex_init(&mMutex, nullptr);
+    MOZ_ASSERT(!err);
+  }
+
+  ~CriticalSection() {
+    DebugOnly<int> err = pthread_mutex_destroy(&mMutex);
+    MOZ_ASSERT(!err);
+  }
+
+  void Enter() {
+    DebugOnly<int> err = pthread_mutex_lock(&mMutex);
+    MOZ_ASSERT(!err);
+  }
+
+  void Leave() {
+    DebugOnly<int> err = pthread_mutex_unlock(&mMutex);
+    MOZ_ASSERT(!err);
+  }
+
+protected:
+  pthread_mutex_t mMutex;
+  friend class PosixCondVar;
+};
+
+#endif
+
+/// RAII helper.
+struct CriticalSectionAutoEnter {
+    explicit CriticalSectionAutoEnter(CriticalSection* aSection) : mSection(aSection) { mSection->Enter(); }
+    ~CriticalSectionAutoEnter() { mSection->Leave(); }
+protected:
+    CriticalSection* mSection;
+};
+
+
+} // namespace
+} // namespace
+
+#endif

gfx/2d/TaskScheduler.cpp

@@ -175,7 +175,7 @@ SyncObject::Signal()
 void
 SyncObject::AddWaitingTask(Task* aTask)
 {
-  MutexAutoLock lock(&mMutex);
+  CriticalSectionAutoEnter lock(&mWaitingTasksSection);
   mWaitingTasks.push_back(aTask);
 }
 
@@ -190,7 +190,7 @@ void SyncObject::SubmitWaitingTasks()
     // hold a strong ref to prevent that!
     RefPtr<SyncObject> kungFuDeathGrip(this);
 
-    MutexAutoLock lock(&mMutex);
+    CriticalSectionAutoEnter lock(&mWaitingTasksSection);
     tasksToSubmit = Move(mWaitingTasks);
     mWaitingTasks.clear();
   }

gfx/2d/TaskScheduler.h

@@ -195,7 +195,7 @@ private:
 #endif
 
   std::vector<Task*> mWaitingTasks;
-  Mutex mMutex; // for concurrent access to mWaintingTasks
+  CriticalSection mWaitingTasksSection; // for concurrent access to mWaintingTasks
   Atomic<uint32_t> mSignals;
   Atomic<bool> mHasSubmittedSubsequent;
 
@@ -203,15 +203,6 @@ private:
   friend class TaskScheduler;
 };
 
-
-/// RAII helper.
-struct MutexAutoLock {
-    MutexAutoLock(Mutex* aMutex) : mMutex(aMutex) { mMutex->Lock(); }
-    ~MutexAutoLock() { mMutex->Unlock(); }
-protected:
-    Mutex* mMutex;
-};
-
 /// Base class for worker threads.
 class WorkerThread
 {

gfx/2d/TaskScheduler_posix.h

@@ -16,6 +16,7 @@
 
 #include "mozilla/RefPtr.h"
 #include "mozilla/DebugOnly.h"
+#include "mozilla/gfx/CriticalSection.h"
 
 namespace mozilla {
 namespace gfx {
@@ -24,32 +25,8 @@ class Task;
 class PosixCondVar;
 class WorkerThread;
 
-class Mutex {
-public:
-  Mutex() {
-    DebugOnly<int> err = pthread_mutex_init(&mMutex, nullptr);
-    MOZ_ASSERT(!err);
-  }
-
-  ~Mutex() {
-    DebugOnly<int> err = pthread_mutex_destroy(&mMutex);
-    MOZ_ASSERT(!err);
-  }
-
-  void Lock() {
-    DebugOnly<int> err = pthread_mutex_lock(&mMutex);
-    MOZ_ASSERT(!err);
-  }
-
-  void Unlock() {
-    DebugOnly<int> err = pthread_mutex_unlock(&mMutex);
-    MOZ_ASSERT(!err);
-  }
-
-protected:
-  pthread_mutex_t mMutex;
-  friend class PosixCondVar;
-};
+typedef mozilla::gfx::CriticalSection Mutex;
+typedef mozilla::gfx::CriticalSectionAutoEnter MutexAutoLock;
 
 // posix platforms only!
 class PosixCondVar {

gfx/2d/TaskScheduler_win32.cpp

@@ -50,7 +50,7 @@ MultiThreadedTaskQueue::PopTask(Task*& aOutTask, AccessType aAccess)
   for (;;) {
     while (aAccess == BLOCKING && mTasks.empty()) {
       {
-        MutexAutoLock lock(&mMutex);
+        CriticalSectionAutoEnter lock(&mSection);
         if (mShuttingDown) {
           return false;
         }
@@ -60,7 +60,7 @@ MultiThreadedTaskQueue::PopTask(Task*& aOutTask, AccessType aAccess)
       ::WaitForMultipleObjects(2, handles, FALSE, INFINITE);
     }
 
-    MutexAutoLock lock(&mMutex);
+    CriticalSectionAutoEnter lock(&mSection);
 
     if (mShuttingDown) {
       return false;
@@ -92,7 +92,7 @@ MultiThreadedTaskQueue::SubmitTask(Task* aTask)
 {
   MOZ_ASSERT(aTask);
   MOZ_ASSERT(aTask->GetTaskQueue() == this);
-  MutexAutoLock lock(&mMutex);
+  CriticalSectionAutoEnter lock(&mSection);
   mTasks.push_back(aTask);
   ::SetEvent(mAvailableEvent);
 }
@@ -101,7 +101,7 @@ void
 MultiThreadedTaskQueue::ShutDown()
 {
   {
-    MutexAutoLock lock(&mMutex);
+    CriticalSectionAutoEnter lock(&mSection);
     mShuttingDown = true;
   }
   while (mThreadsCount) {
@@ -113,14 +113,14 @@ MultiThreadedTaskQueue::ShutDown()
 size_t
 MultiThreadedTaskQueue::NumTasks()
 {
-  MutexAutoLock lock(&mMutex);
+  CriticalSectionAutoEnter lock(&mSection);
   return mTasks.size();
 }
 
 bool
 MultiThreadedTaskQueue::IsEmpty()
 {
-  MutexAutoLock lock(&mMutex);
+  CriticalSectionAutoEnter lock(&mSection);
   return mTasks.empty();
 }
 
@@ -133,7 +133,7 @@ MultiThreadedTaskQueue::RegisterThread()
 void
 MultiThreadedTaskQueue::UnregisterThread()
 {
-  MutexAutoLock lock(&mMutex);
+  CriticalSectionAutoEnter lock(&mSection);
   mThreadsCount -= 1;
   if (mThreadsCount == 0) {
     ::SetEvent(mShutdownEvent);

gfx/2d/TaskScheduler_win32.h

@@ -10,6 +10,7 @@
 #define NOT_IMPLEMENTED MOZ_CRASH("Not implemented")
 
 #include "mozilla/RefPtr.h"
+#include "mozilla/gfx/CriticalSection.h"
 #include <windows.h>
 #include <list>
 
@@ -19,41 +20,6 @@ namespace gfx {
 class WorkerThread;
 class Task;
 
-class Mutex {
-public:
-  Mutex() {
-    ::InitializeCriticalSection(&mMutex);
-#ifdef DEBUG
-    mOwner = 0;
-#endif
-  }
-
-  ~Mutex() { ::DeleteCriticalSection(&mMutex); }
-
-  void Lock() {
-    ::EnterCriticalSection(&mMutex);
-#ifdef DEBUG
-    MOZ_ASSERT(mOwner != GetCurrentThreadId(), "recursive locking");
-    mOwner = GetCurrentThreadId();
-#endif
-  }
-
-  void Unlock() {
-#ifdef DEBUG
-    // GetCurrentThreadId cannot return 0: it is not a valid thread id
-    MOZ_ASSERT(mOwner == GetCurrentThreadId(), "mismatched lock/unlock");
-    mOwner = 0;
-#endif
-    ::LeaveCriticalSection(&mMutex);
-  }
-
-protected:
-  CRITICAL_SECTION mMutex;
-#ifdef DEBUG
-  DWORD mOwner;
-#endif
-};
-
 // The public interface of this class must remain identical to its equivalent
 // in TaskScheduler_posix.h
 class MultiThreadedTaskQueue {
@@ -95,7 +61,7 @@ public:
 
 protected:
   std::list<Task*> mTasks;
-  Mutex mMutex;
+  CriticalSection mSection;
   HANDLE mAvailableEvent;
   HANDLE mShutdownEvent;
   int32_t mThreadsCount;

gfx/2d/moz.build

@@ -20,6 +20,7 @@ EXPORTS.mozilla.gfx += [
     'Blur.h',
     'BorrowedContext.h',
     'Coord.h',
+    'CriticalSection.h',
     'DataSurfaceHelpers.h',
     'DrawTargetTiled.h',
     'Filters.h',

gfx/tests/gtest/TestTaskScheduler.cpp

@@ -35,7 +35,7 @@ void MaybeYieldThread()
 /// Used by the TestCommand to check that tasks are processed in the right order.
 struct SanityChecker {
   std::vector<uint64_t> mAdvancements;
-  mozilla::gfx::Mutex mMutex;
+  mozilla::gfx::CriticalSection mSection;
 
   explicit SanityChecker(uint64_t aNumCmdBuffers)
   {
@@ -47,7 +47,7 @@ struct SanityChecker {
   virtual void Check(uint64_t aTaskId, uint64_t aCmdId)
   {
     MaybeYieldThread();
-    MutexAutoLock lock(&mMutex);
+    CriticalSectionAutoEnter lock(&mSection);
     ASSERT_EQ(mAdvancements[aTaskId], aCmdId-1);
     mAdvancements[aTaskId] = aCmdId;
   }