Use Chrome compatible naming for compiler specifics.

src/base/platform/time.cc

 // Copyright 2013 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/time.h"
 
 #if V8_OS_POSIX
 #include <fcntl.h>  // for O_RDONLY
 #include <sys/time.h>
 #include <unistd.h>
@@ skipping 128 matching lines @@
 }
 
 #endif  // V8_OS_POSIX
 
 
 #if V8_OS_WIN
 
 // We implement time using the high-resolution timers so that we can get
 // timeouts which are smaller than 10-15ms. To avoid any drift, we
 // periodically resync the internal clock to the system clock.
-class Clock V8_FINAL {
+class Clock FINAL {
  public:
   Clock() : initial_ticks_(GetSystemTicks()), initial_time_(GetSystemTime()) {}
 
   Time Now() {
     // Time between resampling the un-granular clock for this API (1 minute).
     const TimeDelta kMaxElapsedTime = TimeDelta::FromMinutes(1);
 
     LockGuard<Mutex> lock_guard(&mutex_);
 
     // Determine current time and ticks.
@@ skipping 226 matching lines @@
 // RDTSC on each processor are consistent with each other, and apply a handful
 // of workarounds for known buggy hardware. In other words, QPC is supposed to
 // give consistent result on a multiprocessor computer, but it is unreliable in
 // reality due to bugs in BIOS or HAL on some, especially old computers.
 // With recent updates on HAL and newer BIOS, QPC is getting more reliable but
 // it should be used with caution.
 //
 // (3) System time. The system time provides a low-resolution (typically 10ms
 // to 55 milliseconds) time stamp but is comparatively less expensive to
 // retrieve and more reliable.
-class HighResolutionTickClock V8_FINAL : public TickClock {
+class HighResolutionTickClock FINAL : public TickClock {
  public:
   explicit HighResolutionTickClock(int64_t ticks_per_second)
       : ticks_per_second_(ticks_per_second) {
     DCHECK_LT(0, ticks_per_second);
   }
   virtual ~HighResolutionTickClock() {}
 
-  virtual int64_t Now() V8_OVERRIDE {
+  virtual int64_t Now() OVERRIDE {
     LARGE_INTEGER now;
     BOOL result = QueryPerformanceCounter(&now);
     DCHECK(result);
     USE(result);
 
     // Intentionally calculate microseconds in a round about manner to avoid
     // overflow and precision issues. Think twice before simplifying!
     int64_t whole_seconds = now.QuadPart / ticks_per_second_;
     int64_t leftover_ticks = now.QuadPart % ticks_per_second_;
     int64_t ticks = (whole_seconds * Time::kMicrosecondsPerSecond) +
         ((leftover_ticks * Time::kMicrosecondsPerSecond) / ticks_per_second_);
 
     // Make sure we never return 0 here, so that TimeTicks::HighResolutionNow()
     // will never return 0.
     return ticks + 1;
   }
 
-  virtual bool IsHighResolution() V8_OVERRIDE {
+  virtual bool IsHighResolution() OVERRIDE {
     return true;
   }
 
  private:
   int64_t ticks_per_second_;
 };
 
 
-class RolloverProtectedTickClock V8_FINAL : public TickClock {
+class RolloverProtectedTickClock FINAL : public TickClock {
  public:
   // We initialize rollover_ms_ to 1 to ensure that we will never
   // return 0 from TimeTicks::HighResolutionNow() and TimeTicks::Now() below.
   RolloverProtectedTickClock() : last_seen_now_(0), rollover_ms_(1) {}
   virtual ~RolloverProtectedTickClock() {}
 
-  virtual int64_t Now() V8_OVERRIDE {
+  virtual int64_t Now() OVERRIDE {
     LockGuard<Mutex> lock_guard(&mutex_);
     // We use timeGetTime() to implement TimeTicks::Now(), which rolls over
     // every ~49.7 days. We try to track rollover ourselves, which works if
     // TimeTicks::Now() is called at least every 49 days.
     // Note that we do not use GetTickCount() here, since timeGetTime() gives
     // more predictable delta values, as described here:
     // http://blogs.msdn.com/b/larryosterman/archive/2009/09/02/what-s-the-difference-between-gettickcount-and-timegettime.aspx
     // timeGetTime() provides 1ms granularity when combined with
     // timeBeginPeriod(). If the host application for V8 wants fast timers, it
     // can use timeBeginPeriod() to increase the resolution.
     DWORD now = timeGetTime();
     if (now < last_seen_now_) {
       rollover_ms_ += V8_INT64_C(0x100000000);  // ~49.7 days.
     }
     last_seen_now_ = now;
     return (now + rollover_ms_) * Time::kMicrosecondsPerMillisecond;
   }
 
-  virtual bool IsHighResolution() V8_OVERRIDE {
+  virtual bool IsHighResolution() OVERRIDE {
     return false;
   }
 
  private:
   Mutex mutex_;
   DWORD last_seen_now_;
   int64_t rollover_ms_;
 };
 
 
@@ skipping 177 matching lines @@
 
 
 // static
 bool TimeTicks::KernelTimestampAvailable() {
   return kernel_tick_clock.Pointer()->Available();
 }
 
 #endif  // V8_OS_WIN
 
 } }  // namespace v8::base