Support WebKit debugger.

This needs matching changes in the webkit debugger component.

Author: Paul van Brenk

Common/Product/SharedProject/ProjectNode.cs

@@ -4496,7 +4496,6 @@ public virtual int IsDocumentInProject(string mkDoc, out int found, VSDOCUMENTPR
             }
 
             return VSConstants.S_OK;
-
         }
 
         protected virtual bool IncludeNonMemberItemInProject(HierarchyNode node) {
@@ -5597,6 +5596,10 @@ public virtual int GetBuildSystemKind(out uint kind) {
         internal HierarchyNode FindNodeByFullPath(string name) {
             Site.GetUIThread().MustBeCalledFromUIThread();
 
+            if (name.StartsWith("mdha:", StringComparison.OrdinalIgnoreCase)) {
+                return default(HierarchyNode);
+            }
+
             Debug.Assert(Path.IsPathRooted(name));
 
             HierarchyNode node;

Nodejs/Product/Nodejs/Debugger/DebugEngine/AD7Engine.cs

@@ -565,9 +565,10 @@ int IDebugEngineLaunch2.LaunchSuspended(string pszServer, IDebugPort2 port, stri
 
             AttachEvents(_process);
 
-            var adProcessId = new AD_PROCESS_ID();
-            adProcessId.ProcessIdType = (uint)enum_AD_PROCESS_ID.AD_PROCESS_ID_SYSTEM;
-            adProcessId.dwProcessId = (uint)_process.Id;
+            var adProcessId = new AD_PROCESS_ID() {
+                ProcessIdType = (uint)enum_AD_PROCESS_ID.AD_PROCESS_ID_SYSTEM,
+                dwProcessId = (uint)_process.Id
+            };
 
             EngineUtils.RequireOk(port.GetProcess(adProcessId, out process));
             LiveLogger.WriteLine("AD7Engine LaunchSuspended returning S_OK");

Nodejs/Product/Nodejs/Debugger/NodeConstants.cs

@@ -15,7 +15,7 @@
 //*********************************************************//
 
 namespace Microsoft.NodejsTools.Debugger {
-    sealed class NodeConstants {
+    internal sealed class NodeConstants {
         public const string ScriptWrapBegin = "(function (exports, require, module, __filename, __dirname) { ";
         public const string ScriptWrapEnd = "\n});";
     }

Nodejs/Product/Nodejs/Debugger/NodeDebugOptions.cs

@@ -18,7 +18,7 @@
 
 namespace Microsoft.NodejsTools.Debugger {
     [Flags]
-    enum NodeDebugOptions {
+    internal enum NodeDebugOptions {
         None,
         /// <summary>
         /// Passing this flag to the debugger will cause it to wait for input on an abnormal (non-zero)

Nodejs/Product/Nodejs/Debugger/NodeDebugger.cs

@@ -36,8 +36,8 @@ namespace Microsoft.NodejsTools.Debugger {
     /// <summary>
     /// Handles all interactions with a Node process which is being debugged.
     /// </summary>
-    sealed class NodeDebugger : IDisposable {
-        public readonly int MainThreadId = 1;
+    internal sealed class NodeDebugger : IDisposable {
+        public const int MainThreadId = 1;
         private readonly Dictionary<int, NodeBreakpointBinding> _breakpointBindings = new Dictionary<int, NodeBreakpointBinding>();
         private readonly IDebuggerClient _client;
         private readonly IDebuggerConnection _connection;
@@ -76,82 +76,90 @@ private NodeDebugger() {
             _fileNameMapper = new LocalFileNameMapper();
         }
 
-        public NodeDebugger(
-            string exe,
-            string script,
-            string dir,
-            string env,
-            string interpreterOptions,
-            NodeDebugOptions debugOptions,
-            ushort? debuggerPort = null,
-            bool createNodeWindow = true)
+        public NodeDebugger(Uri debuggerEndpointUri, int id)
+            : this() {
+            _debuggerEndpointUri = debuggerEndpointUri;
+            _id = id;
+            _attached = true;
+        }
+
+        public NodeDebugger(string exe, string script, string dir, string env, string interpreterOptions, NodeDebugOptions debugOptions, ushort? debuggerPort = null, bool createNodeWindow = true)
             : this() {
             // Select debugger port for a local connection
-            ushort debuggerPortOrDefault = NodejsConstants.DefaultDebuggerPort;
-            if (debuggerPort != null) {
-                debuggerPortOrDefault = debuggerPort.Value;
-            } else {
-                List<int> activeConnections =
-                    (from listener in IPGlobalProperties.GetIPGlobalProperties().GetActiveTcpListeners()
-                     select listener.Port).ToList();
-                if (activeConnections.Contains(debuggerPortOrDefault)) {
-                    debuggerPortOrDefault = (ushort)Enumerable.Range(new Random().Next(5859, 6000), 60000).Except(activeConnections).First();
-                }
+            var debuggerPortOrDefault = debuggerPort ?? GetDebuggerPort();
+            _debuggerEndpointUri = new UriBuilder { Scheme = "tcp", Host = "localhost", Port = debuggerPortOrDefault }.Uri;
+
+            _process = StartNodeProcessWithDebug(exe, script, dir, env, interpreterOptions, debugOptions, debuggerPortOrDefault, createNodeWindow);
+        }
+
+        private static ushort GetDebuggerPort() {
+            var debuggerPortOrDefault = NodejsConstants.DefaultDebuggerPort;
+
+            var activeConnections = (from listener in IPGlobalProperties.GetIPGlobalProperties().GetActiveTcpListeners()
+                                     select listener.Port).ToList();
+
+            if (activeConnections.Contains(debuggerPortOrDefault)) {
+                debuggerPortOrDefault = (ushort)Enumerable.Range(new Random().Next(5859, 6000), 60000).Except(activeConnections).First();
             }
 
-            _debuggerEndpointUri = new UriBuilder { Scheme = "tcp", Host = "localhost", Port = debuggerPortOrDefault }.Uri;
+            return debuggerPortOrDefault;
+        }
+
+        public static NodeProcess StartNodeProcessWithDebug(string exe, string script, string dir, string env, string interpreterOptions, NodeDebugOptions debugOptions, ushort? debuggerPort = null, bool createNodeWindow = true) {
+            // Select debugger port for a local connection
+            var debuggerPortOrDefault = debuggerPort ?? GetDebuggerPort();
 
             // Node usage: node [options] [ -e script | script.js ] [arguments]
-            string allArgs = string.Format(CultureInfo.InvariantCulture,
-                "--debug-brk={0} --nolazy {1} {2}",
-                debuggerPortOrDefault,
-                interpreterOptions,
-                script
-            );
+            var allArgs = $"--debug-brk={debuggerPortOrDefault} --nolazy {interpreterOptions} \"{script}\"";
+
+            return StartNodeProcess(exe, dir, env, debugOptions, debuggerPortOrDefault, allArgs, createNodeWindow);
+        }
 
+        public static NodeProcess StartNodeProcessWithInspect(string exe, string script, string dir, string env, string interpreterOptions, NodeDebugOptions debugOptions, ushort? debuggerPort = null, bool createNodeWindow = true) {
+            // Select debugger port for a local connection
+            var debuggerPortOrDefault = debuggerPort ?? GetDebuggerPort();
+
+            // Node usage: node [options] [ -e script | script.js ] [arguments]
+            string allArgs = $"--debug-brk={debuggerPortOrDefault} --nolazy {interpreterOptions} {script}";
+
+            return StartNodeProcess(exe, dir, env, debugOptions, debuggerPortOrDefault, allArgs, createNodeWindow);
+        }
+
+        // starts the nodeprocess in debug mode without hooking up our debugger, this way we can attach the WebKit debugger as a next step.
+        private static NodeProcess StartNodeProcess(string exe, string dir, string env, NodeDebugOptions debugOptions, ushort debuggerPortOrDefault, string allArgs, bool createNodeWindow) {
             var psi = new ProcessStartInfo(exe, allArgs) {
                 CreateNoWindow = !createNodeWindow,
                 WorkingDirectory = dir,
                 UseShellExecute = false
             };
 
             if (env != null) {
-                string[] envValues = env.Split('\0');
-                foreach (string curValue in envValues) {
-                    string[] nameValue = curValue.Split(new[] { '=' }, 2);
+                var envValues = env.Split('\0');
+                foreach (var curValue in envValues) {
+                    var nameValue = curValue.Split(new[] { '=' }, 2);
                     if (nameValue.Length == 2 && !String.IsNullOrWhiteSpace(nameValue[0])) {
                         psi.EnvironmentVariables[nameValue[0]] = nameValue[1];
                     }
                 }
             }
 
-            _process = new NodeProcess(
+            return new NodeProcess(
                 psi,
-                debugOptions.HasFlag(NodeDebugOptions.WaitOnAbnormalExit),
-                debugOptions.HasFlag(NodeDebugOptions.WaitOnNormalExit),
-                true);
+                waitOnAbnormal: debugOptions.HasFlag(NodeDebugOptions.WaitOnAbnormalExit),
+                waitOnNormal: debugOptions.HasFlag(NodeDebugOptions.WaitOnNormalExit),
+                enableRaisingEvents: true,
+                debuggerPort: debuggerPortOrDefault);
         }
 
-        public NodeDebugger(Uri debuggerEndpointUri, int id)
-            : this() {
-            _debuggerEndpointUri = debuggerEndpointUri;
-            _id = id;
-            _attached = true;
-        }
+
 
         #region Public Process API
 
-        public int Id {
-            get { return _id != null ? _id.Value : _process.Id; }
-        }
+        public int Id => _id != null ? _id.Value : _process.Id;
 
-        private NodeThread MainThread {
-            get { return _threads[MainThreadId]; }
-        }
+        private NodeThread MainThread => _threads[MainThreadId];
 
-        public bool HasExited {
-            get { return !_connection.Connected; }
-        }
+        public bool HasExited => !_connection.Connected;
 
         /// <summary>
         /// Gets or sets a value indicating whether executed remote debugging process.
@@ -424,16 +432,12 @@ public void ClearExceptionTreatment() {
         /// <summary>
         /// Gets a next command identifier.
         /// </summary>
-        private int CommandId {
-            get { return Interlocked.Increment(ref _commandId); }
-        }
+        private int CommandId => Interlocked.Increment(ref _commandId);
 
         /// <summary>
         /// Gets a source mapper.
         /// </summary>
-        public SourceMapper SourceMapper {
-            get { return _sourceMapper; }
-        }
+        public SourceMapper SourceMapper => _sourceMapper;
 
         /// <summary>
         /// Gets or sets a file name mapper.
@@ -650,7 +654,7 @@ private async Task<bool> ProcessBreakpointBreakAsync(
                     }
 
                     SetBreakpointCommand result = await SetBreakpointAsync(breakpoint, cancellationToken: cancellationToken).ConfigureAwait(false);
-                    
+
                     // Treat rebound breakpoint binding as fully bound
                     NodeBreakpointBinding reboundbreakpointBinding = CreateBreakpointBinding(breakpoint, result.BreakpointId, result.ScriptId, breakpoint.GetPosition(SourceMapper).FileName, result.Line, result.Column, true);
                     HandleBindBreakpointSuccess(reboundbreakpointBinding, breakpoint);
@@ -712,7 +716,7 @@ private void OnExceptionEvent(object sender, ExceptionEventArgs args) {
 
                 var lookupCommand = new LookupCommand(CommandId, _resultFactory, new[] { exception.ErrorNumber.Value });
                 string errorCodeFromLookup = null;
-                
+
                 if (await TrySendRequestAsync(lookupCommand).ConfigureAwait(false)) {
                     errorCodeFromLookup = lookupCommand.Results[errorNumber][0].StringValue;
                     _errorCodes[errorNumber] = errorCodeFromLookup;
@@ -848,10 +852,6 @@ private IEnumerable<NodeStackFrame> GetLocalFrames(IEnumerable<NodeStackFrame> s
             return backtraceCommand.Running;
         }
 
-        internal IList<NodeThread> GetThreads() {
-            return _threads.Values.ToList();
-        }
-
         internal void SendStepOver(int identity) {
             DebugWriteCommand("StepOver");
             DebuggerClient.RunWithRequestExceptionsHandled(async () => {
@@ -1049,7 +1049,7 @@ internal async Task UpdateBreakpointBindingAsync(
 
         internal async Task<int?> GetBreakpointHitCountAsync(int breakpointId, CancellationToken cancellationToken = new CancellationToken()) {
             var listBreakpointsCommand = new ListBreakpointsCommand(CommandId);
-            
+
             int hitCount;
             if (await TrySendRequestAsync(listBreakpointsCommand, cancellationToken).ConfigureAwait(false) &&
                 listBreakpointsCommand.Breakpoints.TryGetValue(breakpointId, out hitCount)) {
@@ -1160,7 +1160,7 @@ internal async Task<NodeEvaluationResult> SetVariableValueAsync(
                 return false;
             }
         }
-        
+
         #endregion
 
         #region Debugging Events
@@ -1211,7 +1211,7 @@ private bool GetOrAddModule(NodeModule module, out NodeModule value, NodeStackFr
             javaScriptFileName = FileNameMapper.GetLocalFileName(javaScriptFileName);
 
             // Try to get mapping for JS file
-            if(stackFrame != null) {
+            if (stackFrame != null) {
                 line = stackFrame.Line;
                 column = stackFrame.Column;
             }
@@ -1255,8 +1255,6 @@ public NodeModule GetModuleForFilePath(string filePath) {
         internal void Close() {
         }
 
-
-
         #region IDisposable
 
         public void Dispose() {

Nodejs/Product/Nodejs/Debugger/NodeEvaluationResult.cs

@@ -24,7 +24,7 @@ namespace Microsoft.NodejsTools.Debugger {
     /// <summary>
     /// Represents the result of an evaluation of an expression against a given stack frame.
     /// </summary>
-    class NodeEvaluationResult {
+    internal class NodeEvaluationResult {
         private readonly Regex _stringLengthExpression = new Regex(@"\.\.\. \(length: ([0-9]+)\)$", RegexOptions.Compiled);
 
         /// <summary>

Nodejs/Product/Nodejs/Debugger/NodeEventEventArgs.cs

@@ -29,13 +29,17 @@ namespace Microsoft.NodejsTools.Debugger {
     sealed class NodeProcess : IDisposable {
         private readonly ProcessStartInfo _psi;
         private readonly bool _waitOnAbnormal, _waitOnNormal, _enableRaisingEvents;
-        private Process _process, _pressAnyKeyProcess;
+        private Process _process;
+        private Process _pressAnyKeyProcess;
 
-        public NodeProcess(ProcessStartInfo psi, bool waitOnAbnormal, bool waitOnNormal, bool enableRaisingEvents) {
+        public ushort DebuggerPort { get; }
+
+        public NodeProcess(ProcessStartInfo psi, bool waitOnAbnormal, bool waitOnNormal, bool enableRaisingEvents, ushort debuggerPort = 0) {
             _psi = psi;
             _waitOnAbnormal = waitOnAbnormal;
             _waitOnNormal = waitOnNormal;
             _enableRaisingEvents = enableRaisingEvents;
+            DebuggerPort = debuggerPort;
         }
 
         public static NodeProcess Start(ProcessStartInfo psi, bool waitOnAbnormal, bool waitOnNormal) {