This CL is due the thread I have made on chromium-dev:...

base/condition_variable_unittest.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Multi-threaded tests of ConditionVariable class.
 
 #include <time.h>
 #include <algorithm>
 #include <vector>
 
 #include "base/condition_variable.h"
 #include "base/logging.h"
 #include "base/platform_test.h"
 #include "base/platform_thread.h"
 #include "base/scoped_ptr.h"
 #include "base/spin_wait.h"
+#include "base/thread_collision_warner.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 //------------------------------------------------------------------------------
 // Define our test class, with several common variables.
 //------------------------------------------------------------------------------
 
 class ConditionVariableTest : public PlatformTest {
  public:
   const TimeDelta kZeroMs;
@@ skipping 42 matching lines @@
   bool EveryIdWasAllocated() const;  // Indicates that all IDs were handed out.
   TimeDelta GetAnAssignment(int thread_id);  // Get a work task duration.
   void WorkIsCompleted(int thread_id);
 
   int task_count() const;
   bool allow_help_requests() const;  // Workers can signal more workers.
   bool shutdown() const;  // Check if shutdown has been requested.
   int shutdown_task_count() const;
 
   void thread_shutting_down();
+
+  //----------------------------------------------------------------------------
+  // Worker threads can call them but not needed to acquire a lock
   Lock* lock();
 
   ConditionVariable* work_is_available();
   ConditionVariable* all_threads_have_ids();
   ConditionVariable* no_more_tasks();
 
   //----------------------------------------------------------------------------
   // The rest of the methods are for use by the controlling master thread (the
   // test case code).
   void ResetHistory();
@@ skipping 21 matching lines @@
   const int thread_count_;
   scoped_array<PlatformThreadHandle> thread_handles_;
   std::vector<int> assignment_history_;  // Number of assignment per worker.
   std::vector<int> completion_history_;  // Number of completions per worker.
   int thread_started_counter_;  // Used to issue unique id to workers.
   int shutdown_task_count_;  // Number of tasks told to shutdown
   int task_count_;  // Number of assignment tasks waiting to be processed.
   TimeDelta worker_delay_;  // Time each task takes to complete.
   bool allow_help_requests_;  // Workers can signal more workers.
   bool shutdown_;  // Set when threads need to terminate.
+
+  D_DEFINE_CRITICAL_SECTION(locked_methods_);
 };
 
 //------------------------------------------------------------------------------
 // The next section contains the actual tests.
 //------------------------------------------------------------------------------
 
 TEST_F(ConditionVariableTest, StartupShutdownTest) {
   Lock lock;
 
   // First try trivial startup/shutdown.
@@ skipping 337 matching lines @@
     SetShutdown();
   }
   work_is_available_.Broadcast();  // Tell them all to terminate.
 
   for (int i = 0; i < thread_count_; ++i) {
     PlatformThread::Join(thread_handles_[i]);
   }
 }
 
 int WorkQueue::GetThreadId() {
+  D_SCOPED_RECURSIVE_BOOK_CRITICAL_SECTION(locked_methods_);
   DCHECK(!EveryIdWasAllocated());
   return thread_started_counter_++;  // Give out Unique IDs.
 }
 
 bool WorkQueue::EveryIdWasAllocated() const {
+  D_SCOPED_RECURSIVE_BOOK_CRITICAL_SECTION(locked_methods_);
   return thread_count_ == thread_started_counter_;
 }
 
 TimeDelta WorkQueue::GetAnAssignment(int thread_id) {
+  D_SCOPED_RECURSIVE_BOOK_CRITICAL_SECTION(locked_methods_);
   DCHECK_LT(0, task_count_);
   assignment_history_[thread_id]++;
   if (0 == --task_count_) {
     no_more_tasks_.Signal();
   }
   return worker_delay_;
 }
 
 void WorkQueue::WorkIsCompleted(int thread_id) {
+  D_SCOPED_RECURSIVE_BOOK_CRITICAL_SECTION(locked_methods_);
   completion_history_[thread_id]++;
 }
 
 int WorkQueue::task_count() const {
+  D_SCOPED_RECURSIVE_BOOK_CRITICAL_SECTION(locked_methods_);
   return task_count_;
 }
 
 bool WorkQueue::allow_help_requests() const {
+  D_SCOPED_RECURSIVE_BOOK_CRITICAL_SECTION(locked_methods_);
   return allow_help_requests_;
 }
 
 bool WorkQueue::shutdown() const {
+  D_SCOPED_RECURSIVE_BOOK_CRITICAL_SECTION(locked_methods_);
   return shutdown_;
 }
 
 int WorkQueue::shutdown_task_count() const {
+  D_SCOPED_RECURSIVE_BOOK_CRITICAL_SECTION(locked_methods_);
   return shutdown_task_count_;
 }
 
 void WorkQueue::thread_shutting_down() {
+  D_SCOPED_RECURSIVE_BOOK_CRITICAL_SECTION(locked_methods_);
   shutdown_task_count_++;
 }
 
 Lock* WorkQueue::lock() {
   return &lock_;
 }
 
 ConditionVariable* WorkQueue::work_is_available() {
   return &work_is_available_;
 }
@@ skipping 127 matching lines @@
     {
       AutoLock auto_lock(lock_);
       // Send notification that we completed our "work."
       WorkIsCompleted(thread_id);
     }
   }
 }
 
 }  // namespace