Changeset 74103 in webkit

Timestamp:

Dec 15, 2010 2:39:17 AM (13 years ago)

Author:

podivilov@chromium.org

Message:

2010-12-13 Pavel Podivilov <​podivilov@chromium.org>

Reviewed by Yury Semikhatsky.

Web Inspector: push persistent breakpoints into backend state cookie so they hit on navigation.
​https://bugs.webkit.org/show_bug.cgi?id=48858

BreakpointManager pushes all persistent breakpoints to backend when loaded.
InspectorController restores sticky breakpoints from cookie on navigation.

• inspector/Inspector.idl:
• inspector/InspectorController.cpp: (WebCore::InspectorController::InspectorController): (WebCore::InspectorController::disconnectFrontend): (WebCore::InspectorController::didCommitLoad): (WebCore::InspectorController::setStickyBreakpoints): (WebCore::InspectorController::restoreStickyBreakpoints): (WebCore::InspectorController::restoreStickyBreakpoint):
• inspector/InspectorController.h:
• inspector/InspectorState.cpp: (WebCore::InspectorState::InspectorState): (WebCore::InspectorState::getObject): (WebCore::InspectorState::setObject): (WebCore::InspectorState::registerObject):
• inspector/InspectorState.h:
• inspector/front-end/BreakpointManager.js: (WebInspector.BreakpointManager):
• inspector/front-end/BreakpointsSidebarPane.js: (WebInspector.BreakpointsSidebarPane): (WebInspector.BreakpointsSidebarPane.prototype._removeListElement): (WebInspector.BreakpointsSidebarPane.prototype._projectChanged): (WebInspector.EventListenerBreakpointsSidebarPane): (WebInspector.EventListenerBreakpointsSidebarPane.prototype._createCategory): (WebInspector.EventListenerBreakpointsSidebarPane.prototype._breakpointAdded): (WebInspector.EventListenerBreakpointsSidebarPane.prototype._projectChanged):
• inspector/front-end/CallStackSidebarPane.js: (WebInspector.CallStackSidebarPane):
• inspector/front-end/ElementsPanel.js: (WebInspector.ElementsPanel.prototype.reset):
• inspector/front-end/ScriptsPanel.js: (WebInspector.ScriptsPanel.prototype.reset):
• inspector/front-end/Settings.js: (WebInspector.Settings.prototype.inspectedURLChanged): (WebInspector.Settings.prototype.get projectId): (WebInspector.Settings.prototype.findSettingForAllProjects): (WebInspector.Settings.prototype._formatProjectKey):
• inspector/front-end/inspector.js: (WebInspector.createDOMBreakpointsSidebarPane): (WebInspector.createXHRBreakpointsSidebarPane): (WebInspector.reset): (WebInspector.inspectedURLChanged):

Location:

trunk/WebCore

Files:

• ChangeLog (modified) (1 diff)
• inspector/Inspector.idl (modified) (1 diff)
• inspector/InspectorController.cpp (modified) (5 diffs)
• inspector/InspectorController.h (modified) (3 diffs)
• inspector/InspectorState.cpp (modified) (3 diffs)
• inspector/InspectorState.h (modified) (3 diffs)
• inspector/front-end/BreakpointManager.js (modified) (22 diffs)
• inspector/front-end/BreakpointsSidebarPane.js (modified) (6 diffs)
• inspector/front-end/CallStackSidebarPane.js (modified) (1 diff)
• inspector/front-end/ElementsPanel.js (modified) (1 diff)
• inspector/front-end/ScriptsPanel.js (modified) (1 diff)
• inspector/front-end/Settings.js (modified) (3 diffs)
• inspector/front-end/inspector.js (modified) (5 diffs)

trunk/WebCore/ChangeLog

@@ +1 @@
+2010-12-13  Pavel Podivilov  <podivilov@chromium.org>
+
+        Reviewed by Yury Semikhatsky.
+
+        Web Inspector: push persistent breakpoints into backend state cookie so they hit on navigation.
+        https://bugs.webkit.org/show_bug.cgi?id=48858
+
+        BreakpointManager pushes all persistent breakpoints to backend when loaded.
+        InspectorController restores sticky breakpoints from cookie on navigation.
+
+        * inspector/Inspector.idl:
+        * inspector/InspectorController.cpp:
+        (WebCore::InspectorController::InspectorController):
+        (WebCore::InspectorController::disconnectFrontend):
+        (WebCore::InspectorController::didCommitLoad):
+        (WebCore::InspectorController::setStickyBreakpoints):
+        (WebCore::InspectorController::restoreStickyBreakpoints):
+        (WebCore::InspectorController::restoreStickyBreakpoint):
+        * inspector/InspectorController.h:
+        * inspector/InspectorState.cpp:
+        (WebCore::InspectorState::InspectorState):
+        (WebCore::InspectorState::getObject):
+        (WebCore::InspectorState::setObject):
+        (WebCore::InspectorState::registerObject):
+        * inspector/InspectorState.h:
+        * inspector/front-end/BreakpointManager.js:
+        (WebInspector.BreakpointManager):
+        * inspector/front-end/BreakpointsSidebarPane.js:
+        (WebInspector.BreakpointsSidebarPane):
+        (WebInspector.BreakpointsSidebarPane.prototype._removeListElement):
+        (WebInspector.BreakpointsSidebarPane.prototype._projectChanged):
+        (WebInspector.EventListenerBreakpointsSidebarPane):
+        (WebInspector.EventListenerBreakpointsSidebarPane.prototype._createCategory):
+        (WebInspector.EventListenerBreakpointsSidebarPane.prototype._breakpointAdded):
+        (WebInspector.EventListenerBreakpointsSidebarPane.prototype._projectChanged):
+        * inspector/front-end/CallStackSidebarPane.js:
+        (WebInspector.CallStackSidebarPane):
+        * inspector/front-end/ElementsPanel.js:
+        (WebInspector.ElementsPanel.prototype.reset):
+        * inspector/front-end/ScriptsPanel.js:
+        (WebInspector.ScriptsPanel.prototype.reset):
+        * inspector/front-end/Settings.js:
+        (WebInspector.Settings.prototype.inspectedURLChanged):
+        (WebInspector.Settings.prototype.get projectId):
+        (WebInspector.Settings.prototype.findSettingForAllProjects):
+        (WebInspector.Settings.prototype._formatProjectKey):
+        * inspector/front-end/inspector.js:
+        (WebInspector.createDOMBreakpointsSidebarPane):
+        (WebInspector.createXHRBreakpointsSidebarPane):
+        (WebInspector.reset):
+        (WebInspector.inspectedURLChanged):
+
 2010-12-15  Mario Sanchez Prada  <msanchez@igalia.com>
 

