Revert of DevTools: do not use RAII for sync native breakpoints, reuse AsyncTask where possible.

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

Index: third_party/WebKit/Source/core/inspector/InspectorInstrumentation.cpp
diff --git a/third_party/WebKit/Source/core/inspector/InspectorInstrumentation.cpp b/third_party/WebKit/Source/core/inspector/InspectorInstrumentation.cpp
index 079454d631ee6b650840186877c45e3752be9732..0470465885e7bcc1f852704e38b9e6d693616371 100644
--- a/third_party/WebKit/Source/core/inspector/InspectorInstrumentation.cpp
+++ b/third_party/WebKit/Source/core/inspector/InspectorInstrumentation.cpp
@@ -57,18 +57,7 @@
 
 AsyncTask::AsyncTask(ExecutionContext* context, void* task, bool enabled)
     : m_debugger(enabled ? ThreadDebugger::from(toIsolate(context)) : nullptr),
-      m_task(task),
-      m_breakpoint(nullptr, nullptr) {
-  if (m_debugger)
-    m_debugger->asyncTaskStarted(m_task);
-}
-
-AsyncTask::AsyncTask(ExecutionContext* context,
-                     void* task,
-                     const char* breakpointName)
-    : m_debugger(ThreadDebugger::from(toIsolate(context))),
-      m_task(task),
-      m_breakpoint(context, breakpointName) {
+      m_task(task) {
   if (m_debugger)
     m_debugger->asyncTaskStarted(m_task);
 }
@@ -80,18 +69,17 @@
 
 void asyncTaskScheduled(ExecutionContext* context,
                         const String& name,
+                        void* task) {
+  if (ThreadDebugger* debugger = ThreadDebugger::from(toIsolate(context)))
+    debugger->asyncTaskScheduled(name, task, false);
+}
+
+void asyncTaskScheduled(ExecutionContext* context,
+                        const String& name,
                         void* task,
                         bool recurring) {
   if (ThreadDebugger* debugger = ThreadDebugger::from(toIsolate(context)))
     debugger->asyncTaskScheduled(name, task, recurring);
-}
-
-void asyncTaskScheduledBreakable(ExecutionContext* context,
-                                 const char* name,
-                                 void* task,
-                                 bool recurring) {
-  asyncTaskScheduled(context, name, task, recurring);
-  breakIfNeeded(context, name);
 }
 
 void asyncTaskCanceled(ExecutionContext* context, void* task) {
@@ -99,43 +87,27 @@
     debugger->asyncTaskCanceled(task);
 }
 
-void asyncTaskCanceledBreakable(ExecutionContext* context,
-                                const char* name,
-                                void* task) {
-  asyncTaskCanceled(context, task);
-  breakIfNeeded(context, name);
-}
-
 void allAsyncTasksCanceled(ExecutionContext* context) {
   if (ThreadDebugger* debugger = ThreadDebugger::from(toIsolate(context)))
     debugger->allAsyncTasksCanceled();
 }
 
-void breakIfNeeded(ExecutionContext* context, const char* name) {
-  InstrumentingAgents* instrumentingAgents = instrumentingAgentsFor(context);
-  if (!instrumentingAgents ||
-      !instrumentingAgents->hasInspectorDOMDebuggerAgents())
-    return;
-  for (InspectorDOMDebuggerAgent* domDebuggerAgent :
-       instrumentingAgents->inspectorDOMDebuggerAgents()) {
-    domDebuggerAgent->allowNativeBreakpoint(name, nullptr, true);
-  }
-}
-
-NativeBreakpoint::NativeBreakpoint(ExecutionContext* context, const char* name)
-    : m_instrumentingAgents(instrumentingAgentsFor(context)) {
+NativeBreakpoint::NativeBreakpoint(ExecutionContext* context,
+                                   const char* name,
+                                   bool sync)
+    : m_instrumentingAgents(instrumentingAgentsFor(context)), m_sync(sync) {
   if (!m_instrumentingAgents ||
       !m_instrumentingAgents->hasInspectorDOMDebuggerAgents())
     return;
   for (InspectorDOMDebuggerAgent* domDebuggerAgent :
        m_instrumentingAgents->inspectorDOMDebuggerAgents())
-    domDebuggerAgent->allowNativeBreakpoint(name, nullptr, false);
+    domDebuggerAgent->allowNativeBreakpoint(name, nullptr, m_sync);
 }
 
 NativeBreakpoint::NativeBreakpoint(ExecutionContext* context,
                                    EventTarget* eventTarget,
                                    Event* event)
-    : m_instrumentingAgents(instrumentingAgentsFor(context)) {
+    : m_instrumentingAgents(instrumentingAgentsFor(context)), m_sync(false) {
   if (!m_instrumentingAgents ||
       !m_instrumentingAgents->hasInspectorDOMDebuggerAgents())
     return;
@@ -143,16 +115,20 @@
   String targetName = node ? node->nodeName() : eventTarget->interfaceName();
   for (InspectorDOMDebuggerAgent* domDebuggerAgent :
        m_instrumentingAgents->inspectorDOMDebuggerAgents())
-    domDebuggerAgent->allowNativeBreakpoint(event->type(), &targetName, false);
+    domDebuggerAgent->allowNativeBreakpoint(event->type(), &targetName, m_sync);
 }
 
 NativeBreakpoint::~NativeBreakpoint() {
-  if (!m_instrumentingAgents ||
+  if (m_sync || !m_instrumentingAgents ||
       !m_instrumentingAgents->hasInspectorDOMDebuggerAgents())
     return;
   for (InspectorDOMDebuggerAgent* domDebuggerAgent :
        m_instrumentingAgents->inspectorDOMDebuggerAgents())
     domDebuggerAgent->cancelNativeBreakpoint();
+}
+
+bool isDebuggerPaused(LocalFrame*) {
+  return MainThreadDebugger::instance()->isPaused();
 }
 
 void didReceiveResourceResponseButCanceled(LocalFrame* frame,