Ignore CpuProfiler::SetIdle call when not profiling.

src/api.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/api.h"
 
 #include <string.h>  // For memcpy, strlen.
 #ifdef V8_USE_ADDRESS_SANITIZER
 #include <sanitizer/asan_interface.h>
 #endif  // V8_USE_ADDRESS_SANITIZER
@@ skipping 8334 matching lines @@
 
 
 CpuProfile* CpuProfiler::StopProfiling(Local<String> title) {
   return reinterpret_cast<CpuProfile*>(
       reinterpret_cast<i::CpuProfiler*>(this)->StopProfiling(
           *Utils::OpenHandle(*title)));
 }
 
 
 void CpuProfiler::SetIdle(bool is_idle) {
-  i::Isolate* isolate = reinterpret_cast<i::CpuProfiler*>(this)->isolate();
+  i::CpuProfiler* profiler = reinterpret_cast<i::CpuProfiler*>(this);
+  if (!profiler->is_profiling()) return;

[alph, 2016/04/30 00:03:08]

Sorry, didn't get how it helps. If we're not profiling, but it's called from
within a compilation it'll get the state of v8::COMPILER and fail the DCHECK. Am
I missing something?

[dgozman, 2016/04/30 00:10:39]

This does not happen, since compilation cannot trigger idle state unless we run
nested message loop.
Do you think we should instead allow to call this at any time and just remove
the DCHECK? That's a possible solution.

[alph, 2016/04/30 00:29:20]

Looks more robust to me. The problem is that when you call setIdle(false) you
have to restore the previous state e.g. COMPILER, rather than set it to
EXTERNAL.

Relying on the fact that profiling disables nested messages loops looks fragile.
Despite it was done this way before.

+  i::Isolate* isolate = profiler->isolate();
   v8::StateTag state = isolate->current_vm_state();
-  DCHECK(state == v8::JS || state == v8::EXTERNAL || state == v8::IDLE);
+  DCHECK(state == v8::EXTERNAL || state == v8::IDLE);
   if (isolate->js_entry_sp() != NULL) return;
   if (is_idle) {
     isolate->set_current_vm_state(v8::IDLE);
   } else if (state == v8::IDLE) {
     isolate->set_current_vm_state(v8::EXTERNAL);
   }
 }
 
 
 static i::HeapGraphEdge* ToInternal(const HeapGraphEdge* edge) {
@@ skipping 470 matching lines @@
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   callback(info);
 }
 
 
 }  // namespace internal
 }  // namespace v8