On Linux, move the passing of filedescriptors to a dedicated socketpair().

chrome/tools/test/reference_build/chrome_linux/resources/inspector/ScriptsPanel.js

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 38 matching lines @@
     this.forwardButton.title = WebInspector.UIString("Show the next script resource.");
     this.forwardButton.disabled = true;
     this.forwardButton.appendChild(document.createElement("img"));
     this.forwardButton.addEventListener("click", this._goForward.bind(this), false);
     this.topStatusBar.appendChild(this.forwardButton);
 
     this.filesSelectElement = document.createElement("select");
     this.filesSelectElement.className = "status-bar-item";
     this.filesSelectElement.id = "scripts-files";
     this.filesSelectElement.addEventListener("change", this._changeVisibleFile.bind(this), false);
+    this.filesSelectElement.handleKeyEvent = this.handleKeyEvent.bind(this);
     this.topStatusBar.appendChild(this.filesSelectElement);
 
     this.functionsSelectElement = document.createElement("select");
     this.functionsSelectElement.className = "status-bar-item";
     this.functionsSelectElement.id = "scripts-functions";
 
     // FIXME: append the functions select element to the top status bar when it is implemented.
     // this.topStatusBar.appendChild(this.functionsSelectElement);
 
     this.sidebarButtonsElement = document.createElement("div");
@@ skipping 56 matching lines @@
     this.topStatusBar.appendChild(this.sidebarResizeWidgetElement);
 
     this.sidebarPanes = {};
     this.sidebarPanes.callstack = new WebInspector.CallStackSidebarPane();
     this.sidebarPanes.scopechain = new WebInspector.ScopeChainSidebarPane();
     this.sidebarPanes.breakpoints = new WebInspector.BreakpointsSidebarPane();
 
     for (var pane in this.sidebarPanes)
         this.sidebarElement.appendChild(this.sidebarPanes[pane].element);
 
-    // FIXME: remove the following line of code when the Breakpoints pane has content.
-    this.sidebarElement.removeChild(this.sidebarPanes.breakpoints.element);
-
     this.sidebarPanes.callstack.expanded = true;
     this.sidebarPanes.callstack.addEventListener("call frame selected", this._callFrameSelected, this);
 
     this.sidebarPanes.scopechain.expanded = true;
+    this.sidebarPanes.breakpoints.expanded = true;
 
     var panelEnablerHeading = WebInspector.UIString("You need to enable debugging before you can use the Scripts panel.");
     var panelEnablerDisclaimer = WebInspector.UIString("Enabling debugging will make scripts run slower.");
     var panelEnablerButton = WebInspector.UIString("Enable Debugging");
 
     this.panelEnablerView = new WebInspector.PanelEnablerView("scripts", panelEnablerHeading, panelEnablerDisclaimer, panelEnablerButton);
     this.panelEnablerView.addEventListener("enable clicked", this._enableDebugging, this);
 
     this.element.appendChild(this.panelEnablerView.element);
     this.element.appendChild(this.viewsContainerElement);
     this.element.appendChild(this.sidebarElement);
     this.element.appendChild(this.sidebarResizeElement);
 
-    this.enableToggleButton = document.createElement("button");
-    this.enableToggleButton.className = "enable-toggle-status-bar-item status-bar-item";
+    this.enableToggleButton = new WebInspector.StatusBarButton("", "enable-toggle-status-bar-item");
     this.enableToggleButton.addEventListener("click", this._toggleDebugging.bind(this), false);
 
-    this.pauseOnExceptionButton = document.createElement("button");
-    this.pauseOnExceptionButton.id = "scripts-pause-on-exceptions-status-bar-item";
-    this.pauseOnExceptionButton.className = "status-bar-item";
+    this.pauseOnExceptionButton = new WebInspector.StatusBarButton("", "scripts-pause-on-exceptions-status-bar-item");
     this.pauseOnExceptionButton.addEventListener("click", this._togglePauseOnExceptions.bind(this), false);
 
     this._breakpointsURLMap = {};
 
