[debugger] remove break point hit count and ignore count.

src/debug/debug.js

 // 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.
 
 (function (global, utils) {
 "use strict";
 
 // ----------------------------------------------------------------------------
 // Imports
 
@@ skipping 129 matching lines @@
 // NOTE: This object does not have a reference to the function having break
 // point as this would cause function not to be garbage collected when it is
 // not used any more. We do not want break points to keep functions alive.
 function BreakPoint(source_position, opt_script_break_point) {
   this.source_position_ = source_position;
   if (opt_script_break_point) {
     this.script_break_point_ = opt_script_break_point;
   } else {
     this.number_ = next_break_point_number++;
   }
-  this.hit_count_ = 0;
   this.active_ = true;
   this.condition_ = null;
-  this.ignoreCount_ = 0;
 }
 
 
 BreakPoint.prototype.number = function() {
   return this.number_;
 };
 
 
 BreakPoint.prototype.func = function() {
   return this.func_;
 };
 
 
 BreakPoint.prototype.source_position = function() {
   return this.source_position_;
 };
 
 
-BreakPoint.prototype.hit_count = function() {
-  return this.hit_count_;
-};
-
-
 BreakPoint.prototype.active = function() {
   if (this.script_break_point()) {
     return this.script_break_point().active();
   }
   return this.active_;
 };
 
 
 BreakPoint.prototype.condition = function() {
   if (this.script_break_point() && this.script_break_point().condition()) {
     return this.script_break_point().condition();
   }
   return this.condition_;
 };
 
 
-BreakPoint.prototype.ignoreCount = function() {
-  return this.ignoreCount_;
-};
-
-
 BreakPoint.prototype.script_break_point = function() {
   return this.script_break_point_;
 };
 
 
 BreakPoint.prototype.enable = function() {
   this.active_ = true;
 };
 
 
 BreakPoint.prototype.disable = function() {
   this.active_ = false;
 };
 
 
 BreakPoint.prototype.setCondition = function(condition) {
   this.condition_ = condition;
 };
 
 
-BreakPoint.prototype.setIgnoreCount = function(ignoreCount) {
-  this.ignoreCount_ = ignoreCount;
-};
-
-
 BreakPoint.prototype.isTriggered = function(exec_state) {
   // Break point not active - not triggered.
   if (!this.active()) return false;
 
   // Check for conditional break point.
   if (this.condition()) {
     // If break point has condition try to evaluate it in the top frame.
     try {
       var mirror = exec_state.frame(0).evaluate(this.condition());
       // If no sensible mirror or non true value break point not triggered.
       if (!(mirror instanceof ValueMirror) || !mirror.value_) {
         return false;
       }
     } catch (e) {
       // Exception evaluating condition counts as not triggered.
       return false;
     }
   }
 
-  // Update the hit count.
-  this.hit_count_++;
-  if (this.script_break_point_) {
-    this.script_break_point_.hit_count_++;
-  }
-
-  // If the break point has an ignore count it is not triggered.
-  if (this.ignoreCount_ > 0) {
-    this.ignoreCount_--;
-    return false;
-  }
-
   // Break point triggered.
   return true;
 };
 
 
 // Function called from the runtime when a break point is hit. Returns true if
 // the break point is triggered and supposed to break execution.
 function IsBreakPointTriggered(break_id, break_point) {
   return break_point.isTriggered(MakeExecutionState(break_id));
 }
@@ skipping 12 matching lines @@
   } else if (type == Debug.ScriptBreakPointType.ScriptRegExp) {
     this.script_regexp_object_ = new GlobalRegExp(script_id_or_name);
   } else {
     throw MakeError(kDebugger, "Unexpected breakpoint type " + type);
   }
   this.line_ = opt_line || 0;
   this.column_ = opt_column;
   this.groupId_ = opt_groupId;
   this.position_alignment_ = IS_UNDEFINED(opt_position_alignment)
       ? Debug.BreakPositionAlignment.Statement : opt_position_alignment;
-  this.hit_count_ = 0;
   this.active_ = true;
   this.condition_ = null;
-  this.ignoreCount_ = 0;
   this.break_points_ = [];
 }
 
 
 // Creates a clone of script breakpoint that is linked to another script.
 ScriptBreakPoint.prototype.cloneForOtherScript = function (other_script) {
   var copy = new ScriptBreakPoint(Debug.ScriptBreakPointType.ScriptId,
       other_script.id, this.line_, this.column_, this.groupId_,
       this.position_alignment_);
   copy.number_ = next_break_point_number++;
   script_break_points.push(copy);
 
-  copy.hit_count_ = this.hit_count_;
   copy.active_ = this.active_;
   copy.condition_ = this.condition_;
-  copy.ignoreCount_ = this.ignoreCount_;
   return copy;
 };
 
 
 ScriptBreakPoint.prototype.number = function() {
   return this.number_;
 };
 
 
 ScriptBreakPoint.prototype.groupId = function() {
@@ skipping 39 matching lines @@
   return locations;
 };
 
 
 ScriptBreakPoint.prototype.update_positions = function(line, column) {
   this.line_ = line;
   this.column_ = column;
 };
 
 
