Move platform abstraction to base library

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/platform/time.h"
+#include "src/base/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>
 
 #if V8_OS_WIN
 #include "src/base/lazy-instance.h"
 #include "src/base/win32-headers.h"
 #endif
-#include "src/checks.h"
-#include "src/cpu.h"
-#include "src/platform.h"
+#include "src/base/cpu.h"
+#include "src/base/logging.h"
+#include "src/base/platform/platform.h"
 
 namespace v8 {
-namespace internal {
+namespace base {
 
 TimeDelta TimeDelta::FromDays(int days) {
   return TimeDelta(days * Time::kMicrosecondsPerDay);
 }
 
 
 TimeDelta TimeDelta::FromHours(int hours) {
   return TimeDelta(hours * Time::kMicrosecondsPerHour);
 }
 
@@ skipping 151 matching lines @@
     ::GetSystemTimeAsFileTime(&ft);
     return Time::FromFiletime(ft);
   }
 
   TimeTicks initial_ticks_;
   Time initial_time_;
   Mutex mutex_;
 };
 
 
-static base::LazyStaticInstance<Clock, base::DefaultConstructTrait<Clock>,
-                                base::ThreadSafeInitOnceTrait>::type clock =
+static LazyStaticInstance<Clock, DefaultConstructTrait<Clock>,
+                          ThreadSafeInitOnceTrait>::type clock =
     LAZY_STATIC_INSTANCE_INITIALIZER;
 
 
 Time Time::Now() {
   return clock.Pointer()->Now();
 }
 
 
 Time Time::NowFromSystemTime() {
   return clock.Pointer()->NowFromSystemTime();
@@ skipping 247 matching lines @@
     return false;
   }
 
  private:
   Mutex mutex_;
   DWORD last_seen_now_;
   int64_t rollover_ms_;
 };
 
 
-static base::LazyStaticInstance<
-    RolloverProtectedTickClock,
-    base::DefaultConstructTrait<RolloverProtectedTickClock>,
-    base::ThreadSafeInitOnceTrait>::type tick_clock =
+static LazyStaticInstance<RolloverProtectedTickClock,
+                          DefaultConstructTrait<RolloverProtectedTickClock>,
+                          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 base::LazyDynamicInstance<TickClock,
-    CreateHighResTickClockTrait,
-    base::ThreadSafeInitOnceTrait>::type high_res_tick_clock =
-        LAZY_DYNAMIC_INSTANCE_INITIALIZER;
+static LazyDynamicInstance<TickClock, CreateHighResTickClockTrait,
+                           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 52 matching lines @@
 }
 
 
 // static
 bool TimeTicks::IsHighResolutionClockWorking() {
   return true;
 }
 
 #endif  // V8_OS_WIN
 
-} }  // namespace v8::internal
+} }  // namespace v8::base