Move atomic ops and related files to base library

src/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/platform/time.h"
 
 #if V8_OS_POSIX
 #include <sys/time.h>
 #endif
 #if V8_OS_MACOSX
 #include <mach/mach_time.h>
 #endif
 
 #include <string.h>
 
 #include "src/checks.h"
 #include "src/cpu.h"
 #include "src/platform.h"
 #if V8_OS_WIN
-#include "src/win32-headers.h"
+#include "src/base/win32-headers.h"
 #endif
 
 namespace v8 {
 namespace internal {
 
 TimeDelta TimeDelta::FromDays(int days) {
   return TimeDelta(days * Time::kMicrosecondsPerDay);
 }
 
 
@@ skipping 155 matching lines @@
     ::GetSystemTimeAsFileTime(&ft);
     return Time::FromFiletime(ft);
   }
 
   TimeTicks initial_ticks_;
   Time initial_time_;
   Mutex mutex_;
 };
 
 
-static LazyStaticInstance<Clock,
-    DefaultConstructTrait<Clock>,
-    ThreadSafeInitOnceTrait>::type clock = LAZY_STATIC_INSTANCE_INITIALIZER;
+static base::LazyStaticInstance<Clock, base::DefaultConstructTrait<Clock>,

[Jakob Kummerow, 2014/06/05 11:49:06]

IWYU?

+                                base::ThreadSafeInitOnceTrait>::type clock =
+    LAZY_STATIC_INSTANCE_INITIALIZER;
 
 
 Time Time::Now() {
   return clock.Pointer()->Now();
 }
 
 
 Time Time::NowFromSystemTime() {
   return clock.Pointer()->NowFromSystemTime();
 }
@@ skipping 246 matching lines @@
     return false;
   }
 
  private:
   Mutex mutex_;
   DWORD last_seen_now_;
   int64_t rollover_ms_;
 };
 
 
-static LazyStaticInstance<RolloverProtectedTickClock,
-    DefaultConstructTrait<RolloverProtectedTickClock>,
-    ThreadSafeInitOnceTrait>::type tick_clock =
-        LAZY_STATIC_INSTANCE_INITIALIZER;
+static base::LazyStaticInstance<
+    RolloverProtectedTickClock,
+    base::DefaultConstructTrait<RolloverProtectedTickClock>,
+    base::ThreadSafeInitOnceTrait>::type tick_clock =
+    LAZY_STATIC_INSTANCE_INITIALIZER;
 
 
 struct CreateHighResTickClockTrait {
   static TickClock* Create() {
     // Check if the installed hardware supports a high-resolution performance
     // counter, and if not fallback to the low-resolution tick clock.
     LARGE_INTEGER ticks_per_second;
     if (!QueryPerformanceFrequency(&ticks_per_second)) {
       return tick_clock.Pointer();
     }
 
     // On Athlon X2 CPUs (e.g. model 15) the QueryPerformanceCounter
     // is unreliable, fallback to the low-resolution tick clock.
     CPU cpu;
     if (strcmp(cpu.vendor(), "AuthenticAMD") == 0 && cpu.family() == 15) {
       return tick_clock.Pointer();
     }
 
     return new HighResolutionTickClock(ticks_per_second.QuadPart);
   }
 };
 
 
-static LazyDynamicInstance<TickClock,
+static base::LazyDynamicInstance<TickClock,
     CreateHighResTickClockTrait,
-    ThreadSafeInitOnceTrait>::type high_res_tick_clock =
+    base::ThreadSafeInitOnceTrait>::type high_res_tick_clock =
         LAZY_DYNAMIC_INSTANCE_INITIALIZER;
 
 
 TimeTicks TimeTicks::Now() {
   // Make sure we never return 0 here.
   TimeTicks ticks(tick_clock.Pointer()->Now());
   ASSERT(!ticks.IsNull());
   return ticks;
 }
 
@@ skipping 54 matching lines @@
 
 
 // static
 bool TimeTicks::IsHighResolutionClockWorking() {
   return true;
 }
 
 #endif  // V8_OS_WIN
 
 } }  // namespace v8::internal