-ScriptBreakPoint.prototype.hit_count = function() {
-  return this.hit_count_;
-};
-
-
 ScriptBreakPoint.prototype.active = function() {
   return this.active_;
 };
 
 
 ScriptBreakPoint.prototype.condition = function() {
   return this.condition_;
 };
 
 
-ScriptBreakPoint.prototype.ignoreCount = function() {
-  return this.ignoreCount_;
-};
-
-
 ScriptBreakPoint.prototype.enable = function() {
   this.active_ = true;
 };
 
 
 ScriptBreakPoint.prototype.disable = function() {
   this.active_ = false;
 };
 
 
 ScriptBreakPoint.prototype.setCondition = function(condition) {
   this.condition_ = condition;
 };
 
 
-ScriptBreakPoint.prototype.setIgnoreCount = function(ignoreCount) {
-  this.ignoreCount_ = ignoreCount;
-
-  // Set ignore count on all break points created from this script break point.
-  for (var i = 0; i < this.break_points_.length; i++) {
-    this.break_points_[i].setIgnoreCount(ignoreCount);
-  }
-};
-
-
 // Check whether a script matches this script break point. Currently this is
 // only based on script name.
 ScriptBreakPoint.prototype.matchesScript = function(script) {
   if (this.type_ == Debug.ScriptBreakPointType.ScriptId) {
     return this.script_id_ == script.id;
   } else {
     // We might want to account columns here as well.
     if (!(script.line_offset <= this.line_  &&
           this.line_ < script.line_offset + script.lineCount())) {
       return false;
@@ skipping 34 matching lines @@
 
   // Convert the line and column into an absolute position within the script.
   var position = Debug.findScriptSourcePosition(script, this.line(), column);
 
   // If the position is not found in the script (the script might be shorter
   // than it used to be) just ignore it.
   if (IS_NULL(position)) return;
 
   // Create a break point object and set the break point.
   var break_point = MakeBreakPoint(position, this);
-  break_point.setIgnoreCount(this.ignoreCount());
   var actual_position = %SetScriptBreakPoint(script, position,
                                              this.position_alignment_,
                                              break_point);
   if (IS_UNDEFINED(actual_position)) {
     actual_position = position;
   }
   var actual_location = script.locationFromPosition(actual_position, true);
   break_point.actual_location = { line: actual_location.line,
                                   column: actual_location.column,
                                   script_id: script.id };
@@ skipping 244 matching lines @@
   }
 };
 
 
 Debug.changeBreakPointCondition = function(break_point_number, condition) {
   var break_point = this.findBreakPoint(break_point_number, false);
   break_point.setCondition(condition);
 };
 
 
-Debug.changeBreakPointIgnoreCount = function(break_point_number, ignoreCount) {
-  if (ignoreCount < 0) throw MakeError(kDebugger, 'Invalid argument');
-  var break_point = this.findBreakPoint(break_point_number, false);
-  break_point.setIgnoreCount(ignoreCount);
-};
-
-
 Debug.clearBreakPoint = function(break_point_number) {
   var break_point = this.findBreakPoint(break_point_number, true);
   if (break_point) {
     return %ClearBreakPoint(break_point);
   } else {
     break_point = this.findScriptBreakPoint(break_point_number, true);
     if (!break_point) throw MakeError(kDebugger, 'Invalid breakpoint');
   }
 };
 
@@ skipping 104 matching lines @@
 };
 
 
 Debug.changeScriptBreakPointCondition = function(
     break_point_number, condition) {
   var script_break_point = this.findScriptBreakPoint(break_point_number, false);
   script_break_point.setCondition(condition);
 };
 
 
