Migrate to pthread_mutex/pthread_cond (youtube#3357)

Test-On-Device: true
b/302335657

Change-Id: Id95117ee26d3c67efcee47403588f1382896302d

base/logging.cc

@@ -49,7 +49,7 @@
 #include "starboard/file.h"
 #include "starboard/system.h"
 typedef SbFile FileHandle;
-typedef SbMutex MutexHandle;
+typedef pthread_mutex_t MutexHandle;
 #else
 #if BUILDFLAG(IS_WIN)
 #include <io.h>

base/synchronization/condition_variable.h

@@ -70,8 +70,12 @@
 #include "base/synchronization/lock.h"
 
 #if defined(STARBOARD)
+#if SB_API_VERSION < 16
 #include "starboard/condition_variable.h"
 #else
+#include <pthread.h>
+#endif  // SB_API_VERSION < 16
+#else
 #if BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
 #include <pthread.h>
 #endif
@@ -118,8 +122,13 @@ class BASE_EXPORT ConditionVariable {
 
  private:
 #if defined(STARBOARD)
+#if SB_API_VERSION < 16
   SbConditionVariable condition_;
   SbMutex* user_mutex_;
+#else
+  pthread_cond_t condition_;
+  pthread_mutex_t* user_mutex_;
+#endif  // SB_API_VERSION < 16
 #elif BUILDFLAG(IS_WIN)
   CHROME_CONDITION_VARIABLE cv_;
   const raw_ptr<CHROME_SRWLOCK> srwlock_;

base/synchronization/condition_variable_starboard.cc

@@ -30,13 +30,34 @@ ConditionVariable::ConditionVariable(Lock* user_lock)
       user_lock_(user_lock)
 #endif
 {
+#if SB_API_VERSION < 16
   bool result = SbConditionVariableCreate(&condition_, user_mutex_);
   DCHECK(result);
+#else
+#if !SB_HAS_QUIRK(NO_CONDATTR_SETCLOCK_SUPPORT)
+  pthread_condattr_t attribute;
+  pthread_condattr_init(&attribute);
+  pthread_condattr_setclock(&attribute, CLOCK_MONOTONIC);
+
+  int result = pthread_cond_init(&condition_, &attribute);
+  DCHECK(result == 0);
+
+  pthread_condattr_destroy(&attribute);
+#else
+  int result = pthread_cond_init(&condition_, nullptr);
+  DCHECK(result == 0);
+#endif  // !SB_HAS_QUIRK(NO_CONDATTR_SETCLOCK_SUPPORT)
+#endif  // SB_API_VERSION < 16
 }
 
 ConditionVariable::~ConditionVariable() {
+#if SB_API_VERSION < 16
   bool result = SbConditionVariableDestroy(&condition_);
   DCHECK(result);
+#else
+  int result = pthread_cond_destroy(&condition_);
+  DCHECK(result == 0);
+#endif  // SB_API_VERSION < 16
 }
 
 void ConditionVariable::Wait() {
@@ -48,9 +69,14 @@ void ConditionVariable::Wait() {
 #if DCHECK_IS_ON()
   user_lock_->CheckHeldAndUnmark();
 #endif
-  SbConditionVariableResult result =
+#if SB_API_VERSION < 16
+ SbConditionVariableResult result =
       SbConditionVariableWait(&condition_, user_mutex_);
   DCHECK(SbConditionVariableIsSignaled(result));
+#else
+  int result = pthread_cond_wait(&condition_, user_mutex_);
+  DCHECK(result == 0);
+#endif  // SB_API_VERSION < 16
 #if DCHECK_IS_ON()
   user_lock_->CheckUnheldAndMark();
 #endif
@@ -66,22 +92,48 @@ void ConditionVariable::TimedWait(const TimeDelta& max_time) {
 #if DCHECK_IS_ON()
   user_lock_->CheckHeldAndUnmark();
 #endif
+#if SB_API_VERSION < 16
   SbConditionVariableResult result =
       SbConditionVariableWaitTimed(&condition_, user_mutex_, duration);
   DCHECK_NE(kSbConditionVariableFailed, result);
+#else
+#if !SB_HAS_QUIRK(NO_CONDATTR_SETCLOCK_SUPPORT)
+  int64_t timeout_time_usec = starboard::CurrentMonotonicTime();
+#else
+  int64_t timeout_time_usec = starboard::CurrentPosixTime();
+#endif  // !SB_HAS_QUIRK(NO_CONDATTR_SETCLOCK_SUPPORT)
+  timeout_time_usec += max_time.InMicroseconds();
+
+  struct timespec timeout;
+  timeout.tv_sec = timeout_time_usec / 1000'000;
+  timeout.tv_nsec = (timeout_time_usec % 1000'000) * 1000;
+
+  int result = pthread_cond_timedwait(&condition_, user_mutex_, &timeout);
+  DCHECK(result == 0 || result == ETIMEDOUT);
+#endif
 #if DCHECK_IS_ON()
   user_lock_->CheckUnheldAndMark();
 #endif
 }
 
 void ConditionVariable::Broadcast() {
+#if SB_API_VERSION < 16
   bool result = SbConditionVariableBroadcast(&condition_);
   DCHECK(result);
+#else
+  int result = pthread_cond_broadcast(&condition_);
+  DCHECK(result == 0);
+#endif  // SB_API_VERSION < 16
 }
 
 void ConditionVariable::Signal() {
+#if SB_API_VERSION < 16
   bool result = SbConditionVariableSignal(&condition_);
   DCHECK(result);
+#else
+  int result = pthread_cond_signal(&condition_);
+  DCHECK(result == 0);
+#endif  // SB_API_VERSION < 16
 }
 
 }  // namespace base

base/synchronization/lock_impl.h

@@ -12,7 +12,11 @@
 #include "build/build_config.h"
 
 #if defined(STARBOARD)
+#if SB_API_VERSION < 16
 #include "starboard/common/mutex.h"
+#else
+#include <pthread.h>
+#endif
 #include "base/check_op.h"
 #elif BUILDFLAG(IS_WIN)
 #include "base/win/windows_types.h"
@@ -49,7 +53,11 @@ class BASE_EXPORT LockImpl {
   friend class base::win::internal::ScopedHandleVerifier;
 
 #if defined(STARBOARD)
+#if SB_API_VERSION < 16
   using NativeHandle = SbMutex;
+#else
+  using NativeHandle = pthread_mutex_t;
+#endif  // SB_API_VERSION < 16
 #elif BUILDFLAG(IS_WIN)
   using NativeHandle = CHROME_SRWLOCK;
 #elif BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
@@ -100,14 +108,24 @@ void LockImpl::Lock() {
 
 #if defined(STARBOARD)
 bool LockImpl::Try() {
+#if SB_API_VERSION < 16
   SbMutexResult result = SbMutexAcquireTry(&native_handle_);
   DCHECK_NE(kSbMutexDestroyed, result);
   return SbMutexIsSuccess(result);
+#else
+  int result = pthread_mutex_trylock(&native_handle_);
+  return result  == 0;
+#endif  // SB_API_VERSION < 16
 }
 
 void LockImpl::Unlock() {
+#if SB_API_VERSION < 16
   bool result = SbMutexRelease(&native_handle_);
   DCHECK(result);
+#else
+  int result = pthread_mutex_unlock(&native_handle_);
+  DCHECK(result == 0);
+#endif  //SB_API_VERSION < 16
 }
 #elif BUILDFLAG(IS_WIN)
 bool LockImpl::Try() {

base/synchronization/lock_impl_starboard.cc

@@ -15,24 +15,42 @@
 #include "base/synchronization/lock_impl.h"
 
 #include "base/check_op.h"
-#include "starboard/common/mutex.h"
+
+#if SB_API_VERSION < 16
+#include "starboard/mutex.h"
+#endif  // SB_API_VERSION < 16
 
 namespace base {
 namespace internal {
 
 LockImpl::LockImpl() {
+#if SB_API_VERSION < 16
   bool result = SbMutexCreate(&native_handle_);
   DCHECK(result);
+#else
+  int result = pthread_mutex_init(&native_handle_, nullptr);
+  DCHECK_EQ(result, 0);
+#endif  // SB_API_VERSION < 16
 }
 
 LockImpl::~LockImpl() {
+#if SB_API_VERSION < 16
   bool result = SbMutexDestroy(&native_handle_);
   DCHECK(result);
+#else
+  int result = pthread_mutex_destroy(&native_handle_);
+  DCHECK_EQ(result, 0);
+#endif  // SB_API_VERSION < 16
 }
 
 void LockImpl::LockInternal() {
+#if SB_API_VERSION < 16
   SbMutexResult result = SbMutexAcquire(&native_handle_);
   DCHECK_NE(kSbMutexDestroyed, result);
+#else
+  int result = pthread_mutex_lock(&native_handle_);
+  DCHECK_EQ(result, 0);
+#endif  // SB_API_VERSION < 16
 }
 
 }  // namespace internal

cobalt/renderer/rasterizer/skia/skia/src/ports/SkMutex_starboard.h

@@ -87,8 +87,7 @@ class SkMutex : public SkBaseMutex {
   ~SkMutex() { pthread_mutex_destroy(&mutex_); }
 };
 
-#define SK_BASE_MUTEX_INIT \
-  { SB_MUTEX_INITIALIZER }
+#define SK_BASE_MUTEX_INIT {PTHREAD_MUTEX_INITIALIZER}
 
 // Using POD-style initialization prevents the generation of a static
 // initializer.

starboard/android/shared/log_format.cc

@@ -12,15 +12,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include <pthread.h>
 #include <stdio.h>
+
 #include <string>
 
 #include "starboard/common/log.h"
-#include "starboard/common/mutex.h"
 #include "starboard/common/string.h"
 
 namespace {
-SbMutex log_line_mutex = SB_MUTEX_INITIALIZER;
+pthread_mutex_t log_line_mutex = PTHREAD_MUTEX_INITIALIZER;
 std::stringstream log_line;
 const int kFormatBufferSizeBytes = 16 * 1024;
 
@@ -39,7 +40,7 @@ void SbLogFormat(const char* format, va_list arguments) {
 
   const char* newline = strchr(formatted_buffer, '\n');
 
-  SbMutexAcquire(&log_line_mutex);
+  pthread_mutex_lock(&log_line_mutex);
   std::string buffer_string(formatted_buffer);
   log_line << buffer_string;
   if (newline != NULL) {
@@ -50,5 +51,5 @@ void SbLogFormat(const char* format, va_list arguments) {
     log_line.str("");
     log_line.clear();
   }
-  SbMutexRelease(&log_line_mutex);
+  pthread_mutex_unlock(&log_line_mutex);
 }

starboard/common/condition_variable.cc

@@ -14,37 +14,90 @@
 
 #include "starboard/common/condition_variable.h"
 
+#include <sys/time.h>
+
+#include "starboard/common/log.h"
+#include "starboard/common/time.h"
+
 namespace starboard {
 
 ConditionVariable::ConditionVariable(const Mutex& mutex)
     : mutex_(&mutex), condition_() {
+#if SB_API_VERSION < 16
   SbConditionVariableCreate(&condition_, mutex_->mutex());
+#else
+#if !SB_HAS_QUIRK(NO_CONDATTR_SETCLOCK_SUPPORT)
+  pthread_condattr_t attribute;
+  pthread_condattr_init(&attribute);
+  pthread_condattr_setclock(&attribute, CLOCK_MONOTONIC);
+
+  int result = pthread_cond_init(&condition_, &attribute);
+  SB_DCHECK(result == 0);
+
+  pthread_condattr_destroy(&attribute);
+#else
+  int result = pthread_cond_init(&condition_, nullptr);
+  SB_DCHECK(result == 0);
+#endif  // !SB_HAS_QUIRK(NO_CONDATTR_SETCLOCK_SUPPORT)
+#endif  // SB_API_VERSION < 16
 }
 
 ConditionVariable::~ConditionVariable() {
+#if SB_API_VERSION < 16
   SbConditionVariableDestroy(&condition_);
+#else
+  pthread_cond_destroy(&condition_);
+#endif  // SB_API_VERSION < 16
 }
 
 void ConditionVariable::Wait() const {
   mutex_->debugSetReleased();
+#if SB_API_VERSION < 16
   SbConditionVariableWait(&condition_, mutex_->mutex());
+#else
+  pthread_cond_wait(&condition_, mutex_->mutex());
+#endif  // SB_API_VERSION < 16
   mutex_->debugSetAcquired();
 }
 
 bool ConditionVariable::WaitTimed(int64_t duration) const {
   mutex_->debugSetReleased();
+#if SB_API_VERSION < 16
   bool was_signaled = SbConditionVariableIsSignaled(
       SbConditionVariableWaitTimed(&condition_, mutex_->mutex(), duration));
+#else
+#if !SB_HAS_QUIRK(NO_CONDATTR_SETCLOCK_SUPPORT)
+  int64_t timeout_time_usec = starboard::CurrentMonotonicTime();
+#else
+  int64_t timeout_time_usec = starboard::CurrentPosixTime();
+#endif  // !SB_HAS_QUIRK(NO_CONDATTR_SETCLOCK_SUPPORT)
+  timeout_time_usec += duration;
+
+  struct timespec timeout;
+  timeout.tv_sec = timeout_time_usec / 1000'000;
+  timeout.tv_nsec = (timeout_time_usec % 1000'000) * 1000;
+
+  bool was_signaled =
+      pthread_cond_timedwait(&condition_, mutex_->mutex(), &timeout) == 0;
+#endif  // SB_API_VERSION < 16
   mutex_->debugSetAcquired();
   return was_signaled;
 }
 
 void ConditionVariable::Broadcast() const {
+#if SB_API_VERSION < 16
   SbConditionVariableBroadcast(&condition_);
+#else
+  pthread_cond_broadcast(&condition_);
+#endif  // SB_API_VERSION < 16
 }
 
 void ConditionVariable::Signal() const {
+#if SB_API_VERSION < 16
   SbConditionVariableSignal(&condition_);
+#else
+  pthread_cond_signal(&condition_);
+#endif  // SB_API_VERSION < 16
 }
 
 }  // namespace starboard

starboard/common/condition_variable.h

@@ -20,13 +20,15 @@
 #ifndef STARBOARD_COMMON_CONDITION_VARIABLE_H_
 #define STARBOARD_COMMON_CONDITION_VARIABLE_H_
 
-#include "starboard/common/mutex.h"
+#include <pthread.h>
 #include "starboard/condition_variable.h"
+
+#include "starboard/common/mutex.h"
 #include "starboard/types.h"
 
 namespace starboard {
 
-// Inline class wrapper for SbConditionVariable.
+// Inline class wrapper for pthread_cond_t.
 class ConditionVariable {
  public:
   explicit ConditionVariable(const Mutex& mutex);
@@ -47,7 +49,11 @@ class ConditionVariable {
 
  private:
   const Mutex* mutex_;
+#if SB_API_VERSION < 16
   mutable SbConditionVariable condition_;
+#else
+  mutable pthread_cond_t condition_;
+#endif  // SB_API_VERSION < 16
 };
 
 }  // namespace starboard