VS Add-in more properties and improvements

visual_studio/NativeClientVSAddIn/NativeClientVSAddIn/Utility.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 EnvDTE;
+  using EnvDTE80;
   using Microsoft.VisualStudio.VCProjectEngine;
 
   /// <summary>
   /// Contains helper functions for this add-in.
   /// </summary>
   public static class Utility
   {
     /// <summary>
     /// Tells us if the given project is a Visual C/C++ project.
     /// </summary>
     /// <param name="proj">Project to check.</param>
     /// <returns>True if project is a Visual C/C++ project.</returns>
     public static bool IsVisualCProject(Project proj)
     {
-      string projectType = proj.Properties.Item("Kind").Value as string;
-      return projectType == "VCProject";
+      foreach (Property prop in proj.Properties)
+      {
+        if (prop.Name == "Kind")
+        {
+          string projectType = prop.Value as string;
+          return projectType == "VCProject";
+        }
+      }
+
+      return false;
     }
 
     /// <summary>
     /// Given a generic project, checks that it is a Visual C project, and
     /// extracts the active VCConfiguration object.
     /// </summary>
     /// <param name="proj">Generic project object.</param>
     /// <returns>The active configuration, or null if failure.</returns>
     public static VCConfiguration GetActiveVCConfiguration(Project proj)
     {
@@ skipping 12 matching lines @@
             config.Platform.Name == active.PlatformName)
         {
           return config;
         }
       }
 
       return null;
     }
 
     /// <summary>
+    /// Returns all VCConfigurations from the open solution that have the specified platform name.
+    /// Note only VC++ projects are checked.
+    /// </summary>
+    /// <param name="dte">Visual studio main interface.</param>
+    /// <param name="platformName">Name of the platform to get.</param>
+    /// <returns>List of all matching VCConfigurations.</returns>
+    public static List<VCConfiguration> GetPlatformVCConfigurations(DTE2 dte, string platformName)
+    {
+      var platformConfigs = new List<VCConfiguration>();
+      foreach (Project proj in dte.Solution.Projects)
+      {
+        if (Utility.IsVisualCProject(proj))
+        {
+          VCProject vcproj = (VCProject)proj.Object;
+          IVCCollection configs = vcproj.Configurations;
+
+          foreach (VCConfiguration config in configs)
+          {
+            if (platformName.Equals(config.Platform.Name))
+            {
+              platformConfigs.Add(config);
+            }
+          }
+        }
+      }
+
+      return platformConfigs;
+    }
+
+    /// <summary>
     /// Extends the string class to allow checking if a string contains another string
     /// allowing a comparison type (such as case-insensitivity).
     /// </summary>
     /// <param name="source">Base string to search.</param>
     /// <param name="toCheck">String to check if contained within base string.</param>
     /// <param name="comparison">Comparison type.</param>
     /// <returns>True if toCheck is contained in source.</returns>
     public static bool Contains(this string source, string toCheck, StringComparison comparison)
     {
       return source.IndexOf(toCheck, comparison) != -1;
@@ skipping 13 matching lines @@
       uint ancestor)
     {
       return IsDescendantOfProcessHelper(
           processSearcher,
           descendant,
           ancestor,
           DateTime.UtcNow);
     }
 
     /// <summary>
+    /// Helper function to properly dispose of a process object and ensure it is dead.  The given
+    /// reference is set to null afterwards.
+    /// </summary>
+    /// <param name="process">Process to kill.  Reference is set to null afterwards.</param>
+    public static void EnsureProcessKill(ref System.Diagnostics.Process process)
+    {
+      if (process == null)
+      {
+        return;
+      }
+
+      try
+      {
+        process.Kill();
+      }
+      catch (System.InvalidOperationException)
+      {
+        // This happens if the process has already exited.
+      }
+      
+      process.Dispose();
+      process = null;
+    }
+
+    /// <summary>
     /// Helper function for IsDescendantOfProcessHelper().
     /// This function prevents an edge case where a process has a parent process ID
     /// that refers to a descendant of itself. This can occur when the parent of a process
     /// is destroyed and the parent's pid is recycled and reused on a descendant.  The
     /// parent process ID value is never updated when the parent is destroyed. The solution
     /// is to make sure that parents are created before children, otherwise it is a cycle.
     /// </summary>
     /// <param name="processSearcher">Process searcher object.</param>
     /// <param name="descendant">Process ID of the descendant.</param>
     /// <param name="anscestor">Process ID of the ancestor.</param>
@@ skipping 26 matching lines @@
               proc.ParentID,
               anscestor,
               proc.CreationDate);
         }
       }
 
       return false;
     }
   }
 }