Revert of [debugger] reapply break points after clearing one shots.

src/debug/debug.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/debug/debug.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/arguments.h"
@@ skipping 318 matching lines @@
 void BreakLocation::ClearBreakPoint(Handle<Object> break_point_object) {
   // Clear the break point information.
   DebugInfo::ClearBreakPoint(debug_info_, code_offset_, break_point_object);
   // If there are no more break points here remove the debug break.
   if (!HasBreakPoint()) {
     ClearDebugBreak();
     DCHECK(!IsDebugBreak());
   }
 }
 
-void BreakLocation::ReapplyBreakPoint() {
-  // We indeed have a break point here to re-apply.
-  DCHECK(HasBreakPoint());
-  // The break point is currently not applied to code.
-  DCHECK(!IsDebugBreak());
-  SetDebugBreak();
-}
 
 void BreakLocation::SetOneShot() {
   // Debugger statement always calls debugger. No need to modify it.
   if (IsDebuggerStatement()) return;
 
   // If there is a real break point here no more to do.
   if (HasBreakPoint()) {
     DCHECK(IsDebugBreak());
     return;
   }
 
   // Patch code with debug break.
   SetDebugBreak();
 }
 
 
 void BreakLocation::ClearOneShot() {
   // Debugger statement always calls debugger. No need to modify it.
   if (IsDebuggerStatement()) return;
 
+  // If there is a real break point here no more to do.
+  if (HasBreakPoint()) {
+    DCHECK(IsDebugBreak());
+    return;
+  }
+
   // Patch code removing debug break.
   ClearDebugBreak();
   DCHECK(!IsDebugBreak());
 }
 
 
 void BreakLocation::SetDebugBreak() {
   // Debugger statement always calls debugger. No need to modify it.
   if (IsDebuggerStatement()) return;
 
@@ skipping 745 matching lines @@
 }
 
 
 // Clears all the one-shot break points that are currently set. Normally this
 // function is called each time a break point is hit as one shot break points
 // are used to support stepping.
 void Debug::ClearOneShot() {
   // The current implementation just runs through all the breakpoints. When the
   // last break point for a function is removed that function is automatically
   // removed from the list.
-  DisallowHeapAllocation no_gc;
   for (DebugInfoListNode* node = debug_info_list_; node != NULL;
        node = node->next()) {
-    Handle<DebugInfo> debug_info = node->debug_info();
     for (std::unique_ptr<BreakLocation::Iterator> it(
-             BreakLocation::GetIterator(debug_info));
+             BreakLocation::GetIterator(node->debug_info()));
          !it->Done(); it->Next()) {
       it->GetBreakLocation().ClearOneShot();
     }
-    // Re-apply break points after having cleared everything.
-    if (debug_info->break_points()->IsUndefined(isolate_)) continue;
-    FixedArray* break_points = debug_info->break_points();
-    for (int i = 0; i < break_points->length(); i++) {
-      if (break_points->get(i)->IsUndefined(isolate_)) continue;
-      BreakPointInfo* break_point_info =
-          BreakPointInfo::cast(break_points->get(i));
-      if (break_point_info->GetBreakPointCount() == 0) continue;
-      BreakLocation break_location = BreakLocation::FromPosition(
-          debug_info, break_point_info->source_position(),
-          BREAK_POSITION_ALIGNED);
-      break_location.ReapplyBreakPoint();
-    }
   }
 }
 
 
 bool MatchingCodeTargets(Code* target1, Code* target2) {
   if (target1 == target2) return true;
   if (target1->kind() != target2->kind()) return false;
   return target1->is_handler() || target1->is_inline_cache_stub();
 }
 
@@ skipping 1430 matching lines @@
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 }  // namespace internal
 }  // namespace v8