+    this._shortcuts = {};
+
+    var isMac = InspectorController.platform().indexOf("mac-") === 0;
+    var platformSpecificModifier = isMac ? WebInspector.KeyboardShortcut.Modifiers.Meta : WebInspector.KeyboardShortcut.Modifiers.Ctrl;
+
+    // Continue.
+    var handler = this.pauseButton.click.bind(this.pauseButton);
+    var shortcut = WebInspector.KeyboardShortcut.makeKey(WebInspector.KeyboardShortcut.KeyCodes.F8);
+    this._shortcuts[shortcut] = handler;
+    var shortcut = WebInspector.KeyboardShortcut.makeKey(WebInspector.KeyboardShortcut.KeyCodes.Slash, platformSpecificModifier);
+    this._shortcuts[shortcut] = handler;
+
+    // Step over.
+    var handler = this.stepOverButton.click.bind(this.stepOverButton);
+    var shortcut = WebInspector.KeyboardShortcut.makeKey(WebInspector.KeyboardShortcut.KeyCodes.F10);
+    this._shortcuts[shortcut] = handler;
+    var shortcut = WebInspector.KeyboardShortcut.makeKey(WebInspector.KeyboardShortcut.KeyCodes.SingleQuote, platformSpecificModifier);
+    this._shortcuts[shortcut] = handler;
+
+    // Step into.
+    var handler = this.stepIntoButton.click.bind(this.stepIntoButton);
+    var shortcut = WebInspector.KeyboardShortcut.makeKey(WebInspector.KeyboardShortcut.KeyCodes.F11);
+    this._shortcuts[shortcut] = handler;
+    var shortcut = WebInspector.KeyboardShortcut.makeKey(WebInspector.KeyboardShortcut.KeyCodes.Semicolon, platformSpecificModifier);
+    this._shortcuts[shortcut] = handler;
+
+    // Step out.
+    var handler = this.stepOutButton.click.bind(this.stepOutButton);
+    var shortcut = WebInspector.KeyboardShortcut.makeKey(WebInspector.KeyboardShortcut.KeyCodes.F11, WebInspector.KeyboardShortcut.Modifiers.Shift);
+    this._shortcuts[shortcut] = handler;
+    var shortcut = WebInspector.KeyboardShortcut.makeKey(WebInspector.KeyboardShortcut.KeyCodes.Semicolon, WebInspector.KeyboardShortcut.Modifiers.Shift, platformSpecificModifier);
+    this._shortcuts[shortcut] = handler;
+
     this.reset();
 }
 
 WebInspector.ScriptsPanel.prototype = {
     toolbarItemClass: "scripts",
 
     get toolbarItemLabel()
     {
         return WebInspector.UIString("Scripts");
     },
 
     get statusBarItems()
     {
-        return [this.enableToggleButton, this.pauseOnExceptionButton];
+        return [this.enableToggleButton.element, this.pauseOnExceptionButton.element];
     },
 
     get paused()
     {
         return this._paused;
     },
 
     show: function()
     {
         WebInspector.Panel.prototype.show.call(this);
         this.sidebarResizeElement.style.right = (this.sidebarElement.offsetWidth - 3) + "px";
 
         if (this.visibleView) {
             if (this.visibleView instanceof WebInspector.ResourceView)
                 this.visibleView.headersVisible = false;
             this.visibleView.show(this.viewsContainerElement);
         }
 
         // Hide any views that are visible that are not this panel's current visible view.
         // This can happen when a ResourceView is visible in the Resources panel then switched
         // to the this panel.
         for (var sourceID in this._sourceIDMap) {
             var scriptOrResource = this._sourceIDMap[sourceID];
             var view = this._sourceViewForScriptOrResource(scriptOrResource);
             if (!view || view === this.visibleView)
                 continue;
             view.visible = false;
         }
+        if (this._attachDebuggerWhenShown) {
+            InspectorController.enableDebugger(false);
+            delete this._attachDebuggerWhenShown;
+        }
     },
 
     get searchableViews()
     {
         var views = [];
 
         const visibleView = this.visibleView;
         if (visibleView && visibleView.performSearch) {
             visibleView.alreadySearching = true;
             views.push(visibleView);
@@ skipping 36 matching lines @@
                 }
             }
         }
 
         if (sourceID)
             this._sourceIDMap[sourceID] = (resource || script);
 
         this._addScriptToFilesMenu(script);
     },
 