trunk/WebCore/inspector/Inspector.idl

@@ -220 +220 @@
         [domain=Debugger] void removeBreakpoint(in String sourceID, in unsigned long lineNumber);
 
+        [domain=Inspector] void setStickyBreakpoints(in Object breakpoints); // FIXME: Move to newly introduced BrowserDebugger.
+
         [domain=DOM] void setDOMBreakpoint(in long nodeId, in long type); // FIXME: Move to newly introduced BrowserDebugger.
         [domain=DOM] void removeDOMBreakpoint(in long nodeId, in long type); // FIXME: Move to newly introduced BrowserDebugger.

trunk/WebCore/inspector/InspectorController.cpp

@@ -150 +150 @@
     , m_attachDebuggerWhenShown(false)
     , m_hasXHRBreakpointWithEmptyURL(false)
+    , m_stickyBreakpointsRestored(false)
     , m_profilerAgent(InspectorProfilerAgent::create(this))
 #endif
@@ -561 +562 @@
     disableDebugger();
     m_attachDebuggerWhenShown = debuggerWasEnabled;
-    clearNativeBreakpoints();
 #endif
     setSearchingForNode(false);
@@ -718 +718 @@
 
 #if ENABLE(JAVASCRIPT_DEBUGGER)
-        if (m_debuggerAgent)
+        if (m_debuggerAgent) {
             m_debuggerAgent->clearForPageNavigation();
-
-        clearNativeBreakpoints();
+            restoreStickyBreakpoints();
+        }
 #endif
 
@@ -1383 +1383 @@
 }
 
+void InspectorController::setStickyBreakpoints(PassRefPtr<InspectorObject> breakpoints)
+{
+    m_state->setObject(InspectorState::stickyBreakpoints, breakpoints);
+    if (!m_stickyBreakpointsRestored) {
+        restoreStickyBreakpoints();
+        m_stickyBreakpointsRestored = true;
+    }
+}
+
+void InspectorController::restoreStickyBreakpoints()
+{
+    m_eventListenerBreakpoints.clear();
+    m_XHRBreakpoints.clear();
+    m_hasXHRBreakpointWithEmptyURL = false;
+
+    RefPtr<InspectorObject> allBreakpoints = m_state->getObject(InspectorState::stickyBreakpoints);
+    KURL url = m_inspectedPage->mainFrame()->loader()->url();
+    url.removeFragmentIdentifier();
+    RefPtr<InspectorArray> breakpoints = allBreakpoints->getArray(url);
+    if (!breakpoints)
+        return;
+    for (unsigned i = 0; i < breakpoints->length(); ++i)
+        restoreStickyBreakpoint(breakpoints->get(i)->asObject());
+}
+
+void InspectorController::restoreStickyBreakpoint(PassRefPtr<InspectorObject> breakpoint)
+{
+    DEFINE_STATIC_LOCAL(String, eventListenerNativeBreakpointType, ("EventListener"));
+    DEFINE_STATIC_LOCAL(String, xhrNativeBreakpointType, ("XHR"));
+
+    if (!breakpoint)
+        return;
+    String type;
+    if (!breakpoint->getString("type", &type))
+        return;
+    bool enabled;
+    if (!breakpoint->getBoolean("enabled", &enabled) || !enabled)
+        return;
+    RefPtr<InspectorObject> condition = breakpoint->getObject("condition");
+    if (!condition)
+        return;
+
+    if (type == eventListenerNativeBreakpointType) {
+        String eventName;
+        if (condition->getString("eventName", &eventName))
+            setEventListenerBreakpoint(eventName);
+    } else if (type == xhrNativeBreakpointType) {
+        String url;
+        if (condition->getString("url", &url))
+            setXHRBreakpoint(url);
+    }
+}
+
 void InspectorController::setEventListenerBreakpoint(const String& eventName)
 {
@@ -1429 +1482 @@
 }
 
-void InspectorController::clearNativeBreakpoints()
-{
-    m_eventListenerBreakpoints.clear();
-    m_XHRBreakpoints.clear();
-    m_hasXHRBreakpointWithEmptyURL = false;
-}
 #endif
 

trunk/WebCore/inspector/InspectorController.h

@@ -256 +256 @@
     void resume();
 
+    void setStickyBreakpoints(PassRefPtr<InspectorObject> breakpoints);
     void setEventListenerBreakpoint(const String& eventName);
     void removeEventListenerBreakpoint(const String& eventName);
@@ -310 +311 @@
     void toggleRecordButton(bool);
     void enableDebuggerFromFrontend(bool always);
-
-    void clearNativeBreakpoints();
+    void restoreStickyBreakpoints();
+    void restoreStickyBreakpoint(PassRefPtr<InspectorObject> breakpoint);
 #endif
 #if ENABLE(DATABASE)
