Remove remaining dependencies on allocation.h from a few platform files

src/platform/time.h

 // 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.
 
 #ifndef V8_PLATFORM_TIME_H_
 #define V8_PLATFORM_TIME_H_
 
 #include <time.h>
 #include <limits>
 
-#include "src/allocation.h"
+#include "src/base/macros.h"
 
 // Forward declarations.
 extern "C" {
 struct _FILETIME;
 struct mach_timespec;
 struct timespec;
 struct timeval;
 }
 
 namespace v8 {
 namespace internal {
 
 class Time;
 class TimeTicks;
 
 // -----------------------------------------------------------------------------
 // TimeDelta
 //
 // This class represents a duration of time, internally represented in
 // microseonds.
 
-class TimeDelta V8_FINAL BASE_EMBEDDED {
+class TimeDelta V8_FINAL {
  public:
   TimeDelta() : delta_(0) {}
 
   // Converts units of time to TimeDeltas.
   static TimeDelta FromDays(int days);
   static TimeDelta FromHours(int hours);
   static TimeDelta FromMinutes(int minutes);
   static TimeDelta FromSeconds(int64_t seconds);
   static TimeDelta FromMilliseconds(int64_t milliseconds);
   static TimeDelta FromMicroseconds(int64_t microseconds) {
@@ skipping 107 matching lines @@
   int64_t delta_;
 };
 
 
 // -----------------------------------------------------------------------------
 // Time
 //
 // This class represents an absolute point in time, internally represented as
 // microseconds (s/1,000,000) since 00:00:00 UTC, January 1, 1970.
 
-class Time V8_FINAL BASE_EMBEDDED {
+class Time V8_FINAL {
  public:
   static const int64_t kMillisecondsPerSecond = 1000;
   static const int64_t kMicrosecondsPerMillisecond = 1000;
   static const int64_t kMicrosecondsPerSecond = kMicrosecondsPerMillisecond *
                                                 kMillisecondsPerSecond;
   static const int64_t kMicrosecondsPerMinute = kMicrosecondsPerSecond * 60;
   static const int64_t kMicrosecondsPerHour = kMicrosecondsPerMinute * 60;
   static const int64_t kMicrosecondsPerDay = kMicrosecondsPerHour * 24;
   static const int64_t kMicrosecondsPerWeek = kMicrosecondsPerDay * 7;
   static const int64_t kNanosecondsPerMicrosecond = 1000;
@@ skipping 116 matching lines @@
 // -----------------------------------------------------------------------------
 // TimeTicks
 //
 // This class represents an abstract time that is most of the time incrementing
 // for use in measuring time durations. It is internally represented in
 // microseconds.  It can not be converted to a human-readable time, but is
 // guaranteed not to decrease (if the user changes the computer clock,
 // Time::Now() may actually decrease or jump).  But note that TimeTicks may
 // "stand still", for example if the computer suspended.
 
-class TimeTicks V8_FINAL BASE_EMBEDDED {
+class TimeTicks V8_FINAL {
  public:
   TimeTicks() : ticks_(0) {}
 
   // Platform-dependent tick count representing "right now."
   // The resolution of this clock is ~1-15ms.  Resolution varies depending
   // on hardware/operating system configuration.
   // This method never returns a null TimeTicks.
   static TimeTicks Now();
 
   // Returns a platform-dependent high-resolution tick count. Implementation
@@ skipping 75 matching lines @@
   int64_t ticks_;
 };
 
 inline TimeTicks operator+(const TimeDelta& delta, const TimeTicks& ticks) {
   return ticks + delta;
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_PLATFORM_TIME_H_