+    scriptOrResourceForID: function(id)
+    {
+        return this._sourceIDMap[id];
+    },
+
     addBreakpoint: function(breakpoint)
     {
         this.sidebarPanes.breakpoints.addBreakpoint(breakpoint);
 
         var sourceFrame;
         if (breakpoint.url) {
             if (!(breakpoint.url in this._breakpointsURLMap))
                 this._breakpointsURLMap[breakpoint.url] = [];
             this._breakpointsURLMap[breakpoint.url].unshift(breakpoint);
 
@@ skipping 31 matching lines @@
 
         if (breakpoint.sourceID && !sourceFrame) {
             var object = this._sourceIDMap[breakpoint.sourceID]
             sourceFrame = this._sourceFrameForScriptOrResource(object);
         }
 
         if (sourceFrame)
             sourceFrame.removeBreakpoint(breakpoint);
     },
 
-    evaluateInSelectedCallFrame: function(code, updateInterface)
+    evaluateInSelectedCallFrame: function(code, updateInterface, callback)
     {
         var selectedCallFrame = this.sidebarPanes.callstack.selectedCallFrame;
         if (!this._paused || !selectedCallFrame)
             return;
+
         if (typeof updateInterface === "undefined")
             updateInterface = true;
-        var result = selectedCallFrame.evaluate(code);
-        if (updateInterface)
-            this.sidebarPanes.scopechain.update(selectedCallFrame);
-        return result;
+
+        var self = this;
+        function updatingCallbackWrapper(result, exception)
+        {
+            callback(result, exception);
+            if (updateInterface)
+                self.sidebarPanes.scopechain.update(selectedCallFrame);
+        }
+        this.doEvalInCallFrame(selectedCallFrame, code, updatingCallbackWrapper);
     },
 
-    variablesInScopeForSelectedCallFrame: function()
+    doEvalInCallFrame: function(callFrame, code, callback)
+    {
+        function evalCallback(result)
+        {
+            if (result)
+                callback(result.value, result.isException);
+        }
+        InspectorController.evaluateInCallFrame(callFrame.id, code, evalCallback);
+    },
+
+    variablesInSelectedCallFrame: function()
     {
         var selectedCallFrame = this.sidebarPanes.callstack.selectedCallFrame;
         if (!this._paused || !selectedCallFrame)
             return {};
 
         var result = {};
         var scopeChain = selectedCallFrame.scopeChain;
         for (var i = 0; i < scopeChain.length; ++i) {
-            var scopeObject = scopeChain[i];
-            for (var property in scopeObject)
-                result[property] = true;
+            var scopeObjectProperties = scopeChain[i].properties;
+            for (var j = 0; j < scopeObjectProperties.length; ++j)
+                result[scopeObjectProperties[j]] = true;
         }
-
         return result;
     },
 
     debuggerPaused: function()
     {
         this._paused = true;
         this._waitingToPause = false;
         this._stepping = false;
 
         this._updateDebuggerButtons();
 
+        var self = this;
         var callStackPane = this.sidebarPanes.callstack;
-        var currentFrame = InspectorController.currentCallFrame();
-        callStackPane.update(currentFrame, this._sourceIDMap);
-        callStackPane.selectedCallFrame = currentFrame;
+        function callback(callFrames)
+        {
+            callStackPane.update(callFrames, self._sourceIDMap);
+            callStackPane.selectedCallFrame = callFrames[0];
 
-        WebInspector.currentPanel = this;
-        window.focus();
+            WebInspector.currentPanel = self;
+            window.focus();
+        }
+        InspectorController.getCallFrames(callback);
     },
 
     debuggerResumed: function()
     {
         this._paused = false;
         this._waitingToPause = false;
         this._stepping = false;
 
         this._clearInterface();
     },
 
+    attachDebuggerWhenShown: function()
+    {
+        if (this.element.parentElement) {
+            InspectorController.enableDebugger(false);
+        } else {
+            this._attachDebuggerWhenShown = true;
+        }
+    },
+
     debuggerWasEnabled: function()
     {
         this.reset();
     },
 
     debuggerWasDisabled: function()
     {
         this.reset();
     },
 
@@ skipping 66 matching lines @@
         this._showScriptOrResource(resource, line, true);
     },
 
     showView: function(view)
     {
         if (!view)
             return;
         this._showScriptOrResource((view.resource || view.script));
     },
 
