Remove dependency from platform files on v8.h

src/platform.h

 // Copyright 2012 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.
 
 // This module contains the platform-specific code. This make the rest of the
 // code less dependent on operating system, compilers and runtime libraries.
 // This module does specifically not deal with differences between different
 // processor architecture.
 // The platform classes have the same definition for all platforms. The
 // implementation for a particular platform is put in platform_<os>.cc.
@@ skipping 123 matching lines @@
 
 // ----------------------------------------------------------------------------
 // OS
 //
 // This class has static methods for the different platform specific
 // functions. Add methods here to cope with differences between the
 // supported platforms.
 
 class OS {
  public:
+  // Initialize the OS class.
+  // - random_seed: Used for the GetRandomMmapAddress() if non-zero.
+  // - hard_abort: If true, OS::Abort() will crash instead of aborting.
+  // - gc_fake_mmap: Name of the file for fake gc mmap used in ll_prof.
+  static void Initialize(int64_t random_seed,
+                         bool hard_abort,
+                         const char* const gc_fake_mmap);
+
   // Returns the accumulated user time for thread. This routine
   // can be used for profiling. The implementation should
   // strive for high-precision timer resolution, preferable
   // micro-second resolution.
   static int GetUserTime(uint32_t* secs,  uint32_t* usecs);
 
   // Returns current time as the number of milliseconds since
   // 00:00:00 UTC, January 1, 1970.
   static double TimeCurrentMillis();
 
@@ skipping 51 matching lines @@
   // This is the granularity at which the ProtectCode(...) call can set page
   // permissions.
   static intptr_t CommitPageSize();
 
   // Mark code segments non-writable.
   static void ProtectCode(void* address, const size_t size);
 
   // Assign memory as a guard page so that access will cause an exception.
   static void Guard(void* address, const size_t size);
 
-  // Set a fixed random seed for the random number generator used for
-  // GetRandomMmapAddr.
-  static void SetRandomSeed(int64_t seed);
-
   // Generate a random address to be used for hinting mmap().
   static void* GetRandomMmapAddr();
 
   // Get the Alignment guaranteed by Allocate().
   static size_t AllocateAlignment();
 
   // Sleep for a number of milliseconds.
   static void Sleep(const int milliseconds);
 
   // Abort the current process.
@@ skipping 70 matching lines @@
 
   // Returns the activation frame alignment constraint or zero if
   // the platform doesn't care. Guaranteed to be a power of two.
   static int ActivationFrameAlignment();
 
   static int GetCurrentProcessId();
 
  private:
   static const int msPerSecond = 1000;
 
+#if V8_OS_POSIX
+  static const char* GetGCFakeMMapFile();
+#endif
+
   DISALLOW_IMPLICIT_CONSTRUCTORS(OS);
 };
 
 // Represents and controls an area of reserved memory.
 // Control of the reserved memory can be assigned to another VirtualMemory
 // object by assignment or copy-contructing. This removes the reserved memory
 // from the original object.
 class VirtualMemory {
  public:
   // Empty VirtualMemory object, controlling no reserved memory.
@@ skipping 188 matching lines @@
   char name_[kMaxThreadNameLength];
   int stack_size_;
   Semaphore* start_semaphore_;
 
   DISALLOW_COPY_AND_ASSIGN(Thread);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_PLATFORM_H_