Make sure that the TimerEventScope is destroyed before we signal completion

src/optimizing-compiler-thread.cc

 // 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.
 
 #include "src/optimizing-compiler-thread.h"
 
 #include "src/v8.h"
 
 #include "src/base/atomicops.h"
 #include "src/full-codegen.h"
@@ skipping 35 matching lines @@
 
   virtual ~CompileTask() {}
 
  private:
   // v8::Task overrides.
   void Run() OVERRIDE {
     DisallowHeapAllocation no_allocation;
     DisallowHandleAllocation no_handles;
     DisallowHandleDereference no_deref;
 
-    TimerEventScope<TimerEventRecompileConcurrent> timer(isolate_);
-
     OptimizingCompilerThread* thread = isolate_->optimizing_compiler_thread();
 
-    if (thread->recompilation_delay_ != 0) {
-      base::OS::Sleep(thread->recompilation_delay_);
+    {
+      TimerEventScope<TimerEventRecompileConcurrent> timer(isolate_);
+
+      if (thread->recompilation_delay_ != 0) {
+        base::OS::Sleep(thread->recompilation_delay_);
+      }
+
+      StopFlag flag;
+      OptimizedCompileJob* job = thread->NextInput(&flag);
+
+      if (flag == CONTINUE) {
+        thread->CompileNext(job);
+      } else {
+        AllowHandleDereference allow_handle_dereference;
+        if (!job->info()->is_osr()) {
+          DisposeOptimizedCompileJob(job, true);
+        }
+      }
     }
 
-    StopFlag flag;
-    OptimizedCompileJob* job = thread->NextInput(&flag);
-
-    if (flag == CONTINUE) {
-      thread->CompileNext(job);
-    } else {
-      AllowHandleDereference allow_handle_dereference;
-      if (!job->info()->is_osr()) {
-        DisposeOptimizedCompileJob(job, true);
-      }
-    }
     bool signal = false;
     {
       base::LockGuard<base::RecursiveMutex> lock(&thread->task_count_mutex_);
       if (--thread->task_count_ == 0) {
         if (static_cast<StopFlag>(base::Acquire_Load(&thread->stop_thread_)) ==
             FLUSH) {
           base::Release_Store(&thread->stop_thread_,
                               static_cast<base::AtomicWord>(CONTINUE));
           signal = true;
         }
@@ skipping 389 matching lines @@
 
 
 bool OptimizingCompilerThread::IsOptimizerThread() {
   base::LockGuard<base::Mutex> lock_guard(&thread_id_mutex_);
   return ThreadId::Current().ToInteger() == thread_id_;
 }
 #endif
 
 
 } }  // namespace v8::internal