-Debug.changeScriptBreakPointIgnoreCount = function(
-    break_point_number, ignoreCount) {
-  if (ignoreCount < 0) throw MakeError(kDebugger, 'Invalid argument');
-  var script_break_point = this.findScriptBreakPoint(break_point_number, false);
-  script_break_point.setIgnoreCount(ignoreCount);
-};
-
-
 Debug.scriptBreakPoints = function() {
   return script_break_points;
 };
 
 
 Debug.clearStepping = function() {
   %ClearStepping();
 };
 
 Debug.setBreakOnException = function() {
@@ skipping 618 matching lines @@
   }
 
   // Pull out arguments.
   var type = request.arguments.type;
   var target = request.arguments.target;
   var line = request.arguments.line;
   var column = request.arguments.column;
   var enabled = IS_UNDEFINED(request.arguments.enabled) ?
       true : request.arguments.enabled;
   var condition = request.arguments.condition;
-  var ignoreCount = request.arguments.ignoreCount;
   var groupId = request.arguments.groupId;
 
   // Check for legal arguments.
   if (!type || IS_UNDEFINED(target)) {
     response.failed('Missing argument "type" or "target"');
     return;
   }
 
   // Either function or script break point.
   var break_point_number;
@@ skipping 45 matching lines @@
     break_point_number =
         Debug.setScriptBreakPointByRegExp(target, line, column, condition,
                                           groupId);
   } else {
     response.failed('Illegal type "' + type + '"');
     return;
   }
 
   // Set additional break point properties.
   var break_point = Debug.findBreakPoint(break_point_number);
-  if (ignoreCount) {
-    Debug.changeBreakPointIgnoreCount(break_point_number, ignoreCount);
-  }
   if (!enabled) {
     Debug.disableBreakPoint(break_point_number);
   }
 
   // Add the break point number to the response.
   response.body = { type: type,
                     breakpoint: break_point_number };
 
   // Add break point information to the response.
   if (break_point instanceof ScriptBreakPoint) {
@@ skipping 25 matching lines @@
   // Check for legal request.
   if (!request.arguments) {
     response.failed('Missing arguments');
     return;
   }
 
   // Pull out arguments.
   var break_point = TO_NUMBER(request.arguments.breakpoint);
   var enabled = request.arguments.enabled;
   var condition = request.arguments.condition;
-  var ignoreCount = request.arguments.ignoreCount;
 
   // Check for legal arguments.
   if (!break_point) {
     response.failed('Missing argument "breakpoint"');
     return;
   }
 
   // Change enabled state if supplied.
   if (!IS_UNDEFINED(enabled)) {
     if (enabled) {
       Debug.enableBreakPoint(break_point);
     } else {
       Debug.disableBreakPoint(break_point);
     }
   }
 
   // Change condition if supplied
   if (!IS_UNDEFINED(condition)) {
     Debug.changeBreakPointCondition(break_point, condition);
   }
-
-  // Change ignore count if supplied
-  if (!IS_UNDEFINED(ignoreCount)) {
-    Debug.changeBreakPointIgnoreCount(break_point, ignoreCount);
-  }
 };
 
 
 DebugCommandProcessor.prototype.clearBreakPointGroupRequest_ = function(
     request, response) {
   // Check for legal request.
   if (!request.arguments) {
     response.failed('Missing arguments');
     return;
   }
@@ skipping 54 matching lines @@
     request, response) {
   var array = [];
   for (var i = 0; i < script_break_points.length; i++) {
     var break_point = script_break_points[i];
 
     var description = {
       number: break_point.number(),
       line: break_point.line(),
       column: break_point.column(),
       groupId: break_point.groupId(),
-      hit_count: break_point.hit_count(),
       active: break_point.active(),
       condition: break_point.condition(),
-      ignoreCount: break_point.ignoreCount(),
       actual_locations: break_point.actual_locations()
     };
 
     if (break_point.type() == Debug.ScriptBreakPointType.ScriptId) {
       description.type = 'scriptId';
       description.script_id = break_point.script_id();
     } else if (break_point.type() == Debug.ScriptBreakPointType.ScriptName) {
       description.type = 'scriptName';
       description.script_name = break_point.script_name();
     } else if (break_point.type() == Debug.ScriptBreakPointType.ScriptRegExp) {
@@ skipping 869 matching lines @@
   "IsBreakPointTriggered", IsBreakPointTriggered,
   "UpdateScriptBreakPoints", UpdateScriptBreakPoints,
 ]);
 
 // Export to liveedit.js
 utils.Export(function(to) {
   to.GetScriptBreakPoints = GetScriptBreakPoints;
 });
 
 })