@@ -392 +393 @@
     HashSet<String> m_XHRBreakpoints;
     bool m_hasXHRBreakpointWithEmptyURL;
+    bool m_stickyBreakpointsRestored;
 
     OwnPtr<InspectorProfilerAgent> m_profilerAgent;

trunk/WebCore/inspector/InspectorState.cpp

@@ -41 +41 @@
 {
     registerBoolean(monitoringXHR, false, "monitoringXHREnabled", "xhrMonitor");
-    registerBoolean(timelineProfilerEnabled, false, "timelineProfilerEnabled", (const char*)0);
-    registerBoolean(searchingForNode, false, "searchingForNodeEnabled", (const char*)0);
-    registerBoolean(profilerAlwaysEnabled, false, (const char*)0, "profilerEnabled");
-    registerBoolean(debuggerAlwaysEnabled, false, (const char*)0, "debuggerEnabled");
-    registerBoolean(inspectorStartsAttached, true, (const char*)0, "InspectorStartsAttached");
-    registerLong(inspectorAttachedHeight, InspectorController::defaultAttachedHeight, (const char*)0, "inspectorAttachedHeight");
-    registerLong(pauseOnExceptionsState, 0, "pauseOnExceptionsState", (const char*)0);
-    registerBoolean(consoleMessagesEnabled, false, "consoleMessagesEnabled", (const char*)0);
-    registerBoolean(userInitiatedProfiling, false, "userInitiatedProfiling", (const char*)0);
+    registerBoolean(timelineProfilerEnabled, false, "timelineProfilerEnabled", String());
+    registerBoolean(searchingForNode, false, "searchingForNodeEnabled", String());
+    registerBoolean(profilerAlwaysEnabled, false, String(), "profilerEnabled");
+    registerBoolean(debuggerAlwaysEnabled, false, String(), "debuggerEnabled");
+    registerBoolean(inspectorStartsAttached, true, String(), "InspectorStartsAttached");
+    registerLong(inspectorAttachedHeight, InspectorController::defaultAttachedHeight, String(), "inspectorAttachedHeight");
+    registerLong(pauseOnExceptionsState, 0, "pauseOnExceptionsState", String());
+    registerBoolean(consoleMessagesEnabled, false, "consoleMessagesEnabled", String());
+    registerBoolean(userInitiatedProfiling, false, "userInitiatedProfiling", String());
+    registerObject(stickyBreakpoints, String(), String());
 }
 
@@ -153 +154 @@
 }
 
+PassRefPtr<InspectorObject> InspectorState::getObject(InspectorPropertyId id)
+{
+    PropertyMap::iterator i = m_properties.find(id);
+    ASSERT(i != m_properties.end());
+    return i->second.m_value->asObject();
+}
+
+void InspectorState::setObject(InspectorPropertyId id, PassRefPtr<InspectorObject> value)
+{
+    PropertyMap::iterator i = m_properties.find(id);
+    ASSERT(i != m_properties.end());
+    Property& property = i->second;
+    property.m_value = value;
+    if (property.m_preferenceName.length())
+        m_client->storeSetting(property.m_preferenceName, value->toJSONString());
+    updateCookie();
+}
+
 void InspectorState::registerBoolean(InspectorPropertyId propertyId, bool value, const String& frontendAlias, const String& preferenceName)
 {
@@ -166 +185 @@
 {
     m_properties.set(propertyId, Property::create(InspectorBasicValue::create((double)value), frontendAlias, preferenceName));
+}
+
+void InspectorState::registerObject(InspectorPropertyId propertyId, const String& frontendAlias, const String& preferenceName)
+{
+    m_properties.set(propertyId, Property::create(InspectorObject::create(), frontendAlias, preferenceName));
 }
 

trunk/WebCore/inspector/InspectorState.h

@@ -56 +56 @@
         consoleMessagesEnabled,
         userInitiatedProfiling,
+        stickyBreakpoints,
         lastPropertyId
     };
@@ -69 +70 @@
     String getString(InspectorPropertyId propertyId);
     long getLong(InspectorPropertyId propertyId);
+    PassRefPtr<InspectorObject> getObject(InspectorPropertyId id);
 
     void setBoolean(InspectorPropertyId propertyId, bool value) { setValue(propertyId, InspectorBasicValue::create(value), value ? "true" : "false"); }
     void setString(InspectorPropertyId propertyId, const String& value) { setValue(propertyId, InspectorString::create(value), value); }
     void setLong(InspectorPropertyId propertyId, long value) { setValue(propertyId, InspectorBasicValue::create((double)value), String::number(value)); }
+    void setObject(InspectorPropertyId propertyId, PassRefPtr<InspectorObject> value);
 
 private:
@@ -90 +93 @@
     void registerString(InspectorPropertyId propertyId, const String& value, const String& frontendAlias, const String& preferenceName);
     void registerLong(InspectorPropertyId propertyId, long value, const String& frontendAlias, const String& preferenceName);
+    void registerObject(InspectorPropertyId propertyId, const String& frontendAlias, const String& preferenceName);
 
     InspectorClient* m_client;

trunk/WebCore/inspector/front-end/BreakpointManager.js

@@ -31 +31 @@
 WebInspector.BreakpointManager = function()
 {
+    this._stickyBreakpoints = {};
+    var breakpoints = WebInspector.settings.findSettingForAllProjects("nativeBreakpoints");
+    for (var projectId in breakpoints)
+        this._stickyBreakpoints[projectId] = this._validateBreakpoints(breakpoints[projectId]);
+    InspectorBackend.setStickyBreakpoints(this._stickyBreakpoints);
+
     this._nativeBreakpoints = {};
-
+    this._domBreakpointsRestored = false;
+
+    WebInspector.settings.addEventListener(WebInspector.Settings.Events.ProjectChanged, this._projectChanged, this);
     WebInspector.debuggerModel.addEventListener("native-breakpoint-hit", this._nativeBreakpointHit, this);
     WebInspector.debuggerModel.addEventListener("debugger-resumed", this._debuggerResumed, this);
@@ -43 +51 @@
 }
 
