Refactored the VS add-in

visual_studio/NativeClientVSAddIn/NativeClientVSAddIn/Connect.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 EnvDTE;
   using EnvDTE80;
   using Extensibility;
   using Microsoft.VisualStudio;
   using Microsoft.VisualStudio.VCProjectEngine;
-
+  
   /// <summary>The object for implementing an Add-in.</summary>
   /// <seealso class='IDTExtensibility2' />
   public class Connect : IDTExtensibility2
   {
     /// <summary>
+    /// The main Visual Studio interface.
+    /// </summary>
+    private DTE2 dte_;
+
+    /// <summary>
     /// Receives events related to starting/stopping debugging.
     /// </summary>
     private DebuggerEvents debuggerEvents_;
 
     /// <summary>
     /// Receives all generic events from Visual Studio.
     /// </summary>
     private CommandEvents commandEvents_;
 
     /// <summary>
-    /// The main Visual Studio interface.
+    /// Holds methods related to debugging.
     /// </summary>
-    private DTE2 dte_;
+    private PluginDebuggerBase debugger_;
 
     /// <summary>
-    /// Holds methods related to running the plug-in and debugging.
+    /// The web server launched during debugging.
     /// </summary>
-    private PluginDebuggerHelper debuggerHelper_;
+    private WebServer webServer_;
+
+    /// <summary>
+    /// Visual Studio output window pane that captures output from the web server, and displays
+    /// other web-server related information.
+    /// </summary>
+    private OutputWindowPane webServerOutputPane_;
 
     /// <summary>
     /// Implements the OnConnection method of the IDTExtensibility2 interface.
     /// Receives notification that the Add-in is being loaded.
     /// </summary>
     /// <param name="application">Root object of the host application.</param>
     /// <param name="connectMode">
     /// Describes how the Add-in is being loaded (e.g. command line or UI). This is unused since
     /// the add-in functions the same regardless of how it was loaded.
     /// </param>
     /// <param name="addInInst">Object representing this Add-in.</param>
     /// <param name="custom">Unused, but could contain host specific data for the add-in.</param>
     /// <seealso class='IDTExtensibility2' />
     public void OnConnection(
         object application,
         ext_ConnectMode connectMode,
         object addInInst,
         ref Array custom)
     {
       dte_ = (DTE2)application;
-      debuggerHelper_ = new PluginDebuggerHelper(dte_);
 
       debuggerEvents_ = dte_.Events.DebuggerEvents;
       debuggerEvents_.OnEnterDesignMode += DebuggerOnEnterDesignMode;
       debuggerEvents_.OnEnterRunMode += DebuggerOnEnterRunMode;
 
       commandEvents_ = dte_.Events.CommandEvents;
       commandEvents_.AfterExecute += CommandEventsAfterExecute;
+
+      try
+      {
+        webServerOutputPane_ = dte_.ToolWindows.OutputWindow.OutputWindowPanes.Item(
+            Strings.WebServerOutputWindowTitle);
+      }
+      catch (ArgumentException)
+      {
+        // This exception is expected if the window pane hasn't been created yet.
+        webServerOutputPane_ = dte_.ToolWindows.OutputWindow.OutputWindowPanes.Add(
+            Strings.WebServerOutputWindowTitle);
+      }
     }
 
     /// <summary>
     /// Implements the OnDisconnection method of the IDTExtensibility2
     /// interface. Receives notification that the Add-in is being unloaded.
     /// </summary>
     /// <param name='disconnectMode'>Describes how the Add-in is being unloaded.</param>
     /// <param name='custom'>Array of parameters that are host application specific.</param>
     /// <seealso class='IDTExtensibility2' />
     public void OnDisconnection(ext_DisconnectMode disconnectMode, ref Array custom)
@@ skipping 66 matching lines @@
     /// PerformPropertyFixes() performs a work around on the property pages to force Visual Studio
     /// to save some specific properties into the project file to get around issue 140162.
     /// </summary>
     private void PerformPropertyModifications()
     {
       string naclAddInVersion = GetAddInVersionFromDescription();
 
       var configs = Utility.GetPlatformVCConfigurations(dte_, Strings.PepperPlatformName);
       configs.AddRange(Utility.GetPlatformVCConfigurations(dte_, Strings.NaClPlatformName));
 
+      var properties = new PropertyManager();
       foreach (VCConfiguration config in configs)
       {
-        IVCRulePropertyStorage general = config.Rules.Item("ConfigurationGeneral");
-        string projectVersionSetting = general.GetEvaluatedPropertyValue("NaClAddInVersion");
-        if (string.IsNullOrEmpty(projectVersionSetting))
+        properties.SetTarget(config);
+        if (string.IsNullOrEmpty(properties.NaClAddInVersion))
         {
-          general.SetPropertyValue("NaClAddInVersion", naclAddInVersion);
+          // Set the NaCl add-in version so that it is stored in the project file.
+          properties.SetProperty("ConfigurationGeneral", "NaClAddInVersion", naclAddInVersion);
+          
+          // Expand the CHROME_PATH variable to its full path.
+          string expandedChrome = properties.GetProperty(
+              "WindowsLocalDebugger", "LocalDebuggerCommand");
+          properties.SetProperty("WindowsLocalDebugger", "LocalDebuggerCommand", expandedChrome);
 
           // Work around for issue 140162. Forces some properties to save to the project file.
           PerformPropertyFixes(config);
         }
       }
     }
 
     /// <summary>
     /// Takes a project configuration and sets values in the project file to work around some
     /// problems in Visual Studio. This is a work around for issue 140162.
     /// </summary>
     /// <param name="config">A configuration that needs modification.</param>
     private void PerformPropertyFixes(VCConfiguration config)
     {
       IVCRulePropertyStorage debugger = config.Rules.Item("WindowsLocalDebugger");
-      string evaluatedCommand = debugger.GetEvaluatedPropertyValue("LocalDebuggerCommand");
-      debugger.SetPropertyValue("LocalDebuggerCommand", evaluatedCommand);
-
       string arguments = debugger.GetUnevaluatedPropertyValue("LocalDebuggerCommandArguments");
       debugger.SetPropertyValue("LocalDebuggerCommandArguments", arguments);
     }
 
     /// <summary>
     /// During the build process we dynamically put the add-in version number into the add-in
     /// description.  This function extracts that version number.
     /// </summary>
     /// <returns>The add-in version number.</returns>
     private string GetAddInVersionFromDescription()
@@ skipping 12 matching lines @@
             break;
           }
         }
       }
 
       return naclAddinVersion;
     }
 
     /// <summary>
     /// Called when Visual Studio ends a debugging session.
