refactor: Replace starboard::Mutex with std::mutex (youtube#6679)

This is part of efforts to deprecate `starboard::Mutex` and
`starboard::ConditionVariable`.
 
#vibe-coded
   
Bug: 390503926

Author: kjyoun

starboard/shared/starboard/feature_list.cc

@@ -15,6 +15,7 @@
 #include "starboard/shared/starboard/feature_list.h"
 
 #include <cstring>
+#include <mutex>
 
 #include "starboard/common/log.h"
 #include "starboard/common/once.h"
@@ -52,7 +53,7 @@ void FeatureList::InitializeFeatureList(const SbFeature* features,
   SB_CHECK(instance)
       << "Starboard FeatureList Instance has not been initialized.";
 
-  ScopedLock lock(instance->mutex_);
+  std::lock_guard lock(instance->mutex_);
 
   // Store the updated features inside of our instance's feature map.
   for (size_t i = 0; i < number_of_features; i++) {
@@ -146,7 +147,7 @@ void FeatureList::ValidateParam(const std::string& feature_name,
 // static
 bool FeatureList::IsEnabled(const SbFeature& feature) {
   FeatureList* instance = GetInstance();
-  ScopedLock lock(instance->mutex_);
+  std::lock_guard lock(instance->mutex_);
 
   // IsEnabled can only be called after the FeatureList has been initialized.
   SB_CHECK(instance->IsInitialized())
@@ -164,7 +165,7 @@ bool FeatureList::IsEnabled(const SbFeature& feature) {
 template <>
 bool FeatureList::GetParam(const SbFeatureParamExt<bool>& param) {
   FeatureList* instance = GetInstance();
-  ScopedLock lock(instance->mutex_);
+  std::lock_guard lock(instance->mutex_);
   instance->ValidateParam(param.feature_name, param.param_name,
                           SbFeatureParamTypeBool);
   return std::get<bool>(
@@ -174,7 +175,7 @@ bool FeatureList::GetParam(const SbFeatureParamExt<bool>& param) {
 template <>
 int FeatureList::GetParam(const SbFeatureParamExt<int>& param) {
   FeatureList* instance = GetInstance();
-  ScopedLock lock(instance->mutex_);
+  std::lock_guard lock(instance->mutex_);
   instance->ValidateParam(param.feature_name, param.param_name,
                           SbFeatureParamTypeInt);
   return std::get<int>(
@@ -184,7 +185,7 @@ int FeatureList::GetParam(const SbFeatureParamExt<int>& param) {
 template <>
 double FeatureList::GetParam(const SbFeatureParamExt<double>& param) {
   FeatureList* instance = GetInstance();
-  ScopedLock lock(instance->mutex_);
+  std::lock_guard lock(instance->mutex_);
   instance->ValidateParam(param.feature_name, param.param_name,
                           SbFeatureParamTypeDouble);
   return std::get<double>(
@@ -194,7 +195,7 @@ double FeatureList::GetParam(const SbFeatureParamExt<double>& param) {
 template <>
 std::string FeatureList::GetParam(const SbFeatureParamExt<std::string>& param) {
   FeatureList* instance = GetInstance();
-  ScopedLock lock(instance->mutex_);
+  std::lock_guard lock(instance->mutex_);
   instance->ValidateParam(param.feature_name, param.param_name,
                           SbFeatureParamTypeString);
   return std::get<std::string>(
@@ -204,7 +205,7 @@ std::string FeatureList::GetParam(const SbFeatureParamExt<std::string>& param) {
 template <>
 int64_t FeatureList::GetParam(const SbFeatureParamExt<int64_t>& param) {
   FeatureList* instance = GetInstance();
-  ScopedLock lock(instance->mutex_);
+  std::lock_guard lock(instance->mutex_);
   instance->ValidateParam(param.feature_name, param.param_name,
                           SbFeatureParamTypeTime);
   return std::get<int64_t>(

starboard/shared/starboard/feature_list.h

@@ -15,14 +15,14 @@
 #ifndef STARBOARD_SHARED_STARBOARD_FEATURE_LIST_H_
 #define STARBOARD_SHARED_STARBOARD_FEATURE_LIST_H_
 
+#include <mutex>
 #include <optional>
 #include <string>
 #include <type_traits>
 #include <unordered_map>
 #include <utility>
 #include <variant>
 
-#include "starboard/common/mutex.h"
 #include "starboard/extension/features.h"
 
 namespace starboard::features {
@@ -82,12 +82,12 @@ class FeatureList {
   // Mutex to ensure that in the rare chance that the FeatureList is
   // being accessed while it is initializing, we can let the instance
   // fully initialize before being accessed.
-  Mutex mutex_;
+  std::mutex mutex_;
 
   // Starboard features will be stored in an std::unordered_map, where the keys
   // are the string representations of the features, and the values are the
   // associated boolean value of the feature.
-  std::unordered_map<std::string, bool> features_;
+  std::unordered_map<std::string, bool> features_;  // Guarded by |mutex_|.
 
   // Starboard feature parameters will be stored in a 2D std::unordered_map,
   // where the outer map's keys will be the string of the feature associated

starboard/shared/starboard/player/filter/testing/adaptive_audio_decoder_test.cc

@@ -19,11 +19,11 @@
 #include <deque>
 #include <functional>
 #include <memory>
+#include <mutex>
 #include <numeric>
 #include <queue>
 #include <string>
 
-#include "starboard/common/mutex.h"
 #include "starboard/common/time.h"
 #include "starboard/configuration_constants.h"
 #include "starboard/shared/starboard/media/media_support_internal.h"
@@ -144,7 +144,7 @@ class AdaptiveAudioDecoderTest
     while (CurrentMonotonicTime() - start < kWaitForNextEventTimeOut) {
       job_queue_.RunUntilIdle();
       {
-        ScopedLock scoped_lock(event_queue_mutex_);
+        std::lock_guard lock(event_queue_mutex_);
         if (!event_queue_.empty()) {
           *event = event_queue_.front();
           event_queue_.pop_front();
@@ -199,16 +199,16 @@ class AdaptiveAudioDecoderTest
 
  private:
   void OnOutput() {
-    ScopedLock scoped_lock(event_queue_mutex_);
+    std::lock_guard lock(event_queue_mutex_);
     event_queue_.push_back(kOutput);
   }
   void OnError() {
-    ScopedLock scoped_lock(event_queue_mutex_);
+    std::lock_guard lock(event_queue_mutex_);
     event_queue_.push_back(kError);
   }
 
   void OnConsumed() {
-    ScopedLock scoped_lock(event_queue_mutex_);
+    std::lock_guard lock(event_queue_mutex_);
     event_queue_.push_back(kConsumed);
   }
 
@@ -277,7 +277,7 @@ class AdaptiveAudioDecoderTest
   JobQueue job_queue_;
   std::unique_ptr<AudioDecoder> audio_decoder_;
 
-  Mutex event_queue_mutex_;
+  std::mutex event_queue_mutex_;
   std::deque<Event> event_queue_;
   bool can_accept_more_input_ = true;
 };

starboard/shared/starboard/player/filter/testing/audio_decoder_test.cc

@@ -21,13 +21,12 @@
 #include <functional>
 #include <map>
 #include <memory>
+#include <mutex>
 #include <string>
 #include <utility>
 #include <vector>
 
-#include "starboard/common/condition_variable.h"
 #include "starboard/common/media.h"
-#include "starboard/common/mutex.h"
 #include "starboard/common/ref_counted.h"
 #include "starboard/common/time.h"
 #include "starboard/configuration_constants.h"
@@ -133,17 +132,17 @@ class AudioDecoderTest
   }
 
   void OnOutput() {
-    ScopedLock scoped_lock(event_queue_mutex_);
+    std::lock_guard lock(event_queue_mutex_);
     event_queue_.push_back(kOutput);
   }
 
   void OnError() {
-    ScopedLock scoped_lock(event_queue_mutex_);
+    std::lock_guard lock(event_queue_mutex_);
     event_queue_.push_back(kError);
   }
 
   void OnConsumed() {
-    ScopedLock scoped_lock(event_queue_mutex_);
+    std::lock_guard lock(event_queue_mutex_);
     event_queue_.push_back(kConsumed);
   }
 
@@ -152,7 +151,7 @@ class AudioDecoderTest
     while (CurrentMonotonicTime() - start < kWaitForNextEventTimeOut) {
       job_queue_.RunUntilIdle();
       {
-        ScopedLock scoped_lock(event_queue_mutex_);
+        std::lock_guard lock(event_queue_mutex_);
         if (!event_queue_.empty()) {
           *event = event_queue_.front();
           event_queue_.pop_front();
@@ -344,7 +343,7 @@ class AudioDecoderTest
     decoded_audio_sample_rate_ = 0;
     first_output_received_ = false;
     {
-      ScopedLock scoped_lock(event_queue_mutex_);
+      std::lock_guard lock(event_queue_mutex_);
       event_queue_.clear();
     }
   }
@@ -468,7 +467,7 @@ class AudioDecoderTest
     ASSERT_LE(abs(expected_output_frames - GetTotalFrames(decoded_audios_)), 1);
   }
 
-  Mutex event_queue_mutex_;
+  std::mutex event_queue_mutex_;
   std::deque<Event> event_queue_;
 
   // Test parameter for the filename to load with the VideoDmpReader.