+WebInspector.BreakpointManager.Events = {
+    DOMBreakpointAdded: "dom-breakpoint-added",
+    EventListenerBreakpointAdded: "event-listener-breakpoint-added",
+    XHRBreakpointAdded: "xhr-breakpoint-added",
+    NativeBreakpointHit: "native-breakpoint-hit",
+    ProjectChanged: "project-changed"
+}
+
 WebInspector.BreakpointManager.prototype = {
-    createDOMBreakpoint: function(nodeId, type, disabled)
+    createDOMBreakpoint: function(nodeId, type)
+    {
+        this._createDOMBreakpoint(nodeId, type, true, false);
+    },
+
+    _createDOMBreakpoint: function(nodeId, type, enabled, restored)
     {
         var node = WebInspector.domAgent.nodeForId(nodeId);
@@ -54 +75 @@
             return;
 
-        var breakpoint = new WebInspector.DOMBreakpoint(this, breakpointId, !disabled, node, type);
-        this._nativeBreakpoints[breakpointId] = breakpoint;
-        this._updateNativeBreakpointsInSettings();
-        this.dispatchEventToListeners("dom-breakpoint-added", breakpoint);
-        return breakpoint;
+        var breakpoint = new WebInspector.DOMBreakpoint(node, type);
+        this._setNativeBreakpoint(breakpointId, breakpoint, enabled, restored);
+        if (enabled && restored)
+            breakpoint._enable();
+
+        breakpoint.view = new WebInspector.DOMBreakpointView(this, breakpointId, enabled, node, type);
+        this.dispatchEventToListeners(WebInspector.BreakpointManager.Events.DOMBreakpointAdded, breakpoint.view);
     },
 
     createEventListenerBreakpoint: function(eventName)
+    {
+        this._createEventListenerBreakpoint(eventName, true, false);
+    },
+
+    _createEventListenerBreakpoint: function(eventName, enabled, restored)
     {
         var breakpointId = this._createEventListenerBreakpointId(eventName);
@@ -67 +95 @@
             return;
 
-        var breakpoint = new WebInspector.EventListenerBreakpoint(this, breakpointId, true, eventName);
-        this._nativeBreakpoints[breakpointId] = breakpoint;
-        this._updateNativeBreakpointsInSettings();
-        this.dispatchEventToListeners("event-listener-breakpoint-added", { breakpoint: breakpoint, eventName: eventName });
-        return breakpoint;
-    },
-
-    createXHRBreakpoint: function(url, disabled)
+        var breakpoint = new WebInspector.EventListenerBreakpoint(eventName);
+        this._setNativeBreakpoint(breakpointId, breakpoint, enabled, restored);
+
+        breakpoint.view = new WebInspector.EventListenerBreakpointView(this, breakpointId, enabled, eventName);
+        this.dispatchEventToListeners(WebInspector.BreakpointManager.Events.EventListenerBreakpointAdded, breakpoint.view);
+    },
+
+    createXHRBreakpoint: function(url)
+    {
+        this._createXHRBreakpoint(url, true, false);
+    },
+
+    _createXHRBreakpoint: function(url, enabled, restored)
     {
         var breakpointId = this._createXHRBreakpointId(url);
@@ -80 +113 @@
             return;
 
-        var breakpoint = new WebInspector.XHRBreakpoint(this, breakpointId, !disabled, url);
+        var breakpoint = new WebInspector.XHRBreakpoint(url);
+        this._setNativeBreakpoint(breakpointId, breakpoint, enabled, restored);
+
+        breakpoint.view = new WebInspector.XHRBreakpointView(this, breakpointId, enabled, url);
+        this.dispatchEventToListeners(WebInspector.BreakpointManager.Events.XHRBreakpointAdded, breakpoint.view);
+    },
+
+    _setNativeBreakpoint: function(breakpointId, breakpoint, enabled, restored)
+    {
         this._nativeBreakpoints[breakpointId] = breakpoint;
-        this._updateNativeBreakpointsInSettings();
-        this.dispatchEventToListeners("xhr-breakpoint-added", breakpoint);
-        return breakpoint;
+        breakpoint.enabled = enabled;
+        if (restored)
+            return;
+        if (enabled)
+            breakpoint._enable();
+        this._saveBreakpoints();
     },
 
@@ -90 +134 @@
     {
         var breakpoint = this._nativeBreakpoints[breakpointId];
-
+        if (breakpoint.enabled === enabled)
+            return;
         if (enabled)
             breakpoint._enable();
         else
             breakpoint._disable();
-
-        breakpoint._enabled = enabled;
-        this._updateNativeBreakpointsInSettings();
-        breakpoint.dispatchEventToListeners("enable-changed");
+        breakpoint.enabled = enabled;
+        this._saveBreakpoints();
     },
 
@@ -104 +147 @@
     {
         var breakpoint = this._nativeBreakpoints[breakpointId];
-
         if (breakpoint.enabled)
             breakpoint._disable();
-
         delete this._nativeBreakpoints[breakpointId];
-        this._updateNativeBreakpointsInSettings();
-        breakpoint.dispatchEventToListeners("removed");
-    },
-
-    _updateNativeBreakpointsInSettings: function()
-    {
-        var breakpoints = [];
-        for (var id in this._nativeBreakpoints) {
-            var breakpoint = this._nativeBreakpoints[id];
-            breakpoints.push(breakpoint._serializeToJSON());
-        }
-        WebInspector.settings.nativeBreakpoints = breakpoints;
+        this._saveBreakpoints();
     },
 
