VS Add-in more properties and improvements

visual_studio/NativeClientVSAddIn/NativeClientVSAddIn/PluginDebuggerHelper.cs

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 namespace NativeClientVSAddIn
 {
   using System;
   using System.Collections.Generic;
   using System.IO;
   using System.Linq;
@@ skipping 16 matching lines @@
     /// </summary>
     private const int InitialPluginCheckFrequency = 1000;
 
     /// <summary>
     /// After a plug-in has been found, we slow the frequency of checking
     /// for new ones. This value is in milliseconds.
     /// </summary>
     private const int RelaxedPluginCheckFrequency = 5000;
 
     /// <summary>
+    /// The web server port to default to if the user does not specify one.
+    /// </summary>
+    private const int DefaultWebServerPort = 5103;
+
+    /// <summary>
     /// The main visual studio object through which all Visual Studio functions are executed.
     /// </summary>
     private DTE2 dte_;
 
     /// <summary>
     /// Indicates the PluginDebuggerHelper is configured properly to run.
     /// </summary>
     private bool isProperlyInitialized_ = false;
 
     /// <summary>
@@ skipping 179 matching lines @@
         projectPlatformType_ = ProjectPlatformType.NaCl;
         PluginFoundEvent += new EventHandler<PluginFoundEventArgs>(AttachNaClGDB);
       }
       else
       {
         projectPlatformType_ = ProjectPlatformType.Other;
         return false;
       }
 
       // We only support certain project types (e.g. C/C++ projects). Otherwise we fail.
-      // If supported, extract necessary information from specific project type.
-      if (Utility.IsVisualCProject(startProject))
-      {
-        VCConfiguration config = Utility.GetActiveVCConfiguration(startProject);
-        IVCRulePropertyStorage general = config.Rules.Item("ConfigurationGeneral");
-        VCLinkerTool linker = config.Tools.Item("VCLinkerTool");
-        VCProject vcproj = (VCProject)startProject.Object;
-        
-        sdkRootDirectory_ = general.GetEvaluatedPropertyValue("VSNaClSDKRoot");
-        platformToolset = general.GetEvaluatedPropertyValue("PlatformToolset");
-        pluginOutputDirectory_ = config.Evaluate(config.OutputDirectory);
-        pluginAssembly_ = config.Evaluate(linker.OutputFile);
-        pluginProjectDirectory_ = vcproj.ProjectDirectory;  // Macros not allowed here.
-        
-        if (projectPlatformType_ == ProjectPlatformType.NaCl)
-        {
-          irtPath_ = general.GetEvaluatedPropertyValue("NaClIrtPath");
-          manifestPath_ = general.GetEvaluatedPropertyValue("NaClManifestPath");
-        }
-      }
-      else
+      if (!Utility.IsVisualCProject(startProject))
       {
         return false;
       }
 
+      // Extract necessary information from specific project type.
+      VCConfiguration config = Utility.GetActiveVCConfiguration(startProject);
+      IVCRulePropertyStorage general = config.Rules.Item("ConfigurationGeneral");
+      VCLinkerTool linker = config.Tools.Item("VCLinkerTool");
+      VCProject vcproj = (VCProject)startProject.Object;
+        
+      sdkRootDirectory_ = general.GetEvaluatedPropertyValue("VSNaClSDKRoot");
+      platformToolset = general.GetEvaluatedPropertyValue("PlatformToolset");
+      pluginOutputDirectory_ = config.Evaluate(config.OutputDirectory);
+      pluginAssembly_ = config.Evaluate(linker.OutputFile);
+      pluginProjectDirectory_ = vcproj.ProjectDirectory;  // Macros not allowed here.
+      
+      if (projectPlatformType_ == ProjectPlatformType.NaCl)
+      {
+        irtPath_ = general.GetEvaluatedPropertyValue("NaClIrtPath");
+        manifestPath_ = general.GetEvaluatedPropertyValue("NaClManifestPath");
+      }
+
       if (string.IsNullOrEmpty(sdkRootDirectory_))
       {
-        MessageBox.Show(
-            string.Format(Strings.SDKPathNotSetFormat, Strings.SDKPathEnvironmentVariable));
+        MessageBox.Show(Strings.SDKPathNotSetError);
         return false;
       }
 
       sdkRootDirectory_ = sdkRootDirectory_.TrimEnd("/\\".ToArray<char>());
 
