Use Chrome compatible naming for compiler specifics.

src/base/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 11 matching lines @@
     EXPECT_FALSE(cv.WaitFor(&mutex, TimeDelta::FromMicroseconds(n)));
 
     cv.NotifyAll();
     EXPECT_FALSE(cv.WaitFor(&mutex, TimeDelta::FromMicroseconds(n)));
   }
 }
 
 
 namespace {
 
-class ThreadWithMutexAndConditionVariable V8_FINAL : public Thread {
+class ThreadWithMutexAndConditionVariable FINAL : public Thread {
  public:
   ThreadWithMutexAndConditionVariable()
       : Thread(Options("ThreadWithMutexAndConditionVariable")),
         running_(false),
         finished_(false) {}
   virtual ~ThreadWithMutexAndConditionVariable() {}
 
-  virtual void Run() V8_OVERRIDE {
+  virtual void Run() OVERRIDE {
     LockGuard<Mutex> lock_guard(&mutex_);
     running_ = true;
     cv_.NotifyOne();
     while (running_) {
       cv_.Wait(&mutex_);
     }
     finished_ = true;
     cv_.NotifyAll();
   }
 
@@ skipping 50 matching lines @@
     threads[n].Join();
     LockGuard<Mutex> lock_guard(&threads[n].mutex_);
     EXPECT_FALSE(threads[n].running_);
     EXPECT_TRUE(threads[n].finished_);
   }
 }
 
 
 namespace {
 
-class ThreadWithSharedMutexAndConditionVariable V8_FINAL : public Thread {
+class ThreadWithSharedMutexAndConditionVariable FINAL : public Thread {
  public:
   ThreadWithSharedMutexAndConditionVariable()
       : Thread(Options("ThreadWithSharedMutexAndConditionVariable")),
         running_(false),
         finished_(false),
         cv_(NULL),
         mutex_(NULL) {}
   virtual ~ThreadWithSharedMutexAndConditionVariable() {}
 
-  virtual void Run() V8_OVERRIDE {
+  virtual void Run() OVERRIDE {
     LockGuard<Mutex> lock_guard(mutex_);
     running_ = true;
     cv_->NotifyAll();
     while (running_) {
       cv_->Wait(mutex_);
     }
     finished_ = true;
     cv_->NotifyAll();
   }
 
@@ skipping 79 matching lines @@
 
   // Join all threads.
   for (int n = 0; n < kThreadCount; ++n) {
     threads[n].Join();
   }
 }
 
 
 namespace {
 
-class LoopIncrementThread V8_FINAL : public Thread {
+class LoopIncrementThread FINAL : public Thread {
  public:
   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 {
+  virtual void Run() OVERRIDE {
     int last_count = -1;
     while (true) {
       LockGuard<Mutex> lock_guard(mutex_);
       int count = *counter_;
       while (count % thread_count_ != rem_ && count < limit_) {
         cv_->Wait(mutex_);
         count = *counter_;
       }
       if (count >= limit_) break;
       EXPECT_EQ(*counter_, count);
@@ skipping 45 matching lines @@
       delete threads[n];
     }
     delete[] threads;
 
     EXPECT_EQ(limit, counter);
   }
 }
 
 }  // namespace base
 }  // namespace v8