@@ -139 +169 @@
             return;
 
-        breakpoint.hit = true;
+        breakpoint.view.hit = true;
         this._lastHitBreakpoint = breakpoint;
-        this.dispatchEventToListeners("native-breakpoint-hit", { breakpoint: breakpoint, eventData: eventData });
+        this.dispatchEventToListeners(WebInspector.BreakpointManager.Events.NativeBreakpointHit, { breakpoint: breakpoint.view, eventData: eventData });
     },
 
@@ -148 +178 @@
         if (!this._lastHitBreakpoint)
             return;
-        this._lastHitBreakpoint.hit = false;
+        this._lastHitBreakpoint.view.hit = false;
         delete this._lastHitBreakpoint;
     },
 
-    restoreBreakpoints: function()
-    {
-        var breakpoints = this._persistentBreakpoints();
-        this._domBreakpoints = [];
+    _projectChanged: function(event)
+    {
+        this._nativeBreakpoints = {};
+        this._domBreakpointsRestored = false;
+        this.dispatchEventToListeners(WebInspector.BreakpointManager.Events.ProjectChanged);
+
+        var breakpoints = this._stickyBreakpoints[WebInspector.settings.projectId] || [];
         for (var i = 0; i < breakpoints.length; ++i) {
-            if (breakpoints[i].type === WebInspector.BreakpointManager.NativeBreakpointTypes.DOM)
-                this._domBreakpoints.push(breakpoints[i]);
-            else if (breakpoints[i].type === WebInspector.BreakpointManager.NativeBreakpointTypes.EventListener)
-                this.createEventListenerBreakpoint(breakpoints[i].condition.eventName);
-            else if (breakpoints[i].type === WebInspector.BreakpointManager.NativeBreakpointTypes.XHR)
-                this.createXHRBreakpoint(breakpoints[i].condition.url, !breakpoints[i].enabled);
+            var breakpoint = breakpoints[i];
+            if (breakpoint.type === WebInspector.BreakpointManager.NativeBreakpointTypes.EventListener)
+                this._createEventListenerBreakpoint(breakpoint.condition.eventName, breakpoint.enabled, true);
+            else if (breakpoint.type === WebInspector.BreakpointManager.NativeBreakpointTypes.XHR)
+                this._createXHRBreakpoint(breakpoint.condition.url, breakpoint.enabled, true);
         }
     },
@@ -175 +207 @@
                 return;
             for (var i = 0; i < breakpoints.length; ++i) {
-                if (breakpoints[i].type !== WebInspector.BreakpointManager.NativeBreakpointTypes.DOM)
+                var breakpoint = breakpoints[i];
+                if (breakpoint.type !== WebInspector.BreakpointManager.NativeBreakpointTypes.DOM)
                     continue;
-                var breakpoint = breakpoints[i];
                 var nodeId = pathToNodeId[breakpoint.condition.path];
                 if (nodeId)
-                    this.createDOMBreakpoint(nodeId, breakpoint.condition.type, !breakpoint.enabled);
+                    this._createDOMBreakpoint(nodeId, breakpoint.condition.type, breakpoint.enabled, true);
             }
+            this._domBreakpointsRestored = true;
+            this._saveBreakpoints();
         }
 
-        var breakpoints = this._domBreakpoints;
+        var breakpoints = this._stickyBreakpoints[WebInspector.settings.projectId] || [];
         var pathToNodeId = {};
         var pendingCalls = 0;
@@ -197 +231 @@
             InspectorBackend.pushNodeByPathToFrontend(path, didPushNodeByPathToFrontend.bind(this, path));
         }