+    /// Shuts down the web server and debugger.
     /// </summary>
     /// <param name="reason">The parameter is not used.</param>
     private void DebuggerOnEnterDesignMode(dbgEventReason reason)
     {
-      debuggerHelper_.StopDebugging();
+      if (debugger_ != null)
+      {
+        debugger_.Dispose();
+        debugger_ = null;
+      }
+
+      if (webServer_ != null)
+      {
+        webServer_.Dispose();
+        webServer_ = null;
+      }
     }
 
     /// <summary>
     /// Called when Visual Studio starts a debugging session.
+    /// Here we kick off the debugger and web server if appropriate.
     /// </summary>
     /// <param name="reason">Indicates how we are entering run mode (breakpoint or launch).</param>
     private void DebuggerOnEnterRunMode(dbgEventReason reason)
     {
       // If we are starting debugging (not re-entering from a breakpoint)
       // then load project settings and start the debugger-helper.
-      if (reason == dbgEventReason.dbgEventReasonLaunchProgram &&
-          debuggerHelper_.LoadProjectSettings())
+      if (reason == dbgEventReason.dbgEventReasonLaunchProgram)
       {
-        debuggerHelper_.StartDebugging();
+        PropertyManager properties = new PropertyManager();
+        properties.SetTargetToActive(dte_);
+        if (properties.ProjectPlatform == PropertyManager.ProjectPlatformType.NaCl)
+        {
+          debugger_ = new PluginDebuggerGDB(dte_, properties);
+          webServer_ = new WebServer(webServerOutputPane_, properties);
+        }
+        else if (properties.ProjectPlatform == PropertyManager.ProjectPlatformType.Pepper)
+        {
+          debugger_ = new PluginDebuggerVS(dte_, properties);
+          webServer_ = new WebServer(webServerOutputPane_, properties);
+        }
       }
     }
   }
 }