Preserve breakpoints on page reload

webkit/glue/devtools/js/debugger_agent.js

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @fileoverview Provides communication interface to remote v8 debugger. See
  * protocol decription at http://code.google.com/p/v8/wiki/DebuggerProtocol
  */
 goog.provide('devtools.DebuggerAgent');
 
@@ skipping 61 matching lines @@
    * Whether profiling session is started.
    * @type {boolean}
    */
   this.isProfilingStarted_ = false;
 
   /**
    * Profiler processor instance.
    * @type {devtools.profiler.Processor}
    */
   this.profilerProcessor_ = new devtools.profiler.Processor();
+
+  /**
+   * Container of all breakpoints set using resource URL. These breakpoints
+   * survive page reload. Breakpoints set by script id(for scripts that don't
+   * have URLs) are stored in ScriptInfo objects.
+   * @type {Object}
+   */
+  this.urlToBreakpoints_ = {};
 };
 
 
 /**
  * Resets debugger agent to its initial state.
  */
 devtools.DebuggerAgent.prototype.reset = function() {
   this.scriptsCacheInitialized_ = false;
   this.contextId_ = null;
   this.parsedScripts_ = {};
@@ skipping 84 matching lines @@
  * @param {number} line Number of the line for the breakpoint.
  */
 devtools.DebuggerAgent.prototype.addBreakpoint = function(sourceId, line) {
   var script = this.parsedScripts_[sourceId];
   if (!script) {
     return;
   }
 
   line = devtools.DebuggerAgent.webkitToV8LineNumber_(line);
 
-  var breakpointInfo = script.getBreakpointInfo(line);
-  if (breakpointInfo) {
-    return;
+  var commandArguments;
+  if (script.getUrl()) {
+    var breakpoints = this.urlToBreakpoints_[script.getUrl()];
+    if (breakpoints && breakpoints[line]) {
+      return;
+    }
+    if (!breakpoints) {
+      breakpoints = {};
+      this.urlToBreakpoints_[script.getUrl()] = breakpoints;
+    }
+
+    var breakpointInfo = new devtools.BreakpointInfo(line);
+    breakpoints[line] = breakpointInfo;
+
+    commandArguments = {
+      'type': 'script',
+      'target': script.getUrl(),
+      'line': line
+    };
+  } else {
+    var breakpointInfo = script.getBreakpointInfo(line);
+    if (breakpointInfo) {
+      return;
+    }
+
+    breakpointInfo = new devtools.BreakpointInfo(line);
+    script.addBreakpointInfo(breakpointInfo);
+
+    commandArguments = {
+      'type': 'scriptId',
+      'target': sourceId,
+      'line': line
+    };
   }
 
-  breakpointInfo = new devtools.BreakpointInfo(sourceId, line);
-  script.addBreakpointInfo(breakpointInfo);
-
-  var cmd = new devtools.DebugCommand('setbreakpoint', {
-    'type': 'scriptId',
-    'target': sourceId,
-    'line': line
-  });
+  var cmd = new devtools.DebugCommand('setbreakpoint', commandArguments);
 
   this.requestNumberToBreakpointInfo_[cmd.getSequenceNumber()] = breakpointInfo;
 
   devtools.DebuggerAgent.sendCommand_(cmd);
 };
 
 
 /**
  * @param {number} sourceId Id of the script fot the breakpoint.
  * @param {number} line Number of the line for the breakpoint.
  */
 devtools.DebuggerAgent.prototype.removeBreakpoint = function(sourceId, line) {
   var script = this.parsedScripts_[sourceId];
   if (!script) {
     return;
   }
 
   line = devtools.DebuggerAgent.webkitToV8LineNumber_(line);
 
-  var breakpointInfo = script.getBreakpointInfo(line);
-  script.removeBreakpointInfo(breakpointInfo);
+  var breakpointInfo;
+  if (script.getUrl()) {
+    var breakpoints = this.urlToBreakpoints_[script.getUrl()];
+    breakpointInfo = breakpoints[line];
+    delete breakpoints[line];
+  } else {
+    breakpointInfo = script.getBreakpointInfo(line);
+    script.removeBreakpointInfo(breakpointInfo);
+  }
+
   breakpointInfo.markAsRemoved();
 
   var id = breakpointInfo.getV8Id();
 
   // If we don't know id of this breakpoint in the v8 debugger we cannot send
   // 'clearbreakpoint' request. In that case it will be removed in
   // 'setbreakpoint' response handler when we learn the id.
   if (id != -1) {
     this.requestClearBreakpoint_(id);
   }
@@ skipping 447 matching lines @@
  * Adds the script info to the local cache. This method assumes that the script
  * is not in the cache yet.
  * @param {Object} script Script json object from the debugger message.
  * @param {devtools.DebuggerMessage} msg Debugger message containing the script
  *     data.
  */
 devtools.DebuggerAgent.prototype.addScriptInfo_ = function(script, msg) {
   var context = msg.lookup(script.context.ref);
   var contextType = context.data.type;
   this.parsedScripts_[script.id] = new devtools.ScriptInfo(
-      script.id, script.lineOffset, contextType);
+      script.id, script.name, script.lineOffset, contextType);
   WebInspector.parsedScriptSource(
       script.id, script.name, script.source, script.lineOffset);
 };
 
 
 /**
  * @param {devtools.DebuggerMessage} msg
  */
 devtools.DebuggerAgent.prototype.handleClearBreakpointResponse_ = function(
     msg) {
@@ skipping 191 matching lines @@
  * @param {number} line Resource line number in v8.
  * @return {number} The line number in Web Inspector.
  */
 devtools.DebuggerAgent.v8ToWwebkitLineNumber_ = function(line) {
   return line + 1;
 };
 
 
 /**
  * @param {number} scriptId Id of the script.
+ * @param {?string} url Script resource URL if any.
  * @param {number} lineOffset First line 0-based offset in the containing
  *     document.
  * @param {string} contextType Type of the script's context:
  *     "page" - regular script from html page
  *     "injected" - extension content script
  * @constructor
  */
-devtools.ScriptInfo = function(scriptId, lineOffset, contextType) {
+devtools.ScriptInfo = function(scriptId, url, lineOffset, contextType) {
   this.scriptId_ = scriptId;
   this.lineOffset_ = lineOffset;
   this.contextType_ = contextType;
+  this.url_ = url;
 
   this.lineToBreakpointInfo_ = {};
 };
 
 
 /**
  * @return {number}
  */
 devtools.ScriptInfo.prototype.getLineOffset = function() {
   return this.lineOffset_;
 };
 
 
 /**
  * @return {string}
  */
 devtools.ScriptInfo.prototype.getContextType = function() {
   return this.contextType_;
 };
 
 
 /**
+ * @return {?string}
+ */
+devtools.ScriptInfo.prototype.getUrl = function() {
+  return this.url_;
+};
+
+
+/**
  * @param {number} line 0-based line number in the script.
  * @return {?devtools.BreakpointInfo} Information on a breakpoint at the
  *     specified line in the script or undefined if there is no breakpoint at
  *     that line.
  */
 devtools.ScriptInfo.prototype.getBreakpointInfo = function(line) {
   return this.lineToBreakpointInfo_[line];
 };
 
 
@@ skipping 10 matching lines @@
  * @param {devtools.BreakpointInfo} breakpoint Breakpoint info to be removed.
  */
 devtools.ScriptInfo.prototype.removeBreakpointInfo = function(breakpoint) {
   var line = breakpoint.getLine();
   delete this.lineToBreakpointInfo_[line];
 };
 
 
 
 /**
- * @param {number} scriptId Id of the owning script.
  * @param {number} line Breakpoint 0-based line number in the containing script.
  * @constructor
  */
-devtools.BreakpointInfo = function(sourceId, line) {
-  this.sourceId_ = sourceId;
+devtools.BreakpointInfo = function(line) {
   this.line_ = line;
   this.v8id_ = -1;
   this.removed_ = false;
 };
 
 
 /**
  * @return {number}
  */
-devtools.BreakpointInfo.prototype.getSourceId = function(n) {
-  return this.sourceId_;
-};
-
-
-/**
- * @return {number}
- */
 devtools.BreakpointInfo.prototype.getLine = function(n) {
   return this.line_;
 };
 
 
 /**
  * @return {number} Unique identifier of this breakpoint in the v8 debugger.
  */
 devtools.BreakpointInfo.prototype.getV8Id = function(n) {
   return this.v8id_;
@@ skipping 197 matching lines @@
 
 
 /**
  * @param {number} handle Object handle.
  * @return {?Object} Returns the object with the handle if it was sent in this
  *    message(some objects referenced by handles may be missing in the message).
  */
 devtools.DebuggerMessage.prototype.lookup = function(handle) {
   return this.refs_[handle];
 };