Changeset 55537 in webkit


Ignore:
Timestamp:
Mar 4, 2010 10:56:44 AM (14 years ago)
Author:
pfeldman@chromium.org
Message:

2010-03-04 Pavel Feldman <pfeldman@chromium.org>

Reviewed by Timothy Hatcher.

Web Inspector: Remove two last synchronous calls from front-end to InspectorBackend.

https://bugs.webkit.org/show_bug.cgi?id=35720

  • inspector/InspectorBackend.cpp: (WebCore::InspectorBackend::enableSearchingForNode): (WebCore::InspectorBackend::disableSearchingForNode): (WebCore::InspectorBackend::setPauseOnExceptionsState):
  • inspector/InspectorBackend.h:
  • inspector/InspectorBackend.idl:
  • inspector/InspectorController.cpp: (WebCore::InspectorController::setWindowVisible): (WebCore::InspectorContorller::setSearchingForNode): (WebCore::InspectorController::populateScriptObjects):
  • inspector/InspectorController.h:
  • inspector/InspectorFrontend.cpp: (WebCore::InspectorFrontend::searchingForNodeWasEnabled): (WebCore::InspectorFrontend::searchingForNodeWasDisabled): (WebCore::InspectorFrontend::updatePauseOnExceptionsState):
  • inspector/InspectorFrontend.h:
  • inspector/front-end/ElementsPanel.js: (WebInspector.ElementsPanel): (WebInspector.ElementsPanel.prototype.get statusBarItems): (WebInspector.ElementsPanel.prototype.hide): (WebInspector.ElementsPanel.prototype.reset): (WebInspector.ElementsPanel.prototype.searchingForNodeWasEnabled): (WebInspector.ElementsPanel.prototype.searchingForNodeWasDisabled): (WebInspector.ElementsPanel.prototype._nodeSearchButtonClicked):
  • inspector/front-end/InspectorBackendStub.js: (.WebInspector.InspectorBackendStub.prototype.enableSearchingForNode): (.WebInspector.InspectorBackendStub.prototype.disableSearchingForNode): (.WebInspector.InspectorBackendStub.prototype.setPauseOnExceptionsState):
  • inspector/front-end/ScriptsPanel.js: (WebInspector.ScriptsPanel): (WebInspector.ScriptsPanel.prototype.get statusBarItems): (WebInspector.ScriptsPanel.prototype.updatePauseOnExceptionsState): (WebInspector.ScriptsPanel.prototype._updateDebuggerButtons): (WebInspector.ScriptsPanel.prototype._togglePauseOnExceptions):
  • inspector/front-end/inspector.js: (WebInspector.searchingForNodeWasEnabled): (WebInspector.searchingForNodeWasDisabled): (WebInspector.updatePauseOnExceptionsState): WebKit/chromium:
  • src/js/InspectorControllerImpl.js: (devtools.InspectorBackendImpl):