+    handleKeyEvent: function(event)
+    {
+        var shortcut = WebInspector.KeyboardShortcut.makeKeyFromEvent(event);
+        var handler = this._shortcuts[shortcut];
+        if (handler) {
+            handler(event);
+            event.preventDefault();
+            event.handled = true;
+        } else {
+            this.sidebarPanes.callstack.handleKeyEvent(event);
+        }
+    },
+
     scriptViewForScript: function(script)
     {
         if (!script)
             return null;
         if (!script._scriptView)
             script._scriptView = new WebInspector.ScriptView(script);
         return script._scriptView;
     },
 
     sourceFrameForScript: function(script)
@@ skipping 207 matching lines @@
         this.sidebarResizeWidgetElement.style.right = newWidth + "px";
         this.sidebarResizeElement.style.right = (newWidth - 3) + "px";
 
         event.preventDefault();
     },
 
     _updatePauseOnExceptionsButton: function()
     {
         if (InspectorController.pauseOnExceptions()) {
             this.pauseOnExceptionButton.title = WebInspector.UIString("Don't pause on exceptions.");
-            this.pauseOnExceptionButton.addStyleClass("toggled-on");
+            this.pauseOnExceptionButton.toggled = true;
         } else {
             this.pauseOnExceptionButton.title = WebInspector.UIString("Pause on exceptions.");
-            this.pauseOnExceptionButton.removeStyleClass("toggled-on");
+            this.pauseOnExceptionButton.toggled = false;
         }
     },
 
     _updateDebuggerButtons: function()
     {
         if (InspectorController.debuggerEnabled()) {
             this.enableToggleButton.title = WebInspector.UIString("Debugging enabled. Click to disable.");
-            this.enableToggleButton.addStyleClass("toggled-on");
-            this.pauseOnExceptionButton.removeStyleClass("hidden");
+            this.enableToggleButton.toggled = true;
+            this.pauseOnExceptionButton.visible = true;
             this.panelEnablerView.visible = false;
         } else {
             this.enableToggleButton.title = WebInspector.UIString("Debugging disabled. Click to enable.");
-            this.enableToggleButton.removeStyleClass("toggled-on");
-            this.pauseOnExceptionButton.addStyleClass("hidden");
+            this.enableToggleButton.toggled = false;
+            this.pauseOnExceptionButton.visible = false;
             this.panelEnablerView.visible = true;
         }
 
         this._updatePauseOnExceptionsButton();
 
         if (this._paused) {
             this.pauseButton.addStyleClass("paused");
 
             this.pauseButton.disabled = false;
             this.stepOverButton.disabled = false;
@@ skipping 52 matching lines @@
         }
 
         this._showScriptOrResource(this._backForwardList[++this._currentBackForwardIndex], null, false, true);
         this._updateBackAndForwardButtons();
     },
 
     _enableDebugging: function()
     {
         if (InspectorController.debuggerEnabled())
             return;
-        this._toggleDebugging();
+        this._toggleDebugging(this.panelEnablerView.alwaysEnabled);
     },
 
-    _toggleDebugging: function()
+    _toggleDebugging: function(optionalAlways)
     {
         this._paused = false;
         this._waitingToPause = false;
         this._stepping = false;
 
         if (InspectorController.debuggerEnabled())
-            InspectorController.disableDebugger();
+            InspectorController.disableDebugger(true);
         else
-            InspectorController.enableDebugger();
+            InspectorController.enableDebugger(!!optionalAlways);
     },
 
     _togglePauseOnExceptions: function()
     {
         InspectorController.setPauseOnExceptions(!InspectorController.pauseOnExceptions());
         this._updatePauseOnExceptionsButton();
     },
 
     _togglePause: function()
     {
@@ skipping 35 matching lines @@
         this._paused = false;
         this._stepping = true;
 
         this._clearInterface();
 
         InspectorController.stepOutOfFunctionInDebugger();
     }
 }
 
 WebInspector.ScriptsPanel.prototype.__proto__ = WebInspector.Panel.prototype;