-    },
-
-    _persistentBreakpoints: function()
-    {
-        var result = [];
-        var breakpoints = WebInspector.settings.nativeBreakpoints;
-        if (breakpoints instanceof Array) {
-            for (var i = 0; i < breakpoints.length; ++i) {
-                var breakpoint = breakpoints[i];
-                if ("type" in breakpoint && "condition" in breakpoint)
-                    result.push(breakpoint)
+        if (!pendingCalls)
+            this._domBreakpointsRestored = true;
+    },
+
+    _saveBreakpoints: function()
+    {
+        var breakpoints = [];
+        for (var breakpointId in this._nativeBreakpoints) {
+            var breakpoint = this._nativeBreakpoints[breakpointId];
+            var persistentBreakpoint = breakpoint._serializeToJSON();
+            persistentBreakpoint.enabled = breakpoint.enabled;
+            breakpoints.push(persistentBreakpoint);
+        }
+        if (!this._domBreakpointsRestored) {
+            var stickyBreakpoints = this._stickyBreakpoints[WebInspector.settings.projectId] || [];
+            for (var i = 0; i < stickyBreakpoints.length; ++i) {
+                if (stickyBreakpoints[i].type === WebInspector.BreakpointManager.NativeBreakpointTypes.DOM)
+                    breakpoints.push(stickyBreakpoints[i]);
             }
         }
-        return result;
+        WebInspector.settings.nativeBreakpoints = breakpoints;
+
+        this._stickyBreakpoints[WebInspector.settings.projectId] = breakpoints;
+        InspectorBackend.setStickyBreakpoints(this._stickyBreakpoints);
+    },
+
+    _validateBreakpoints: function(persistentBreakpoints)
+    {
+        var breakpoints = [];
+        var breakpointsSet = {};
+        for (var i = 0; i < persistentBreakpoints.length; ++i) {
+            var breakpoint = persistentBreakpoints[i];
+            if (!("type" in breakpoint && "enabled" in breakpoint && "condition" in breakpoint))
+                continue;
+            var id = breakpoint.type + ":";
+            var condition = breakpoint.condition;
+            if (breakpoint.type === WebInspector.BreakpointManager.NativeBreakpointTypes.DOM) {
+                if (typeof condition.path !== "string" || typeof condition.type !== "number")
+                    continue;
+                id += condition.path + ":" + condition.type;
+            } else if (breakpoint.type === WebInspector.BreakpointManager.NativeBreakpointTypes.EventListener) {
+                if (typeof condition.eventName !== "string")
+                    continue;
+                id += condition.eventName;
+            } else if (breakpoint.type === WebInspector.BreakpointManager.NativeBreakpointTypes.XHR) {
+                if (typeof condition.url !== "string")
+                    continue;
+                id += condition.url;
+            }
+            if (id in breakpointsSet)
+                continue;
+            breakpointsSet[id] = true;
+            breakpoints.push(breakpoint);
+        }
+        return breakpoints;
     },
 
@@ -226 +301 @@
     {
         return "xhr:" + url;
-    },
-
-    reset: function()
-    {
-        this._nativeBreakpoints = {};
     }
 }
@@ -236 +306 @@
 WebInspector.BreakpointManager.prototype.__proto__ = WebInspector.Object.prototype;
 
-WebInspector.NativeBreakpoint = function(manager, id, enabled)
+WebInspector.DOMBreakpoint = function(node, type)
+{
+    this._nodeId = node.id;
+    this._path = node.path();
+    this._type = type;
+}
+
+WebInspector.DOMBreakpoint.prototype = {
+    _enable: function()
+    {
+        InspectorBackend.setDOMBreakpoint(this._nodeId, this._type);
+    },
+
+    _disable: function()
+    {
+        InspectorBackend.removeDOMBreakpoint(this._nodeId, this._type);
+    },
+
+    _serializeToJSON: function()
+    {
+        var type = WebInspector.BreakpointManager.NativeBreakpointTypes.DOM;
+        return { type: type, condition: { path: this._path, type: this._type } };
+    }
+}
+
+WebInspector.EventListenerBreakpoint = function(eventName)
+{
+    this._eventName = eventName;
+}
+
+WebInspector.EventListenerBreakpoint.prototype = {
+    _enable: function()
+    {
+        InspectorBackend.setEventListenerBreakpoint(this._eventName);
+    },
+
+    _disable: function()
+    {
+        InspectorBackend.removeEventListenerBreakpoint(this._eventName);
+    },
+
+    _serializeToJSON: function()
+    {
+        var type = WebInspector.BreakpointManager.NativeBreakpointTypes.EventListener;
+        return { type: type, condition: { eventName: this._eventName } };
+    }
+}
+
+WebInspector.XHRBreakpoint = function(url)
+{
+    this._url = url;
+}
+
+WebInspector.XHRBreakpoint.prototype = {
+    _enable: function()
+    {
+        InspectorBackend.setXHRBreakpoint(this._url);
+    },
+
+    _disable: function()
+    {
+        InspectorBackend.removeXHRBreakpoint(this._url);
+    },
+
+    _serializeToJSON: function()
+    {
+        var type = WebInspector.BreakpointManager.NativeBreakpointTypes.XHR;
+        return { type: type, condition: { url: this._url } };
+    }
+}
+
+
+
+WebInspector.NativeBreakpointView = function(manager, id, enabled)
 {
     this._manager = manager;
@@ -244 +387 @@
 }
 
-WebInspector.NativeBreakpoint.prototype = {
+WebInspector.NativeBreakpointView.prototype = {
     get enabled()
     {
@@ -253 +396 @@
     {
         this._manager._setNativeBreakpointEnabled(this._id, enabled);
+        this._enabled = enabled;
+        this.dispatchEventToListeners("enable-changed");
     },
 
@@ -270 +415 @@
         this._manager._removeNativeBreakpoint(this._id);
         this._onRemove();
+        this.dispatchEventToListeners("removed");
     },
 
@@ -284 +430 @@
 }
 
-WebInspector.NativeBreakpoint.prototype.__proto__ = WebInspector.Object.prototype;
-
-WebInspector.DOMBreakpoint = function(manager, id, enabled, node, type)
-{
-    WebInspector.NativeBreakpoint.call(this, manager, id, enabled);
+WebInspector.NativeBreakpointView.prototype.__proto__ = WebInspector.Object.prototype;
+
+WebInspector.DOMBreakpointView = function(manager, id, enabled, node, type)
+{
+    WebInspector.NativeBreakpointView.call(this, manager, id, enabled);
     this._node = node;
     this._nodeId = node.id;
-    this._path = node.path();
     this._type = type;
-    if (enabled)
-        this._enable();
-
     node.breakpoints[this._type] = this;
 }
 
-WebInspector.DOMBreakpoint.prototype = {
+WebInspector.DOMBreakpointView.prototype = {
     compareTo: function(other)
     {
@@ -345 +487 @@
     },
 
-    _enable: function()
-    {
-        InspectorBackend.setDOMBreakpoint(this._nodeId, this._type);
-    },
-
-    _disable: function()
-    {
-        InspectorBackend.removeDOMBreakpoint(this._nodeId, this._type);
-    },
-
-    _serializeToJSON: function()
-    {
-        var type = WebInspector.BreakpointManager.NativeBreakpointTypes.DOM;
-        return { type: type, enabled: this._enabled, condition: { path: this._path, type: this._type } };
-    },
-
     _onRemove: function()
     {
@@ -367 +493 @@
 }
 
-WebInspector.DOMBreakpoint.prototype.__proto__ = WebInspector.NativeBreakpoint.prototype;
-
-WebInspector.EventListenerBreakpoint = function(manager, id, enabled, eventName)
-{
-    WebInspector.NativeBreakpoint.call(this, manager, id, enabled);
+WebInspector.DOMBreakpointView.prototype.__proto__ = WebInspector.NativeBreakpointView.prototype;
+
+WebInspector.EventListenerBreakpointView = function(manager, id, enabled, eventName)
+{
+    WebInspector.NativeBreakpointView.call(this, manager, id, enabled);
     this._eventName = eventName;
-    if (enabled)
-        this._enable();
-}
-
-WebInspector.EventListenerBreakpoint.eventNameForUI = function(eventName)
-{
-    if (!WebInspector.EventListenerBreakpoint._eventNamesForUI) {
-        WebInspector.EventListenerBreakpoint._eventNamesForUI = {
+}
+
+WebInspector.EventListenerBreakpointView.eventNameForUI = function(eventName)
+{
+    if (!WebInspector.EventListenerBreakpointView._eventNamesForUI) {
+        WebInspector.EventListenerBreakpointView._eventNamesForUI = {
             "instrumentation:setTimer": WebInspector.UIString("Set Timer"),
             "instrumentation:clearTimer": WebInspector.UIString("Clear Timer"),
@@ -386 +510 @@
         };
     }
-    return WebInspector.EventListenerBreakpoint._eventNamesForUI[eventName] || eventName.substring(eventName.indexOf(":") + 1);
-}
-
-WebInspector.EventListenerBreakpoint.prototype = {
+    return WebInspector.EventListenerBreakpointView._eventNamesForUI[eventName] || eventName.substring(eventName.indexOf(":") + 1);
+}
+
+WebInspector.EventListenerBreakpointView.prototype = {
+    get eventName()
+    {
+        return this._eventName;
+    },
+
     compareTo: function(other)
     {
@@ -408 +537 @@
     _uiEventName: function()
     {
-        return WebInspector.EventListenerBreakpoint.eventNameForUI(this._eventName);
-    },
-
-    _enable: function()
-    {
-        InspectorBackend.setEventListenerBreakpoint(this._eventName);
-    },
-
-    _disable: function()
-    {
-        InspectorBackend.removeEventListenerBreakpoint(this._eventName);
-    },
-
-    _serializeToJSON: function()
-    {
-        var type = WebInspector.BreakpointManager.NativeBreakpointTypes.EventListener;
-        return { type: type, enabled: this._enabled, condition: { eventName: this._eventName } };
-    }
-}
-
-WebInspector.EventListenerBreakpoint.prototype.__proto__ = WebInspector.NativeBreakpoint.prototype;
-
-WebInspector.XHRBreakpoint = function(manager, id, enabled, url)
-{
-    WebInspector.NativeBreakpoint.call(this, manager, id, enabled);
+        return WebInspector.EventListenerBreakpointView.eventNameForUI(this._eventName);
+    }
+}
+
+WebInspector.EventListenerBreakpointView.prototype.__proto__ = WebInspector.NativeBreakpointView.prototype;
+
+WebInspector.XHRBreakpointView = function(manager, id, enabled, url)
+{
+    WebInspector.NativeBreakpointView.call(this, manager, id, enabled);
     this._url = url;
-    if (enabled)
-        this._enable();
-}
-
-WebInspector.XHRBreakpoint.prototype = {
+}
+
+WebInspector.XHRBreakpointView.prototype = {
     compareTo: function(other)
     {
@@ -464 +575 @@
         var status = WebInspector.UIString("Paused on a XMLHttpRequest.");
         element.appendChild(document.createTextNode(status));
-    },
-
-    _enable: function()
-    {
-        InspectorBackend.setXHRBreakpoint(this._url);
-    },
-
-    _disable: function()
-    {
-        InspectorBackend.removeXHRBreakpoint(this._url);
-    },
-
-    _serializeToJSON: function()
-    {
-        var type = WebInspector.BreakpointManager.NativeBreakpointTypes.XHR;
-        return { type: type, enabled: this._enabled, condition: { url: this._url } };
-    }
-}
-
-WebInspector.XHRBreakpoint.prototype.__proto__ = WebInspector.NativeBreakpoint.prototype;
+    }
+}
+
+WebInspector.XHRBreakpointView.prototype.__proto__ = WebInspector.NativeBreakpointView.prototype;
 
 WebInspector.DOMBreakpointTypes = {

trunk/WebCore/inspector/front-end/BreakpointsSidebarPane.js

@@ -36 +36 @@
 
     this.bodyElement.appendChild(this.emptyElement);
+
+    WebInspector.breakpointManager.addEventListener(WebInspector.BreakpointManager.Events.ProjectChanged, this._projectChanged, this);
 }
 
 WebInspector.BreakpointsSidebarPane.prototype = {
-    reset: function()
-    {
-        this.listElement.removeChildren();
-        if (this.listElement.parentElement) {
-            this.bodyElement.removeChild(this.listElement);
-            this.bodyElement.appendChild(this.emptyElement);
-        }
-    },
-
     addBreakpointItem: function(breakpointItem)
     {
@@ -95 +88 @@
         this.listElement.removeChild(element);
         if (!this.listElement.firstChild) {
+            this.bodyElement.removeChild(this.listElement);
+            this.bodyElement.appendChild(this.emptyElement);
+        }
+    },
+
+    _projectChanged: function()
+    {
+        this.listElement.removeChildren();
+        if (this.listElement.parentElement) {
             this.bodyElement.removeChild(this.listElement);
             this.bodyElement.appendChild(this.emptyElement);
@@ -260 +262 @@
     this.bodyElement.appendChild(this.categoriesElement);
 
-    WebInspector.breakpointManager.addEventListener("event-listener-breakpoint-added", this._breakpointAdded, this);
+    WebInspector.breakpointManager.addEventListener(WebInspector.BreakpointManager.Events.ProjectChanged, this._projectChanged, this);
+    WebInspector.breakpointManager.addEventListener(WebInspector.BreakpointManager.Events.EventListenerBreakpointAdded, this._breakpointAdded, this);
 
     this._breakpointItems = {};
@@ -293 +296 @@
 
             var breakpointItem = {};
-            var title = WebInspector.EventListenerBreakpoint.eventNameForUI(eventName);
+            var title = WebInspector.EventListenerBreakpointView.eventNameForUI(eventName);
             breakpointItem.element = new TreeElement(title);
             categoryItem.element.appendChild(breakpointItem.element);
@@ -343 +346 @@
     _breakpointAdded: function(event)
     {
-        var breakpoint = event.data.breakpoint;
-        var eventName = event.data.eventName;
-
-        var breakpointItem = this._breakpointItems[eventName];
+        var breakpoint = event.data;
+
+        var breakpointItem = this._breakpointItems[breakpoint.eventName];
         breakpointItem.breakpoint = breakpoint;
         breakpoint.addEventListener("hit-state-changed", this._breakpointHitStateChanged.bind(this, breakpointItem));
@@ -387 +389 @@
     },
 
-    reset: function()
+    _projectChanged: function()
     {
         for (var eventName in this._breakpointItems) {

trunk/WebCore/inspector/front-end/CallStackSidebarPane.js

@@ -27 +27 @@
 {
     WebInspector.SidebarPane.call(this, WebInspector.UIString("Call Stack"));
-    WebInspector.breakpointManager.addEventListener("native-breakpoint-hit", this._nativeBreakpointHit, this);
+    WebInspector.breakpointManager.addEventListener(WebInspector.BreakpointManager.Events.NativeBreakpointHit, this._nativeBreakpointHit, this);
     WebInspector.debuggerModel.addEventListener("script-breakpoint-hit", this._scriptBreakpointHit, this);
 }

trunk/WebCore/inspector/front-end/ElementsPanel.js

@@ -171 +171 @@
 
         delete this.currentQuery;
-
-        if (Preferences.nativeInstrumentationEnabled)
-            this.sidebarPanes.domBreakpoints.reset();
     },
 

trunk/WebCore/inspector/front-end/ScriptsPanel.js

@@ -444 +444 @@
 
         this.sidebarPanes.watchExpressions.refreshExpressions();
-        if (!preserveItems) {
-            this.sidebarPanes.jsBreakpoints.reset();
-            if (Preferences.nativeInstrumentationEnabled) {
-                this.sidebarPanes.domBreakpoints.reset();
-                this.sidebarPanes.xhrBreakpoints.reset();
-                this.sidebarPanes.eventListenerBreakpoints.reset();
-            }
+        if (!preserveItems)
             this.sidebarPanes.workers.reset();
-        }
     },
 

trunk/WebCore/inspector/front-end/Settings.js

@@ -71 +71 @@
 }
 
+WebInspector.Settings.Events = {
+    ProjectChanged: "project-changed"
+}
+
 WebInspector.Settings.prototype = {
     installApplicationSetting: function(key, defaultValue)
@@ -92 +96 @@
         if (fragmentIndex !== -1)
             url = url.substring(0, fragmentIndex);
-        this._inspectedURL = url;
+        this._projectId = url;
+        this.dispatchEventToListeners(WebInspector.Settings.Events.ProjectChanged);
+    },
+
+    get projectId()
+    {
+        return this._projectId;
+    },
+
+    findSettingForAllProjects: function(key)
+    {
+        var result = {};
+        var regexp = "^" + key + ":(.*)";
+        for (var i = 0; i < window.localStorage.length; ++i) {
+            var fullKey =  window.localStorage.key(i);
+            var match = fullKey.match(regexp);
+            if (!match)
+                continue;
+            try {
+                result[match[1]] = JSON.parse(window.localStorage[fullKey]);
+            } catch(e) {
+                window.localStorage.removeItem(fullKey);
+            }
+        }
+        return result;
     },
 
@@ -124 +152 @@
     _formatProjectKey: function(key)
     {
-        return key + ":" + this._inspectedURL;
+        return key + ":" + this._projectId;
     }
 }

trunk/WebCore/inspector/front-end/inspector.js

@@ -204 +204 @@
             pane.addBreakpointItem(new WebInspector.BreakpointItem(event.data));
         }
-        WebInspector.breakpointManager.addEventListener("dom-breakpoint-added", breakpointAdded);
+        WebInspector.breakpointManager.addEventListener(WebInspector.BreakpointManager.Events.DOMBreakpointAdded, breakpointAdded);
         return pane;
     },
@@ -215 +215 @@
             pane.addBreakpointItem(new WebInspector.BreakpointItem(event.data));
         }
-        WebInspector.breakpointManager.addEventListener("xhr-breakpoint-added", breakpointAdded);
+        WebInspector.breakpointManager.addEventListener(WebInspector.BreakpointManager.Events.XHRBreakpointAdded, breakpointAdded);
         return pane;
     },
@@ -1210 +1210 @@
 {
     this.debuggerModel.reset();
-    this.breakpointManager.reset();
 
     for (var panelName in this.panels) {
@@ -1223 +1222 @@
     this.console.clearMessages();
     this.extensionServer.notifyInspectorReset();
-
-    this.breakpointManager.restoreBreakpoints();
 }
 
@@ -1237 +1234 @@
     this.settings.inspectedURLChanged(url);
     this.extensionServer.notifyInspectedURLChanged();
-    if (!this._breakpointsRestored) {
-        this.breakpointManager.restoreBreakpoints();
-        this._breakpointsRestored = true;
-    }
 }