Fix ThreadGroup unit tests for cobalt.

Change-Id: Ia66459ceddaba98b2187ae2c874260983a9cc8af
youtube · Jan 18, 2024 · c8c8377 · c8c8377
1 parent 012fd2e
commit c8c8377
Show file tree

Hide file tree

Showing 4 changed files with 34 additions and 9 deletions.
diff --git a/base/synchronization/condition_variable_starboard.cc b/base/synchronization/condition_variable_starboard.cc
@@ -25,7 +25,7 @@ namespace base {
 
 ConditionVariable::ConditionVariable(Lock* user_lock)
     : user_mutex_(user_lock->lock_.native_handle())
-#if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
+#if DCHECK_IS_ON()
       ,
       user_lock_(user_lock)
 #endif
@@ -40,31 +40,36 @@ ConditionVariable::~ConditionVariable() {
 }
 
 void ConditionVariable::Wait() {
-  internal::ScopedBlockingCallWithBaseSyncPrimitives scoped_blocking_call(FROM_HERE, 
-      BlockingType::MAY_BLOCK);
-#if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
+  absl::optional<internal::ScopedBlockingCallWithBaseSyncPrimitives>
+      scoped_blocking_call;
+  if (waiting_is_blocking_)
+    scoped_blocking_call.emplace(FROM_HERE, BlockingType::MAY_BLOCK);
+
+#if DCHECK_IS_ON()
   user_lock_->CheckHeldAndUnmark();
 #endif
   SbConditionVariableResult result =
       SbConditionVariableWait(&condition_, user_mutex_);
   DCHECK(SbConditionVariableIsSignaled(result));
-#if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
+#if DCHECK_IS_ON()
   user_lock_->CheckUnheldAndMark();
 #endif
 }
 
 void ConditionVariable::TimedWait(const TimeDelta& max_time) {
-  internal::ScopedBlockingCallWithBaseSyncPrimitives scoped_blocking_call(FROM_HERE, 
-      BlockingType::MAY_BLOCK);
+  absl::optional<internal::ScopedBlockingCallWithBaseSyncPrimitives>
+      scoped_blocking_call;
+  if (waiting_is_blocking_)
+    scoped_blocking_call.emplace(FROM_HERE, BlockingType::MAY_BLOCK);
   SbTime duration = max_time.ToSbTime();
 
-#if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
+#if DCHECK_IS_ON()
   user_lock_->CheckHeldAndUnmark();
 #endif
   SbConditionVariableResult result =
       SbConditionVariableWaitTimed(&condition_, user_mutex_, duration);
   DCHECK_NE(kSbConditionVariableFailed, result);
-#if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
+#if DCHECK_IS_ON()
   user_lock_->CheckUnheldAndMark();
 #endif
 }

diff --git a/base/task/thread_pool/can_run_policy_test.h b/base/task/thread_pool/can_run_policy_test.h
@@ -14,6 +14,9 @@
 #include "base/test/test_waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "build/build_config.h"
+#if defined(USE_HACKY_COBALT_CHANGES)
+#include "base/threading/thread_restrictions.h"
+#endif
 
 namespace base {
 namespace internal {
@@ -108,6 +111,9 @@ void TestCanRunPolicyChangedBeforeRun(Target* target,
     task_runner->PostTask(
         FROM_HERE, BindLambdaForTesting([&]() {
           first_task_started.Signal();
+#if defined(USE_HACKY_COBALT_CHANGES)
+          ScopedAllowBaseSyncPrimitivesForTesting allow_base_sync_primitives;
+#endif
           first_task_blocked.Wait();
         }));
     task_runner->PostTask(FROM_HERE, BindLambdaForTesting([&]() {

diff --git a/base/task/thread_pool/test_utils.cc b/base/task/thread_pool/test_utils.cc
@@ -168,9 +168,11 @@ bool MockPooledTaskRunnerDelegate::PostTaskWithSequence(
   if (!task_tracker_->WillPostTask(&task, sequence->shutdown_behavior())) {
     // `task`'s destructor may run sequence-affine code, so it must be leaked
     // when `WillPostTask` returns false.
+#if !defined(USE_HACKY_COBALT_CHANGES)
     auto leak = std::make_unique<Task>(std::move(task));
     ANNOTATE_LEAKING_OBJECT_PTR(leak.get());
     leak.release();
+#endif
     return false;
   }
 

diff --git a/base/task/thread_pool/thread_group_impl_unittest.cc b/base/task/thread_pool/thread_group_impl_unittest.cc
@@ -52,6 +52,9 @@
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/abseil-cpp/absl/types/optional.h"
+#if defined(USE_HACKY_COBALT_CHANGES)
+#include "base/threading/thread_restrictions.h"
+#endif
 
 namespace base {
 namespace internal {
@@ -313,6 +316,9 @@ TEST_F(ThreadGroupImplImplTest, ShouldYieldFloodedUserVisible) {
       BindLambdaForTesting(
           [&threads_running_barrier, &threads_continue](JobDelegate* delegate) {
             threads_running_barrier.Run();
+#if defined(USE_HACKY_COBALT_CHANGES)
+            ScopedAllowBaseSyncPrimitivesForTesting allow_base_sync_primitives;
+#endif
             threads_continue.Wait();
           }),
       /* num_tasks_to_run */ kMaxTasks);
@@ -844,6 +850,9 @@ TEST_P(ThreadGroupImplBlockingTest, TooManyBestEffortTasks) {
     for (size_t i = 0; i < kMaxBestEffortTasks + 1; ++i) {
       best_effort_task_runner->PostTask(
           FROM_HERE, BindLambdaForTesting([&]() {
+#if defined(USE_HACKY_COBALT_CHANGES)
+            ScopedAllowBaseSyncPrimitivesForTesting allow_base_sync_primitives;
+#endif
             {
               NestedScopedBlockingCall scoped_blocking_call(GetParam());
               entered_blocking_scope_barrier.Run();
@@ -1463,6 +1472,9 @@ TEST_F(ThreadGroupImplImplStartInBodyTest, MaxBestEffortTasks) {
     background_runner->PostTask(
         FROM_HERE, base::BindLambdaForTesting([&]() {
           best_effort_tasks_running_barrier.Run();
+#if defined(USE_HACKY_COBALT_CHANGES)
+          ScopedAllowBaseSyncPrimitivesForTesting allow_base_sync_primitives;
+#endif
           unblock_best_effort_tasks.Wait();
         }));
   }