-      // TODO(tysand): Add user option to specify this.
-      int webServerPort = 5103;
+      // TODO(tysand): Move this code getting port to where the web server is started.
+      int webServerPort;
+      if (!int.TryParse(general.GetEvaluatedPropertyValue("NaClWebServerPort"), out webServerPort))
+      {
+        webServerPort = DefaultWebServerPort;
+      }
+
       webServerExecutable_ = "python.exe";
       webServerArguments_ = string.Format(
-          "{0}\\examples\\httpd.py --no_dir_check {1}",
-          sdkRootDirectory_,
-          webServerPort);
+          "{0}\\examples\\httpd.py --no_dir_check {1}", sdkRootDirectory_, webServerPort);
 
       gdbPath_ = Path.Combine(
           sdkRootDirectory_, "toolchain", platformToolset, @"bin\x86_64-nacl-gdb.exe");
 
       debuggedChromeMainProcess_ = null;
 
       isProperlyInitialized_ = true;
       return true;
     }
 
@@ skipping 23 matching lines @@
 
       // Remove all event handlers from the plug-in found event.
       if (PluginFoundEvent != null)
       {
         foreach (Delegate del in PluginFoundEvent.GetInvocationList())
         {
           PluginFoundEvent -= (EventHandler<PluginFoundEventArgs>)del;
         }
       }
 
-      if (webServer_ != null)
-      {
-        webServer_.Kill();
-        webServer_.Dispose();
-        webServer_ = null;
-      }
-
-      KillGDBProcess();
+      Utility.EnsureProcessKill(ref webServer_);
+      WebServerWriteLine(Strings.WebServerStopMessage);
+      CleanUpGDBProcess();
     }
 
     /// <summary>
     /// This function cleans up the started GDB process.
     /// </summary>
-    private void KillGDBProcess()
+    private void CleanUpGDBProcess()
     {
-      if (gdbProcess_ != null)
+      Utility.EnsureProcessKill(ref gdbProcess_);
+      if (!string.IsNullOrEmpty(gdbInitFileName_) && File.Exists(gdbInitFileName_))
       {
-        if (!gdbProcess_.HasExited)
-        {
-          gdbProcess_.Kill();
-          gdbProcess_.Dispose();
-        }
-
-        if (!string.IsNullOrEmpty(gdbInitFileName_) && File.Exists(gdbInitFileName_))
-        {
-          File.Delete(gdbInitFileName_);
-        }
-
-        gdbProcess_ = null;
+        File.Delete(gdbInitFileName_);
+        gdbInitFileName_ = null;
       }
     }
 
     /// <summary>
     /// This is called periodically by the Visual Studio UI thread to look for our plug-in process
     /// and attach the debugger to it.  The call is triggered by the pluginFinderTimer_ object.
     /// </summary>
     /// <param name="unused">The parameter is not used.</param>
     /// <param name="unused1">The parameter is not used.</param>
     private void FindAndAttachToPlugin(object unused, EventArgs unused1)
@@ skipping 13 matching lines @@
           }
         }
 
         return;
       }
 
       // Get the list of all descendants of the main chrome process.
       uint mainChromeProcId = (uint)debuggedChromeMainProcess_.Id;
       List<ProcessInfo> chromeDescendants = processSearcher_.GetDescendants(mainChromeProcId);
 