Location:
trunk
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • trunk/WebCore/ChangeLog

    r55536 r55537  
    112010-03-04  Pavel Feldman  <pfeldman@chromium.org>
     2
     3        Reviewed by Timothy Hatcher.
     4
     5        Web Inspector: Remove two last synchronous calls from front-end to InspectorBackend.
     6
     7        https://bugs.webkit.org/show_bug.cgi?id=35720
     8
     9        * inspector/InspectorBackend.cpp:
     10        (WebCore::InspectorBackend::enableSearchingForNode):
     11        (WebCore::InspectorBackend::disableSearchingForNode):
     12        (WebCore::InspectorBackend::setPauseOnExceptionsState):
     13        * inspector/InspectorBackend.h:
     14        * inspector/InspectorBackend.idl:
     15        * inspector/InspectorController.cpp:
     16        (WebCore::InspectorController::setWindowVisible):
     17        (WebCore::InspectorContorller::setSearchingForNode):
     18        (WebCore::InspectorController::populateScriptObjects):
     19        * inspector/InspectorController.h:
     20        * inspector/InspectorFrontend.cpp:
     21        (WebCore::InspectorFrontend::searchingForNodeWasEnabled):
     22        (WebCore::InspectorFrontend::searchingForNodeWasDisabled):
     23        (WebCore::InspectorFrontend::updatePauseOnExceptionsState):
     24        * inspector/InspectorFrontend.h:
     25        * inspector/front-end/ElementsPanel.js:
     26        (WebInspector.ElementsPanel):
     27        (WebInspector.ElementsPanel.prototype.get statusBarItems):
     28        (WebInspector.ElementsPanel.prototype.hide):
     29        (WebInspector.ElementsPanel.prototype.reset):
     30        (WebInspector.ElementsPanel.prototype.searchingForNodeWasEnabled):
     31        (WebInspector.ElementsPanel.prototype.searchingForNodeWasDisabled):
     32        (WebInspector.ElementsPanel.prototype._nodeSearchButtonClicked):
     33        * inspector/front-end/InspectorBackendStub.js:
     34        (.WebInspector.InspectorBackendStub.prototype.enableSearchingForNode):
     35        (.WebInspector.InspectorBackendStub.prototype.disableSearchingForNode):
     36        (.WebInspector.InspectorBackendStub.prototype.setPauseOnExceptionsState):
     37        * inspector/front-end/ScriptsPanel.js:
     38        (WebInspector.ScriptsPanel):
     39        (WebInspector.ScriptsPanel.prototype.get statusBarItems):
     40        (WebInspector.ScriptsPanel.prototype.updatePauseOnExceptionsState):
     41        (WebInspector.ScriptsPanel.prototype._updateDebuggerButtons):
     42        (WebInspector.ScriptsPanel.prototype._togglePauseOnExceptions):
     43        * inspector/front-end/inspector.js:
     44        (WebInspector.searchingForNodeWasEnabled):
     45        (WebInspector.searchingForNodeWasDisabled):
     46        (WebInspector.updatePauseOnExceptionsState):
     47
     482010-03-03  Pavel Feldman  <pfeldman@chromium.org>
    249
    350        Reviewed by Timothy Hatcher.
  • trunk/WebCore/inspector/InspectorBackend.cpp

    r55535 r55537  
    9292}
    9393
    94 void InspectorBackend::toggleNodeSearch()
    95 {
    96     if (m_inspectorController)
    97         m_inspectorController->toggleSearchForNodeInPage();
    98 }
    99 
    100 bool InspectorBackend::searchingForNode()
    101 {
    102     if (m_inspectorController)
    103         return m_inspectorController->searchingForNodeInPage();
    104     return false;
     94void InspectorBackend::enableSearchingForNode()
     95{
     96    if (m_inspectorController)
     97        m_inspectorController->setSearchingForNode(true);
     98}
     99
     100void InspectorBackend::disableSearchingForNode()
     101{
     102    if (m_inspectorController)
     103        m_inspectorController->setSearchingForNode(false);
    105104}
    106105
     
    210209}
    211210
    212 long InspectorBackend::pauseOnExceptionsState()
    213 {
    214     return ScriptDebugServer::shared().pauseOnExceptionsState();
    215 }
    216 
    217211void InspectorBackend::setPauseOnExceptionsState(long pauseState)
    218212{
    219213    ScriptDebugServer::shared().setPauseOnExceptionsState(static_cast<ScriptDebugServer::PauseOnExceptionsState>(pauseState));
     214    if (InspectorFrontend* frontend = inspectorFrontend())
     215        frontend->updatePauseOnExceptionsState(ScriptDebugServer::shared().pauseOnExceptionsState());
    220216}
    221217
  • trunk/WebCore/inspector/InspectorBackend.h

    r55535 r55537  
    6262    void storeLastActivePanel(const String& panelName);
    6363
    64     void toggleNodeSearch();
    65     bool searchingForNode();
     64    void enableSearchingForNode();
     65    void disableSearchingForNode();
    6666
    6767    void enableResourceTracking(bool always);
     
    8585    void resumeDebugger();
    8686
    87     long pauseOnExceptionsState();
    8887    void setPauseOnExceptionsState(long pauseState);
    8988
  • trunk/WebCore/inspector/InspectorBackend.idl

    r55535 r55537  
    3737        void saveFrontendSettings(in DOMString settings);
    3838
    39         void toggleNodeSearch();
    40         boolean searchingForNode();
     39        void enableSearchingForNode();
     40        void disableSearchingForNode();
    4141
    4242        void enableResourceTracking(in boolean always);
     
    6464        void stepOutOfFunctionInDebugger();
    6565
    66         long pauseOnExceptionsState();
    6766        void setPauseOnExceptionsState(in long pauseOnExceptionsState);
    6867
  • trunk/WebCore/inspector/InspectorController.cpp

    r55535 r55537  
    323323            m_attachDebuggerWhenShown = true;
    324324#endif
    325         if (m_searchingForNode)
    326             toggleSearchForNodeInPage();
     325        setSearchingForNode(false);
    327326        resetScriptObjects();
    328327        stopTimelineProfiler();
     
    477476}
    478477
    479 void InspectorController::toggleSearchForNodeInPage()
    480 {
    481     if (!enabled())
    482         return;
    483 
    484     m_searchingForNode = !m_searchingForNode;
    485     if (!m_searchingForNode)
    486         hideHighlight();
    487 }
    488 
    489478void InspectorController::mouseDidMoveOverElement(const HitTestResult& result, unsigned)
    490479{
     
    507496        return;
    508497
    509     // inspect() will implicitly call ElementsPanel's focusedNodeChanged() and the hover feedback will be stopped there.
     498    setSearchingForNode(false);
    510499    inspect(node);
    511500}
     
    528517    ScriptGlobalObject::set(m_frontendScriptState, "InspectorBackend", m_inspectorBackend.get());
    529518    ScriptGlobalObject::set(m_frontendScriptState, "InspectorFrontendHost", m_inspectorFrontendHost.get());
     519}
     520
     521void InspectorController::setSearchingForNode(bool enabled)
     522{
     523    if (m_searchingForNode == enabled)
     524        return;
     525    m_searchingForNode = enabled;
     526    if (!m_searchingForNode)
     527        hideHighlight();
     528    if (m_frontend) {
     529        if (enabled)
     530            m_frontend->searchingForNodeWasEnabled();
     531        else
     532            m_frontend->searchingForNodeWasDisabled();
     533    }
    530534}
    531535
     
    671675    if (m_resourceTrackingEnabled)
    672676        m_frontend->resourceTrackingWasEnabled();
     677
     678    if (m_searchingForNode)
     679        m_frontend->searchingForNodeWasEnabled();
     680    else
     681        m_frontend->searchingForNodeWasDisabled();
     682
    673683#if ENABLE(JAVASCRIPT_DEBUGGER)
    674684    if (m_profilerEnabled)
     
    688698        m_consoleMessages[i]->addToConsole(m_frontend.get());
    689699
     700#if ENABLE(JAVASCRIPT_DEBUGGER)
     701    if (m_debuggerEnabled)
     702        m_frontend->updatePauseOnExceptionsState(ScriptDebugServer::shared().pauseOnExceptionsState());
     703#endif
    690704#if ENABLE(DATABASE)
    691705    DatabaseResourcesMap::iterator databasesEnd = m_databaseResources.end();
  • trunk/WebCore/inspector/InspectorController.h

    r55522 r55537  
    149149    void detachWindow();
    150150
    151     void toggleSearchForNodeInPage();
    152151    bool searchingForNodeInPage() const { return m_searchingForNode; }
    153152    void mouseDidMoveOverElement(const HitTestResult&, unsigned modifierFlags);
     
    263262    friend class InspectorFrontendHost;
    264263    friend class InjectedScriptHost;
     264
    265265    // Following are used from InspectorBackend and internally.
     266
     267    void setSearchingForNode(bool enabled);
     268
    266269    void scriptObjectReady();
    267270    void moveWindowBy(float x, float y) const;
  • trunk/WebCore/inspector/InspectorFrontend.cpp

    r55522 r55537  
    228228}
    229229
     230
     231void InspectorFrontend::searchingForNodeWasEnabled()
     232{
     233    callSimpleFunction("searchingForNodeWasEnabled");
     234}
     235
     236void InspectorFrontend::searchingForNodeWasDisabled()
     237{
     238    callSimpleFunction("searchingForNodeWasDisabled");
     239}
     240
     241void InspectorFrontend::updatePauseOnExceptionsState(long state)
     242{
     243    ScriptFunctionCall function(m_webInspector, "dispatch");
     244    function.appendArgument("updatePauseOnExceptionsState");
     245    function.appendArgument(state);
     246    function.call();
     247}
     248
    230249void InspectorFrontend::timelineProfilerWasStarted()
    231250{
  • trunk/WebCore/inspector/InspectorFrontend.h

    r55522 r55537  
    7878        void resourceTrackingWasDisabled();
    7979
     80        void searchingForNodeWasEnabled();
     81        void searchingForNodeWasDisabled();
     82
     83        void updatePauseOnExceptionsState(long state);
     84
    8085#if ENABLE(JAVASCRIPT_DEBUGGER)
    8186        void attachDebuggerWhenShown();
  • trunk/WebCore/inspector/front-end/ElementsPanel.js

    r54819 r55537  
    5959        this.panel.updateEventListeners();
    6060
    61         if (InspectorBackend.searchingForNode()) {
    62             InspectorBackend.toggleNodeSearch();
    63             this.panel.nodeSearchButton.toggled = false;
    64         }
    6561        if (this._focusedDOMNode)
    6662            InjectedScriptAccess.get(this._focusedDOMNode.injectedScriptId).addInspectedNode(this._focusedDOMNode.id, function() {});
     
    10399    this.sidebarResizeElement.addEventListener("mousedown", this.rightSidebarResizerDragStart.bind(this), false);
    104100
    105     this.nodeSearchButton = new WebInspector.StatusBarButton(WebInspector.UIString("Select an element in the page to inspect it."), "node-search-status-bar-item");
    106     this.nodeSearchButton.addEventListener("click", this._nodeSearchButtonClicked.bind(this), false);
    107 
    108     this.searchingForNode = false;
     101    this._nodeSearchButton = new WebInspector.StatusBarButton(WebInspector.UIString("Select an element in the page to inspect it."), "node-search-status-bar-item");
     102    this._nodeSearchButton.addEventListener("click", this._nodeSearchButtonClicked.bind(this), false);
    109103
    110104    this.element.appendChild(this.contentElement);
     
    127121    get statusBarItems()
    128122    {
    129         return [this.nodeSearchButton.element, this.crumbsElement];
     123        return [this._nodeSearchButton.element, this.crumbsElement];
    130124    },
    131125
     
    155149
    156150        WebInspector.hoveredDOMNode = null;
    157 
    158         if (InspectorBackend.searchingForNode()) {
    159             InspectorBackend.toggleNodeSearch();
    160             this.nodeSearchButton.toggled = false;
    161         }
     151        InspectorBackend.disableSearchingForNode();
    162152    },
    163153
     
    186176        WebInspector.hoveredDOMNode = null;
    187177
    188         if (InspectorBackend.searchingForNode()) {
    189             InspectorBackend.toggleNodeSearch();
    190             this.nodeSearchButton.toggled = false;
    191         }
    192 
    193178        this.recentlyModifiedNodes = [];
    194179
     
    270255
    271256        InjectedScriptAccess.getDefault().performSearch(whitespaceTrimmedQuery, function() {});
     257    },
     258
     259    searchingForNodeWasEnabled: function()
     260    {
     261        this._nodeSearchButton.toggled = true;
     262    },
     263
     264    searchingForNodeWasDisabled: function()
     265    {
     266        this._nodeSearchButton.toggled = false;
    272267    },
    273268
     
    11091104    _nodeSearchButtonClicked: function(event)
    11101105    {
    1111         InspectorBackend.toggleNodeSearch();
    1112 
    1113         this.nodeSearchButton.toggled = InspectorBackend.searchingForNode();
     1106        if (!this._nodeSearchButton.toggled)
     1107            InspectorBackend.enableSearchingForNode();
     1108        else
     1109            InspectorBackend.disableSearchingForNode();
    11141110    }
    11151111}
  • trunk/WebCore/inspector/front-end/InspectorBackendStub.js

    r55535 r55537  
    134134    },
    135135
     136
     137    enableSearchingForNode: function()
     138    {
     139        WebInspector.searchingForNodeWasEnabled();
     140    },
     141
     142    disableSearchingForNode: function()
     143    {
     144        WebInspector.searchingForNodeWasDisabled();
     145    },
     146
    136147    reloadPage: function()
    137148    {
     
    170181    },
    171182
    172     pauseOnExceptionsState: function()
    173     {
    174         return 0;
    175     },
    176 
    177183    setPauseOnExceptionsState: function(value)
    178184    {
     185        WebInspector.updatePauseOnExceptionsState(value);
    179186    },
    180187
  • trunk/WebCore/inspector/front-end/ScriptsPanel.js

    r55522 r55537  
    162162    this.enableToggleButton.addEventListener("click", this._toggleDebugging.bind(this), false);
    163163
    164     this.pauseOnExceptionButton = new WebInspector.StatusBarButton("", "scripts-pause-on-exceptions-status-bar-item", 3);
    165     this.pauseOnExceptionButton.addEventListener("click", this._togglePauseOnExceptions.bind(this), false);
     164    this._pauseOnExceptionButton = new WebInspector.StatusBarButton("", "scripts-pause-on-exceptions-status-bar-item", 3);
     165    this._pauseOnExceptionButton.addEventListener("click", this._togglePauseOnExceptions.bind(this), false);
     166    this._pauseOnExceptionButton.state = WebInspector.ScriptsPanel.PauseOnExceptionsState.DontPauseOnExceptions;
    166167
    167168    this._shortcuts = {};
     
    218219    get statusBarItems()
    219220    {
    220         return [this.enableToggleButton.element, this.pauseOnExceptionButton.element];
     221        return [this.enableToggleButton.element, this._pauseOnExceptionButton.element];
    221222    },
    222223
     
    795796    },
    796797   
    797     _updatePauseOnExceptionsButton: function()
    798     {
    799         if (InspectorBackend.pauseOnExceptionsState() == WebInspector.ScriptsPanel.PauseOnExceptionsState.DontPauseOnExceptions)
    800             this.pauseOnExceptionButton.title = WebInspector.UIString("Don't pause on exceptions.\nClick to Pause on all exceptions.");
    801         else if (InspectorBackend.pauseOnExceptionsState() == WebInspector.ScriptsPanel.PauseOnExceptionsState.PauseOnAllExceptions)
    802             this.pauseOnExceptionButton.title = WebInspector.UIString("Pause on all exceptions.\nClick to Pause on uncaught exceptions.");
    803         else if (InspectorBackend.pauseOnExceptionsState() == WebInspector.ScriptsPanel.PauseOnExceptionsState.PauseOnUncaughtExceptions)
    804             this.pauseOnExceptionButton.title = WebInspector.UIString("Pause on uncaught exceptions.\nClick to Not pause on exceptions.");
    805        
    806         this.pauseOnExceptionButton.state = InspectorBackend.pauseOnExceptionsState();
    807        
     798    updatePauseOnExceptionsState: function(pauseOnExceptionsState)
     799    {
     800        if (pauseOnExceptionsState == WebInspector.ScriptsPanel.PauseOnExceptionsState.DontPauseOnExceptions)
     801            this._pauseOnExceptionButton.title = WebInspector.UIString("Don't pause on exceptions.\nClick to Pause on all exceptions.");
     802        else if (pauseOnExceptionsState == WebInspector.ScriptsPanel.PauseOnExceptionsState.PauseOnAllExceptions)
     803            this._pauseOnExceptionButton.title = WebInspector.UIString("Pause on all exceptions.\nClick to Pause on uncaught exceptions.");
     804        else if (pauseOnExceptionsState == WebInspector.ScriptsPanel.PauseOnExceptionsState.PauseOnUncaughtExceptions)
     805            this._pauseOnExceptionButton.title = WebInspector.UIString("Pause on uncaught exceptions.\nClick to Not pause on exceptions.");
     806
     807        this._pauseOnExceptionButton.state = pauseOnExceptionsState;
    808808    },
    809809
     
    813813            this.enableToggleButton.title = WebInspector.UIString("Debugging enabled. Click to disable.");
    814814            this.enableToggleButton.toggled = true;
    815             this.pauseOnExceptionButton.visible = true;
     815            this._pauseOnExceptionButton.visible = true;
    816816            this.panelEnablerView.visible = false;
    817817        } else {
    818818            this.enableToggleButton.title = WebInspector.UIString("Debugging disabled. Click to enable.");
    819819            this.enableToggleButton.toggled = false;
    820             this.pauseOnExceptionButton.visible = false;
     820            this._pauseOnExceptionButton.visible = false;
    821821            this.panelEnablerView.visible = true;
    822822        }
    823 
    824         this._updatePauseOnExceptionsButton();
    825823
    826824        if (this._paused) {
     
    908906    _togglePauseOnExceptions: function()
    909907    {
    910         InspectorBackend.setPauseOnExceptionsState((InspectorBackend.pauseOnExceptionsState() + 1) % this.pauseOnExceptionButton.states);
    911         this._updatePauseOnExceptionsButton();
     908        InspectorBackend.setPauseOnExceptionsState((this._pauseOnExceptionButton.state + 1) % this._pauseOnExceptionButton.states);
    912909    },
    913910
  • trunk/WebCore/inspector/front-end/inspector.js

    r55517 r55537  
    13101310}
    13111311
     1312
     1313WebInspector.searchingForNodeWasEnabled = function()
     1314{
     1315    this.panels.elements.searchingForNodeWasEnabled();
     1316}
     1317
     1318WebInspector.searchingForNodeWasDisabled = function()
     1319{
     1320    this.panels.elements.searchingForNodeWasDisabled();
     1321}
     1322
    13121323WebInspector.attachDebuggerWhenShown = function()
    13131324{
     
    13181329{
    13191330    this.panels.scripts.debuggerWasEnabled();
     1331}
     1332
     1333WebInspector.updatePauseOnExceptionsState = function(pauseOnExceptionsState)
     1334{
     1335    this.panels.scripts.updatePauseOnExceptionsState(pauseOnExceptionsState);
    13201336}
    13211337
  • trunk/WebKit/chromium/ChangeLog

    r55535 r55537  
     12010-03-03  Pavel Feldman  <pfeldman@chromium.org>
     2
     3        Reviewed by Timothy Hatcher.
     4
     5        Web Inspector: Remove two last synchronous calls from front-end to InspectorBackend.
     6       
     7        https://bugs.webkit.org/show_bug.cgi?id=35720
     8
     9        * src/js/InspectorControllerImpl.js:
     10        (devtools.InspectorBackendImpl):
     11        (devtools.InspectorBackendImpl.prototype.setPauseOnExceptionsState):
     12
    1132010-03-03  Pavel Feldman  <pfeldman@chromium.org>
    214
  • trunk/WebKit/chromium/src/js/DevTools.js

    r55535 r55537  
    157157 */
    158158function debugPrint(text) {
    159     var console = WebInspector.console;
    160     if (console) {
    161         console.addMessage(new WebInspector.ConsoleMessage(
    162             WebInspector.ConsoleMessage.MessageSource.JS,
    163             WebInspector.ConsoleMessage.MessageType.Log,
    164             WebInspector.ConsoleMessage.MessageLevel.Log,
    165             1, "chrome://devtools/<internal>", undefined, -1, text));
    166     } else
    167         alert(text);
     159    WebInspector.log(text);
    168160}
    169161
     
    369361(function()
    370362{
    371 var orig = WebInspector.ConsoleMessage.prototype.setMessageBody;
    372 WebInspector.ConsoleMessage.prototype.setMessageBody = function(args)
    373 {
    374     for (var i = 0; i < args.length; ++i) {
    375         if (typeof args[i] === "string")
    376             args[i] = WebInspector.ObjectProxy.wrapPrimitiveValue(args[i]);
    377     }
    378     orig.call(this, args);
    379 };
    380 })();
    381 
    382 
    383 (function()
    384 {
    385363var orig = InjectedScriptAccess.prototype.getCompletions;
    386364InjectedScriptAccess.prototype.getCompletions = function(expressionString, includeInspectorCommandLineAPI, callFrameId, reportCompletions)
     
    394372
    395373
    396 (function()
    397 {
    398 WebInspector.ElementsPanel.prototype._nodeSearchButtonClicked = function( event)
    399 {
    400     InspectorBackend.toggleNodeSearch();
    401     this.nodeSearchButton.toggled = !this.nodeSearchButton.toggled;
    402 };
    403 })();
    404 
    405 
    406374// We need to have a place for postponed tasks
    407375// which should be executed when all the messages between agent and frontend
  • trunk/WebKit/chromium/src/js/InspectorControllerImpl.js

    r55522 r55537  
    4545    this.installInspectorControllerDelegate_("didEvaluateForTestInFrontend");
    4646    this.installInspectorControllerDelegate_("disableResourceTracking");
     47    this.installInspectorControllerDelegate_("disableSearchingForNode");
    4748    this.installInspectorControllerDelegate_("disableTimeline");
    4849    this.installInspectorControllerDelegate_("enableResourceTracking");
     50    this.installInspectorControllerDelegate_("enableSearchingForNode");
    4951    this.installInspectorControllerDelegate_("enableTimeline");
    5052    this.installInspectorControllerDelegate_("getChildNodes");
     
    7577
    7678/**
    77  * {@inheritDoc}.
    78  */
    79 devtools.InspectorBackendImpl.prototype.toggleNodeSearch = function()
    80 {
    81     WebInspector.InspectorBackendStub.prototype.toggleNodeSearch.call(this);
    82     this.callInspectorController_.call(this, "toggleNodeSearch");
    83     if (!this.searchingForNode()) {
    84         // This is called from ElementsPanel treeOutline's focusNodeChanged().
    85         InspectorFrontendHost.activateWindow();
    86     }
    87 };
    88 
    89 
    90 /**
    9179 * @override
    9280 */
     
    169157    // TODO(yurys): support all three states. See http://crbug.com/32877
    170158    var enabled = (state !== WebInspector.ScriptsPanel.PauseOnExceptionsState.DontPauseOnExceptions);
    171     return devtools.tools.getDebuggerAgent().setPauseOnExceptions(enabled);
    172 };
    173 
    174 /**
    175  * @override
    176  */
    177 devtools.InspectorBackendImpl.prototype.pauseOnExceptionsState = function()
    178 {
    179     return (this._setPauseOnExceptionsState || WebInspector.ScriptsPanel.PauseOnExceptionsState.DontPauseOnExceptions);
    180 };
     159    WebInspector.updatePauseOnExceptionsState(enabled ? WebInspector.ScriptsPanel.PauseOnExceptionsState.PauseOnUncaughtExceptions : WebInspector.ScriptsPanel.PauseOnExceptionsState.DontPauseOnExceptions);
     160    devtools.tools.getDebuggerAgent().setPauseOnExceptions(enabled);
     161};
     162
    181163
    182164/**
Note: See TracChangeset for help on using the changeset viewer.