[DevTools] Always instrument async tasks in V8Debugger.

third_party/WebKit/Source/core/inspector/ThreadDebugger.cpp

 // Copyright 2016 The Chromium 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 "core/inspector/ThreadDebugger.h"
 
 #include "bindings/core/v8/SourceLocation.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8DOMException.h"
 #include "bindings/core/v8/V8DOMTokenList.h"
@@ skipping 12 matching lines @@
 #include "platform/ScriptForbiddenScope.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 
 ThreadDebugger::ThreadDebugger(v8::Isolate* isolate)
     : m_isolate(isolate)
     , m_debugger(V8Debugger::create(isolate, this))
-    , m_asyncInstrumentationEnabled(false)
 {
 }
 
 ThreadDebugger::~ThreadDebugger()
 {
 }
 
 // static
 ThreadDebugger* ThreadDebugger::from(v8::Isolate* isolate)
 {
@@ skipping 22 matching lines @@
 }
 
 void ThreadDebugger::idleFinished(v8::Isolate* isolate)
 {
     if (ThreadDebugger* debugger = ThreadDebugger::from(isolate))
         debugger->debugger()->idleFinished();
 }
 
 void ThreadDebugger::asyncTaskScheduled(const String& operationName, void* task, bool recurring)
 {
-    if (m_asyncInstrumentationEnabled)
-        m_debugger->asyncTaskScheduled(operationName, task, recurring);
+    m_debugger->asyncTaskScheduled(operationName, task, recurring);
 }
 
 void ThreadDebugger::asyncTaskCanceled(void* task)
 {
-    if (m_asyncInstrumentationEnabled)
-        m_debugger->asyncTaskCanceled(task);
+    m_debugger->asyncTaskCanceled(task);
 }
 
 void ThreadDebugger::allAsyncTasksCanceled()
 {
-    if (m_asyncInstrumentationEnabled)
-        m_debugger->allAsyncTasksCanceled();
+    m_debugger->allAsyncTasksCanceled();
 }
 
 void ThreadDebugger::asyncTaskStarted(void* task)
 {
-    if (m_asyncInstrumentationEnabled)
-        m_debugger->asyncTaskStarted(task);
+    m_debugger->asyncTaskStarted(task);
 }
 
 void ThreadDebugger::asyncTaskFinished(void* task)
 {
-    if (m_asyncInstrumentationEnabled)
-        m_debugger->asyncTaskFinished(task);
+    m_debugger->asyncTaskFinished(task);
 }
 
 unsigned ThreadDebugger::promiseRejected(v8::Local<v8::Context> context, const String16& errorMessage, v8::Local<v8::Value> exception, std::unique_ptr<SourceLocation> location)
 {
     const String16 defaultMessage = "Uncaught (in promise)";
     String16 message = errorMessage;
     if (message.isEmpty())
         message = defaultMessage;
     else if (message.startWith("Uncaught "))
         message = message.substring(0, 8) + " (in promise)" + message.substring(8);
@@ skipping 49 matching lines @@
     if (object->InternalFieldCount() < v8DefaultWrapperInternalFieldCount)
         return true;
     v8::Local<v8::Value> wrapper = object->GetInternalField(v8DOMWrapperObjectIndex);
     // Skip wrapper boilerplates which are like regular wrappers but don't have
     // native object.
     if (!wrapper.IsEmpty() && wrapper->IsUndefined())
         return false;
     return true;
 }
 
-void ThreadDebugger::enableAsyncInstrumentation()
-{
-    DCHECK(!m_asyncInstrumentationEnabled);
-    m_asyncInstrumentationEnabled = true;
-}
-
-void ThreadDebugger::disableAsyncInstrumentation()
-{
-    DCHECK(m_asyncInstrumentationEnabled);
-    m_asyncInstrumentationEnabled = false;
-}
-
 static void returnDataCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     info.GetReturnValue().Set(info.Data());
 }
 
 static void createFunctionPropertyWithData(v8::Local<v8::Context> context, v8::Local<v8::Object> object, const char* name, v8::FunctionCallback callback, v8::Local<v8::Value> data, const char* description)
 {
     v8::Local<v8::String> funcName = v8String(context->GetIsolate(), name);
     v8::Local<v8::Function> func;
     if (!v8::Function::New(context, callback, data, 0, v8::ConstructorBehavior::kThrow).ToLocal(&func))
@@ skipping 184 matching lines @@
 {
     for (size_t index = 0; index < m_timers.size(); ++index) {
         if (m_timers[index].get() == timer) {
             m_timerCallbacks[index](m_timerData[index]);
             return;
         }
     }
 }
 
 } // namespace blink