+      // If we didn't start with debug flags then we should not attach.
+      string mainChromeFlags = chromeDescendants.Find(p => p.ID == mainChromeProcId).CommandLine;
+      if (projectPlatformType_ == ProjectPlatformType.NaCl &&
+          !mainChromeFlags.Contains(Strings.NaClDebugFlag))
+      {
+        return;
+      }
+
       // From the list of descendants, find the plug-in by it's command line arguments and
       // process name as well as not being attached to already.
       List<ProcessInfo> plugins;
       switch (projectPlatformType_)
       {
         case ProjectPlatformType.Pepper:
           string identifierFlagTarget =
               string.Format(Strings.PepperProcessPluginFlagFormat, pluginAssembly_);
           plugins = chromeDescendants.FindAll(p =>
              p.Name.Equals(Strings.ChromeProcessName, ignoreCase) &&
@@ skipping 45 matching lines @@
     /// Attaches the NaCl GDB debugger to the NaCl plug-in process.  Handles loading symbols
     /// and breakpoints from Visual Studio.
     /// </summary>
     /// <param name="src">The parameter is not used.</param>
     /// <param name="args">
     /// Contains the process ID to attach to, unused since debug stub is already attached.
     /// </param>
     private void AttachNaClGDB(object src, PluginFoundEventArgs args)
     {
       // Clean up any pre-existing GDB process (can happen if user reloads page).
-      KillGDBProcess();
+      CleanUpGDBProcess();
 
       gdbInitFileName_ = Path.GetTempFileName();
       string pluginAssemblyEscaped = pluginAssembly_.Replace("\\", "\\\\");
       string irtPathEscaped = irtPath_.Replace("\\", "\\\\");
 
       // Create the initialization file to read in on GDB start.
       StringBuilder contents = new StringBuilder();
 
       if (!string.IsNullOrEmpty(manifestPath_))
       {
         string manifestEscaped = manifestPath_.Replace("\\", "\\\\");
         contents.AppendFormat("nacl-manifest {0}\n", manifestEscaped);
       }
       else
       {
         contents.AppendFormat("file \"{0}\"\n", pluginAssemblyEscaped);
       }
 
       contents.AppendFormat("nacl-irt {0}\n", irtPathEscaped);
       contents.AppendFormat("target remote localhost:{0}\n", 4014);
 
       // Insert breakpoints from Visual Studio project.
       foreach (Breakpoint bp in dte_.Debugger.Breakpoints)
       {
-        if (bp.Enabled &&
-            bp.LocationType == dbgBreakpointLocationType.dbgBreakpointLocationTypeFile)
+        if (!bp.Enabled)
         {
-          contents.AppendFormat("b {0}:{1}", Path.GetFileName(bp.File), bp.FileLine);
-          contents.AppendLine();
+          continue;
         }
-        else if (bp.Enabled &&
-            bp.LocationType == dbgBreakpointLocationType.dbgBreakpointLocationTypeFunction)
+
+        if (bp.LocationType == dbgBreakpointLocationType.dbgBreakpointLocationTypeFile)
         {
-          contents.AppendFormat("b {0}", bp.FunctionName);
-          contents.AppendLine();
+          contents.AppendFormat("b {0}:{1}\n", Path.GetFileName(bp.File), bp.FileLine);
         }
-        else if (bp.Enabled)
+        else if (bp.LocationType == dbgBreakpointLocationType.dbgBreakpointLocationTypeFunction)
+        {
+          contents.AppendFormat("b {0}\n", bp.FunctionName);
+        }
+        else
         {
           WebServerWriteLine(
             string.Format(Strings.UnsupportedBreakpointTypeFormat, bp.LocationType.ToString()));
         }
       }
 
       contents.AppendLine("continue");
       File.WriteAllText(gdbInitFileName_, contents.ToString());
 
       // Start NaCl-GDB.
@@ skipping 61 matching lines @@
     {
       WebServerWriteLine(e.Data);
     }
 
     /// <summary>
     /// Helper function to write data to the Web Server Output Pane.
     /// </summary>
     /// <param name="message">Message to write.</param>
     private void WebServerWriteLine(string message)
     {
-      webServerOutputPane_.OutputString(message + "\n");
+      if (webServerOutputPane_ != null)
+      {
+        webServerOutputPane_.OutputString(message + "\n");
+      }
     }
 
     /// <summary>
     /// The event arguments when a plug-in is found.
     /// </summary>
     public class PluginFoundEventArgs : EventArgs
     {
       /// <summary>
       /// Construct the PluginFoundEventArgs.
       /// </summary>
       /// <param name="pid">Process ID of the found plug-in.</param>
       public PluginFoundEventArgs(uint pid)
       {
         this.ProcessID = pid;
       }
 
       /// <summary>
       /// Gets or sets process ID of the found plug-in.
       /// </summary>
       public uint ProcessID { get; set; }
     }
   }
 }