Remove static initializers in v8.

src/log.cc

 // Copyright 2011 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 17 matching lines @@
 #include <stdarg.h>
 
 #include "v8.h"
 
 #include "bootstrapper.h"
 #include "code-stubs.h"
 #include "deoptimizer.h"
 #include "global-handles.h"
 #include "log.h"
 #include "macro-assembler.h"
+#include "platform.h"
 #include "runtime-profiler.h"
 #include "serialize.h"
 #include "string-stream.h"
 #include "vm-state-inl.h"
 
 namespace v8 {
 namespace internal {
 
 //
 // Sliding state window.  Updates counters to keep track of the last
@@ skipping 1671 matching lines @@
     FLAG_sliding_state_window = true;
     return;
   }
   // Otherwise, if the sliding state window computation has not been
   // started we do it now.
   if (sliding_state_window_ == NULL) {
     sliding_state_window_ = new SlidingStateWindow(Isolate::Current());
   }
 }
 
+// Protects the state below.
+static LazyMutex active_samplers_mutex = LAZY_MUTEX_INITIALIZER;
 
-Mutex* SamplerRegistry::mutex_ = OS::CreateMutex();
 List<Sampler*>* SamplerRegistry::active_samplers_ = NULL;
 
 
 bool SamplerRegistry::IterateActiveSamplers(VisitSampler func, void* param) {
-  ScopedLock lock(mutex_);
+  ScopedLock lock(active_samplers_mutex.Pointer());
   for (int i = 0;
        ActiveSamplersExist() && i < active_samplers_->length();
        ++i) {
     func(active_samplers_->at(i), param);
   }
   return ActiveSamplersExist();
 }
 
 
 static void ComputeCpuProfiling(Sampler* sampler, void* flag_ptr) {
   bool* flag = reinterpret_cast<bool*>(flag_ptr);
   *flag |= sampler->IsProfiling();
 }
 
 
 SamplerRegistry::State SamplerRegistry::GetState() {
   bool flag = false;
   if (!IterateActiveSamplers(&ComputeCpuProfiling, &flag)) {
     return HAS_NO_SAMPLERS;
   }
   return flag ? HAS_CPU_PROFILING_SAMPLERS : HAS_SAMPLERS;
 }
 
 
 void SamplerRegistry::AddActiveSampler(Sampler* sampler) {
   ASSERT(sampler->IsActive());
-  ScopedLock lock(mutex_);
+  ScopedLock lock(active_samplers_mutex.Pointer());
   if (active_samplers_ == NULL) {
     active_samplers_ = new List<Sampler*>;
   } else {
     ASSERT(!active_samplers_->Contains(sampler));
   }
   active_samplers_->Add(sampler);
 }
 
 
 void SamplerRegistry::RemoveActiveSampler(Sampler* sampler) {
   ASSERT(sampler->IsActive());
-  ScopedLock lock(mutex_);
+  ScopedLock lock(active_samplers_mutex.Pointer());
   ASSERT(active_samplers_ != NULL);
   bool removed = active_samplers_->RemoveElement(sampler);
   ASSERT(removed);
   USE(removed);
 }
 
 } }  // namespace v8::internal