Revert the latest set of platform changes.

src/platform.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 82 matching lines @@
 
 #endif  // _MSC_VER
 
 #ifndef __CYGWIN__
 // Random is missing on both Visual Studio and MinGW.
 int random();
 #endif
 
 #endif  // WIN32
 
-#include "mutex.h"
+#include "lazy-instance.h"
 #include "utils.h"
 #include "v8globals.h"
 
 namespace v8 {
 namespace internal {
 
 class Semaphore;
 class Mutex;
 
 double ceiling(double x);
@@ skipping 188 matching lines @@
   static const int kStackWalkError = -1;
   static const int kStackWalkMaxNameLen = 256;
   static const int kStackWalkMaxTextLen = 256;
   struct StackFrame {
     void* address;
     char text[kStackWalkMaxTextLen];
   };
 
   static int StackWalk(Vector<StackFrame> frames);
 
+  // Factory method for creating platform dependent Mutex.
+  // Please use delete to reclaim the storage for the returned Mutex.
+  static Mutex* CreateMutex();
+
   // Factory method for creating platform dependent Semaphore.
   // Please use delete to reclaim the storage for the returned Semaphore.
   static Semaphore* CreateSemaphore(int count);
 
   // Factory method for creating platform dependent Socket.
   // Please use delete to reclaim the storage for the returned Socket.
   static Socket* CreateSocket();
 
   class MemoryMappedFile {
    public:
@@ skipping 383 matching lines @@
 
   char name_[kMaxThreadNameLength];
   int stack_size_;
   Semaphore* start_semaphore_;
 
   DISALLOW_COPY_AND_ASSIGN(Thread);
 };
 
 
 // ----------------------------------------------------------------------------
+// Mutex
+//
+// Mutexes are used for serializing access to non-reentrant sections of code.
+// The implementations of mutex should allow for nested/recursive locking.
+
+class Mutex {
+ public:
+  virtual ~Mutex() {}
+
+  // Locks the given mutex. If the mutex is currently unlocked, it becomes
+  // locked and owned by the calling thread, and immediately. If the mutex
+  // is already locked by another thread, suspends the calling thread until
+  // the mutex is unlocked.
+  virtual int Lock() = 0;
+
+  // Unlocks the given mutex. The mutex is assumed to be locked and owned by
+  // the calling thread on entrance.
+  virtual int Unlock() = 0;
+
+  // Tries to lock the given mutex. Returns whether the mutex was
+  // successfully locked.
+  virtual bool TryLock() = 0;
+};
+
+struct CreateMutexTrait {
+  static Mutex* Create() {
+    return OS::CreateMutex();
+  }
+};
+
+// POD Mutex initialized lazily (i.e. the first time Pointer() is called).
+// Usage:
+//   static LazyMutex my_mutex = LAZY_MUTEX_INITIALIZER;
+//
+//   void my_function() {
+//     ScopedLock my_lock(my_mutex.Pointer());
+//     // Do something.
+//   }
+//
+typedef LazyDynamicInstance<
+    Mutex, CreateMutexTrait, ThreadSafeInitOnceTrait>::type LazyMutex;
+
+#define LAZY_MUTEX_INITIALIZER LAZY_DYNAMIC_INSTANCE_INITIALIZER
+
+// ----------------------------------------------------------------------------
+// ScopedLock
+//
+// Stack-allocated ScopedLocks provide block-scoped locking and
+// unlocking of a mutex.
+class ScopedLock {
+ public:
+  explicit ScopedLock(Mutex* mutex): mutex_(mutex) {
+    ASSERT(mutex_ != NULL);
+    mutex_->Lock();
+  }
+  ~ScopedLock() {
+    mutex_->Unlock();
+  }
+
+ private:
+  Mutex* mutex_;
+  DISALLOW_COPY_AND_ASSIGN(ScopedLock);
+};
+
+
+// ----------------------------------------------------------------------------
 // Socket
 //
 
 class Socket {
  public:
   virtual ~Socket() {}
 
   // Server initialization.
   virtual bool Bind(const int port) = 0;
   virtual bool Listen(int backlog) const = 0;
@@ skipping 22 matching lines @@
   static uint16_t HToN(uint16_t value);
   static uint16_t NToH(uint16_t value);
   static uint32_t HToN(uint32_t value);
   static uint32_t NToH(uint32_t value);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_PLATFORM_H_