Use latent breakpoints list when looking up or removing breakpoints.

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 514 matching lines @@
     if (code.raw() == cbpt->code_) {
       return true;
     }
     cbpt = cbpt->next_;
   }
   return false;
 }
 
 
 void Debugger::PrintBreakpointsToJSONArray(JSONArray* jsarr) const {
-  BreakpointLocation* sbpt = breakpoint_locations_;
+  PrintBreakpointsListToJSONArray(breakpoint_locations_, jsarr);
+  PrintBreakpointsListToJSONArray(latent_locations_, jsarr);
+}
+
+
+void Debugger::PrintBreakpointsListToJSONArray(BreakpointLocation* sbpt,
+                                               JSONArray* jsarr) const {
   while (sbpt != NULL) {
     Breakpoint* bpt = sbpt->breakpoints();
     while (bpt != NULL) {
       jsarr->AddValue(bpt);
       bpt = bpt->next();
     }
     sbpt = sbpt->next_;
   }
 }
 
@@ skipping 1102 matching lines @@
     bpt->Disable();
     delete bpt;
   }
   if (NeedsIsolateEvents()) {
     ServiceEvent event(isolate_, ServiceEvent::kIsolateExit);
     InvokeEventHandler(&event);
   }
 }
 
 
-void Debugger::OnIsolateRunnable() {
-}
+void Debugger::OnIsolateRunnable() {}
 
 
 static RawFunction* ResolveLibraryFunction(const Library& library,
                                            const String& fname) {
   ASSERT(!library.IsNull());
   const Object& object = Object::Handle(library.ResolveName(fname));
   if (!object.IsNull() && object.IsFunction()) {
     return Function::Cast(object).raw();
   }
   return Function::null();
@@ skipping 2520 matching lines @@
     return bpt->OrigStubAddress();
   }
   UNREACHABLE();
   return Code::null();
 }
 
 
 // Remove and delete the source breakpoint bpt and its associated
 // code breakpoints.
 void Debugger::RemoveBreakpoint(intptr_t bp_id) {
+  if (RemoveBreakpointFromTheList(bp_id, &breakpoint_locations_)) {
+    return;
+  }
+  RemoveBreakpointFromTheList(bp_id, &latent_locations_);
+}
+
+
+// Remove and delete the source breakpoint bpt and its associated
+// code breakpoints. Returns true, if breakpoint was found and removed,
+// returns false, if breakpoint was not found.
+bool Debugger::RemoveBreakpointFromTheList(intptr_t bp_id,
+                                           BreakpointLocation** list) {
   BreakpointLocation* prev_loc = NULL;
-  BreakpointLocation* curr_loc = breakpoint_locations_;
+  BreakpointLocation* curr_loc = *list;
   while (curr_loc != NULL) {
     Breakpoint* prev_bpt = NULL;
     Breakpoint* curr_bpt = curr_loc->breakpoints();
     while (curr_bpt != NULL) {
       if (curr_bpt->id() == bp_id) {
         if (prev_bpt == NULL) {
           curr_loc->set_breakpoints(curr_bpt->next());
         } else {
           prev_bpt->set_next(curr_bpt->next());
         }
@@ skipping 11 matching lines @@
         if (synthetic_async_breakpoint_ == curr_bpt) {
           synthetic_async_breakpoint_ = NULL;
         }
         delete curr_bpt;
         curr_bpt = NULL;
 
         // Delete the breakpoint location object if there are no more
         // breakpoints at that location.
         if (curr_loc->breakpoints() == NULL) {
           if (prev_loc == NULL) {
-            breakpoint_locations_ = curr_loc->next();
+            *list = curr_loc->next();
           } else {
             prev_loc->set_next(curr_loc->next());
           }
 
-          // Remove references from code breakpoints to this breakpoint
-          // location and disable them.
-          UnlinkCodeBreakpoints(curr_loc);
+          if (!curr_loc->IsLatent()) {
+            // Remove references from code breakpoints to this breakpoint
+            // location and disable them.
+            // Latent breakpoint locations won't have code breakpoints.
+            UnlinkCodeBreakpoints(curr_loc);
+          }
           BreakpointLocation* next_loc = curr_loc->next();
           delete curr_loc;
           curr_loc = next_loc;
         }
 
         // The code breakpoints will be deleted when the VM resumes
         // after the pause event.
-        return;
+        return true;
       }
 
       prev_bpt = curr_bpt;
       curr_bpt = curr_bpt->next();
     }
     prev_loc = curr_loc;
     curr_loc = curr_loc->next();
   }
   // breakpoint with bp_id does not exist, nothing to do.
+  return false;
 }
 
 
 // Unlink code breakpoints from the given breakpoint location.
 // They will later be deleted when control returns from the pause event
 // callback. Also, disable the breakpoint so it no longer fires if it
 // should be hit before it gets deleted.
 void Debugger::UnlinkCodeBreakpoints(BreakpointLocation* bpt_location) {
   ASSERT(bpt_location != NULL);
   CodeBreakpoint* curr_bpt = code_breakpoints_;
@@ skipping 42 matching lines @@
         (bpt->requested_column_number_ == requested_column)) {
       return bpt;
     }
     bpt = bpt->next();
   }
   return NULL;
 }
 
 
 Breakpoint* Debugger::GetBreakpointById(intptr_t id) {
-  BreakpointLocation* loc = breakpoint_locations_;
+  Breakpoint* bpt = GetBreakpointByIdInTheList(id, breakpoint_locations_);
+  if (bpt != NULL) {
+    return bpt;
+  }
+  return GetBreakpointByIdInTheList(id, latent_locations_);
+}
+
+
+Breakpoint* Debugger::GetBreakpointByIdInTheList(intptr_t id,
+                                                 BreakpointLocation* list) {
+  BreakpointLocation* loc = list;
   while (loc != NULL) {
     Breakpoint* bpt = loc->breakpoints();
     while (bpt != NULL) {
       if (bpt->id() == id) {
         return bpt;
       }
       bpt = bpt->next();
     }
     loc = loc->next();
   }
@@ skipping 54 matching lines @@
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart