Provide actual breakpoints locations in response to setBreakpoint and listBreakpoints requests.

src/debug-debugger.js

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 218 matching lines @@
   } else {  // type == Debug.ScriptBreakPointType.ScriptName
     this.script_name_ = script_id_or_name;
   }
   this.line_ = opt_line || 0;
   this.column_ = opt_column;
   this.groupId_ = opt_groupId;
   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_);
   copy.number_ = next_break_point_number++;
   script_break_points.push(copy);
   
@@ skipping 33 matching lines @@
 ScriptBreakPoint.prototype.line = function() {
   return this.line_;
 };
 
 
 ScriptBreakPoint.prototype.column = function() {
   return this.column_;
 };
 
 
+ScriptBreakPoint.prototype.actual_locations = function() {
+  var locations = [];
+  for (var i = 0; i < this.break_points_.length; i++) {
+    locations.push(this.break_points_[i].actual_location);
+  }
+  return locations;
+}
+
+
 ScriptBreakPoint.prototype.update_positions = function(line, column) {
   this.line_ = line;
   this.column_ = column;
 }
 
 
 ScriptBreakPoint.prototype.hit_count = function() {
   return this.hit_count_;
 };
 
@@ skipping 25 matching lines @@
 
 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 < break_points.length; i++) {
-    if (break_points[i].script_break_point() === this) {
-      break_points[i].setIgnoreCount(ignoreCount);
-    }
+  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 {  // this.type_ == Debug.ScriptBreakPointType.ScriptName
@@ skipping 21 matching lines @@
 
     // Fill cache if needed and get column where the actual source starts.
     if (IS_UNDEFINED(script.sourceColumnStart_[line])) {
       script.sourceColumnStart_[line] =
           source_line.match(sourceLineBeginningSkip)[0].length;
     }
     column = script.sourceColumnStart_[line];
   }
 
   // Convert the line and column into an absolute position within the script.
-  var pos = Debug.findScriptSourcePosition(script, this.line(), column);
+  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 (pos === null) return;
+  if (position === null) return;
 
   // Create a break point object and set the break point.
-  break_point = MakeBreakPoint(pos, this.line(), this.column(), this);
+  break_point = MakeBreakPoint(position, this.line(), this.column(), this);
   break_point.setIgnoreCount(this.ignoreCount());
-  pos = %SetScriptBreakPoint(script, pos, break_point);
-  if (!IS_UNDEFINED(pos)) {
-    this.actual_location = script.locationFromPosition(pos);
+  var actual_position = %SetScriptBreakPoint(script, position, break_point);
+  if (IS_UNDEFINED(actual_position)) {

[Søren Thygesen Gjesse, 2010/06/28 06:50:30]

Is this undefined check still needed after the change to runtime.cc?

[podivilov, 2010/06/28 12:10:06]

Yes, because Runtime_SetScriptBreakPoint returns undefined in case no
SharedFunctionInfo is available for the given position.

+    actual_position = position;
   }
-
+  var actual_location = script.locationFromPosition(actual_position, true);
+  break_point.actual_location = { line: actual_location.line,
+                                  column: actual_location.column };
+  this.break_points_.push(break_point);
   return break_point;
 };
 
 
 // Clear all the break points created from this script break point
 ScriptBreakPoint.prototype.clear = function () {
   var remaining_break_points = [];
   for (var i = 0; i < break_points.length; i++) {
     if (break_points[i].script_break_point() &&
         break_points[i].script_break_point() === this) {
       %ClearBreakPoint(break_points[i]);
     } else {
       remaining_break_points.push(break_points[i]);
     }
   }
   break_points = remaining_break_points;
+  this.break_points_ = [];
 };
 
 
 // Function called from runtime when a new script is compiled to set any script
 // break points set in this script.
 function UpdateScriptBreakPoints(script) {
   for (var i = 0; i < script_break_points.length; i++) {
     if (script_break_points[i].type() == Debug.ScriptBreakPointType.ScriptName &&
         script_break_points[i].matchesScript(script)) {
       script_break_points[i].set(script);
@@ skipping 125 matching lines @@
       break;
     }
   }
   if (break_point) {
     return break_point;
   } else {
     return this.findScriptBreakPoint(break_point_number, remove);
   }
 };
 
+Debug.findBreakPointActualLocations = function(break_point_number) {
+  for (var i = 0; i < script_break_points.length; i++) {
+    if (script_break_points[i].number() == break_point_number) {
+      return script_break_points[i].actual_locations();
+    }
+  }
+  for (var i = 0; i < break_points.length; i++) {
+    if (break_points[i].number() == break_point_number) {
+      return [break_points[i].actual_location];
+    }
+  }
+  return [];
+}
 
 Debug.setBreakPoint = function(func, opt_line, opt_column, opt_condition) {
   if (!IS_FUNCTION(func)) throw new Error('Parameters have wrong types.');
   // Break points in API functions are not supported.
   if (%FunctionIsAPIFunction(func)) {
     throw new Error('Cannot set break point in native code.');
   }
   // Find source position relative to start of the function
   var break_position =
       this.findFunctionSourceLocation(func, opt_line, opt_column).position;
@@ skipping 11 matching lines @@
     source_position += %FunctionGetScriptSourcePosition(func);
     // Find line and column for the position in the script and set a script
     // break point from that.
     var location = script.locationFromPosition(source_position, false);
     return this.setScriptBreakPointById(script.id,
                                         location.line, location.column,
                                         opt_condition);
   } else {
     // Set a break point directly on the function.
     var break_point = MakeBreakPoint(source_position, opt_line, opt_column);
-    %SetFunctionBreakPoint(func, source_position, break_point);
+    var pos = %SetFunctionBreakPoint(func, source_position, break_point);

[Søren Thygesen Gjesse, 2010/06/28 06:50:30]

Maybe pos -> actual_position as above

[podivilov, 2010/06/28 12:10:06]

Done.

+    pos += this.sourcePosition(func);
+    var actual_location = script.locationFromPosition(pos, true);
+    break_point.actual_location = { line: actual_location.line,
+                                    column: actual_location.column };
     break_point.setCondition(opt_condition);
     return break_point.number();
   }
 };
 
 
 Debug.enableBreakPoint = function(break_point_number) {
   var break_point = this.findBreakPoint(break_point_number, false);
   break_point.enable();
 };
@@ skipping 876 matching lines @@
   if (break_point instanceof ScriptBreakPoint) {
     if (break_point.type() == Debug.ScriptBreakPointType.ScriptId) {
       response.body.type = 'scriptId';
       response.body.script_id = break_point.script_id();
     } else {
       response.body.type = 'scriptName';
       response.body.script_name = break_point.script_name();
     }
     response.body.line = break_point.line();
     response.body.column = break_point.column();
+    response.body.actual_locations = break_point.actual_locations();
   } else {
     response.body.type = 'function';
+    response.body.actual_locations = [break_point.actual_location];
   }
 };
 
 
 DebugCommandProcessor.prototype.changeBreakPointRequest_ = function(request, response) {
   // Check for legal request.
   if (!request.arguments) {
     response.failed('Missing arguments');
     return;
   }
@@ skipping 94 matching lines @@
     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()
+      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 {
       description.type = 'scriptName';
       description.script_name = break_point.script_name();
     }
     array.push(description);
@@ skipping 581 matching lines @@
     case 'string':
     case 'number':
       json = value;
       break
 
     default:
       json = null;
   }
   return json;
 }