Get rid of isolate state.

src/sampler.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/sampler.h"
 
 #if V8_OS_POSIX && !V8_OS_CYGWIN
 
 #define USE_SIGNALS
 
@@ skipping 317 matching lines @@
 bool SignalHandler::signal_handler_installed_ = false;
 
 
 // As Native Client does not support signal handling, profiling is disabled.
 #if !V8_OS_NACL
 void SignalHandler::HandleProfilerSignal(int signal, siginfo_t* info,
                                          void* context) {
   USE(info);
   if (signal != SIGPROF) return;
   Isolate* isolate = Isolate::UnsafeCurrent();
-  if (isolate == NULL || !isolate->IsInitialized() || !isolate->IsInUse()) {
+  if (isolate == NULL || !isolate->IsInUse()) {
     // We require a fully initialized and entered isolate.
     return;
   }
   if (v8::Locker::IsActive() &&
       !isolate->thread_manager()->IsLockedByCurrentThread()) {
     return;
   }
 
   Sampler* sampler = isolate->logger()->sampler();
   if (sampler == NULL) return;
@@ skipping 186 matching lines @@
   // Implement Thread::Run().
   virtual void Run() {
     while (true) {
       {
         base::LockGuard<base::Mutex> lock_guard(mutex_);
         if (active_samplers_.is_empty()) break;
         // When CPU profiling is enabled both JavaScript and C++ code is
         // profiled. We must not suspend.
         for (int i = 0; i < active_samplers_.length(); ++i) {
           Sampler* sampler = active_samplers_.at(i);
-          if (!sampler->isolate()->IsInitialized()) continue;
           if (!sampler->IsProfiling()) continue;
           sampler->DoSample();
         }
       }
       base::OS::Sleep(interval_);
     }
   }
 
  private:
   // Protects the process wide state below.
   static base::Mutex* mutex_;
   static SamplerThread* instance_;
 
   const int interval_;
   List<Sampler*> active_samplers_;
 
   DISALLOW_COPY_AND_ASSIGN(SamplerThread);
 };
 
 
 base::Mutex* SamplerThread::mutex_ = NULL;
 SamplerThread* SamplerThread::instance_ = NULL;
 
 
 //
 // StackTracer implementation
 //
 DISABLE_ASAN void TickSample::Init(Isolate* isolate,
                                    const v8::RegisterState& regs) {
-  DCHECK(isolate->IsInitialized());
   timestamp = base::TimeTicks::HighResolutionNow();
   pc = reinterpret_cast<Address>(regs.pc);
   state = isolate->current_vm_state();
 
   // Avoid collecting traces while doing GC.
   if (state == GC) return;
 
   Address js_entry_sp = isolate->js_entry_sp();
   if (js_entry_sp == 0) return;  // Not executing JS now.
 
@@ skipping 19 matching lines @@
   SampleInfo info;
   GetStackSample(isolate, regs, reinterpret_cast<void**>(&stack[0]),
                  kMaxFramesCount, &info);
   frames_count = static_cast<unsigned>(info.frames_count);
 }
 
 
 void TickSample::GetStackSample(Isolate* isolate, const v8::RegisterState& regs,
                                 void** frames, size_t frames_limit,
                                 v8::SampleInfo* sample_info) {
-  DCHECK(isolate->IsInitialized());
   sample_info->frames_count = 0;
   sample_info->vm_state = isolate->current_vm_state();
   if (sample_info->vm_state == GC) return;
 
   Address js_entry_sp = isolate->js_entry_sp();
   if (js_entry_sp == 0) return;  // Not executing JS now.
 
   SafeStackFrameIterator it(isolate, reinterpret_cast<Address>(regs.fp),
                             reinterpret_cast<Address>(regs.sp), js_entry_sp);
   size_t i = 0;
@@ skipping 128 matching lines @@
 #endif  // USE_SIMULATOR
     SampleStack(state);
   }
   ResumeThread(profiled_thread);
 }
 
 #endif  // USE_SIGNALS
 
 
 } }  // namespace v8::internal