Disable async debugger support until context mismatch issue is resolved.

runtime/vm/debugger.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/debugger.h"
 
 #include "include/dart_api.h"
 
 #include "platform/address_sanitizer.h"
 
@@ skipping 3226 matching lines @@
 
 void Debugger::CleanupSyntheticAsyncBreakpoint() {
   if (synthetic_async_breakpoint_ != NULL) {
     RemoveBreakpoint(synthetic_async_breakpoint_->id());
     synthetic_async_breakpoint_ = NULL;
   }
 }
 
 
 void Debugger::RememberTopFrameAwaiter() {
-  if (!FLAG_async_debugger_stepping) {
+  if (!FLAG_async_debugger) {
     return;
   }
   if (stack_trace_->Length() > 0) {
     top_frame_awaiter_ = stack_trace_->FrameAt(0)->GetAsyncAwaiter();
   } else {
     top_frame_awaiter_ = Object::null();
   }
 }
 
 
 void Debugger::SetAsyncSteppingFramePointer() {
-  if (!FLAG_async_debugger_stepping) {
+  if (!FLAG_async_debugger) {
     return;
   }
   if (stack_trace_->FrameAt(0)->function().IsAsyncClosure() ||
       stack_trace_->FrameAt(0)->function().IsAsyncGenClosure()) {
     async_stepping_fp_ = stack_trace_->FrameAt(0)->fp();
   } else {
     async_stepping_fp_ = 0;
   }
 }
 
@@ skipping 19 matching lines @@
     DeoptimizeWorld();
     isolate_->set_single_step(true);
     skip_next_step_ = skip_next_step;
     ASSERT(stack_trace->Length() > 0);
     stepping_fp_ = stack_trace->FrameAt(0)->fp();
     SetAsyncSteppingFramePointer();
     if (FLAG_verbose_debug) {
       OS::Print("HandleSteppingRequest- kStepOver %" Px "\n", stepping_fp_);
     }
   } else if (resume_action_ == kStepOut) {
-    if (FLAG_async_debugger_stepping) {
+    if (FLAG_async_debugger) {
       if (stack_trace->FrameAt(0)->function().IsAsyncClosure() ||
           stack_trace->FrameAt(0)->function().IsAsyncGenClosure()) {
         // Request to step out of an async/async* closure.
         const Object& async_op =
             Object::Handle(stack_trace->FrameAt(0)->GetAsyncAwaiter());
         if (!async_op.IsNull()) {
           // Step out to the awaiter.
           ASSERT(async_op.IsClosure());
           AsyncStepInto(Closure::Cast(async_op));
           return;
@@ skipping 347 matching lines @@
   }
 
   // Check whether we are in a Dart function that the user is
   // interested in. If we saved the frame pointer of a stack frame
   // the user is interested in, we ignore the single step if we are
   // in a callee of that frame. Note that we assume that the stack
   // grows towards lower addresses.
   ActivationFrame* frame = TopDartFrame();
   ASSERT(frame != NULL);
 
-  if (FLAG_async_debugger_stepping) {
+  if (FLAG_async_debugger) {
     if ((async_stepping_fp_ != 0) && (top_frame_awaiter_ != Object::null())) {
       // Check if the user has single stepped out of an async function with
       // an awaiter. The first check handles the case of calling into the
       // async machinery as we finish the async function. The second check
       // handles the case of returning from an async function.
       const bool exited_async_function =
           (IsCalleeFrameOf(async_stepping_fp_, frame->fp()) &&
            frame->IsAsyncMachinery()) ||
           IsCalleeFrameOf(frame->fp(), async_stepping_fp_);
       if (exited_async_function) {
@@ skipping 616 matching lines @@
       }
       bpt = bpt->next();
     }
     loc = loc->next();
   }
   return NULL;
 }
 
 
 void Debugger::MaybeAsyncStepInto(const Closure& async_op) {
-  if (FLAG_async_debugger_stepping && IsSingleStepping()) {
+  if (FLAG_async_debugger && IsSingleStepping()) {
     // We are single stepping, set a breakpoint on the closure activation
     // and resume execution so we can hit the breakpoint.
     AsyncStepInto(async_op);
   }
 }
 
 
 void Debugger::AsyncStepInto(const Closure& async_op) {
   SetBreakpointAtActivation(async_op, true);
   Continue();
@@ skipping 38 matching lines @@
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart