Version 3.28.71.3 (merged r23081)

test/base-unittests/platform/condition-variable-unittest.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/base/platform/condition-variable.h"
 
 #include "src/base/platform/platform.h"
 #include "src/base/platform/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 14 matching lines @@
     EXPECT_FALSE(cv.WaitFor(&mutex, TimeDelta::FromMicroseconds(n)));
   }
 }
 
 
 namespace {
 
 class ThreadWithMutexAndConditionVariable V8_FINAL : public Thread {
  public:
   ThreadWithMutexAndConditionVariable()
-      : Thread("ThreadWithMutexAndConditionVariable"),
-        running_(false), finished_(false) {}
+      : Thread(Options("ThreadWithMutexAndConditionVariable")),
+        running_(false),
+        finished_(false) {}
   virtual ~ThreadWithMutexAndConditionVariable() {}
 
   virtual void Run() V8_OVERRIDE {
     LockGuard<Mutex> lock_guard(&mutex_);
     running_ = true;
     cv_.NotifyOne();
     while (running_) {
       cv_.Wait(&mutex_);
     }
     finished_ = true;
@@ skipping 56 matching lines @@
     EXPECT_TRUE(threads[n].finished_);
   }
 }
 
 
 namespace {
 
 class ThreadWithSharedMutexAndConditionVariable V8_FINAL : public Thread {
  public:
   ThreadWithSharedMutexAndConditionVariable()
-      : Thread("ThreadWithSharedMutexAndConditionVariable"),
-        running_(false), finished_(false), cv_(NULL), mutex_(NULL) {}
+      : Thread(Options("ThreadWithSharedMutexAndConditionVariable")),
+        running_(false),
+        finished_(false),
+        cv_(NULL),
+        mutex_(NULL) {}
   virtual ~ThreadWithSharedMutexAndConditionVariable() {}
 
   virtual void Run() V8_OVERRIDE {
     LockGuard<Mutex> lock_guard(mutex_);
     running_ = true;
     cv_->NotifyAll();
     while (running_) {
       cv_->Wait(mutex_);
     }
     finished_ = true;
@@ skipping 84 matching lines @@
   for (int n = 0; n < kThreadCount; ++n) {
     threads[n].Join();
   }
 }
 
 
 namespace {
 
 class LoopIncrementThread V8_FINAL : public Thread {
  public:
-  LoopIncrementThread(int rem,
-                      int* counter,
-                      int limit,
-                      int thread_count,
-                      ConditionVariable* cv,
-                      Mutex* mutex)
-      : Thread("LoopIncrementThread"), rem_(rem), counter_(counter),
-        limit_(limit), thread_count_(thread_count), cv_(cv), mutex_(mutex) {
+  LoopIncrementThread(int rem, int* counter, int limit, int thread_count,
+                      ConditionVariable* cv, Mutex* mutex)
+      : Thread(Options("LoopIncrementThread")),
+        rem_(rem),
+        counter_(counter),
+        limit_(limit),
+        thread_count_(thread_count),
+        cv_(cv),
+        mutex_(mutex) {
     EXPECT_LT(rem, thread_count);
     EXPECT_EQ(0, limit % thread_count);
   }
 
   virtual void Run() V8_OVERRIDE {
     int last_count = -1;
     while (true) {
       LockGuard<Mutex> lock_guard(mutex_);
       int count = *counter_;
       while (count % thread_count_ != rem_ && count < limit_) {
@@ skipping 50 matching lines @@
       delete threads[n];
     }
     delete[] threads;
 
     EXPECT_EQ(limit, counter);
   }
 }
 
 }  // namespace base
 }  // namespace v8