Perf is bad enumerating runtimes and host apps so make those manual

Author: david-risney

wv2util/AppOverrideUi.xaml.cs

@@ -61,7 +61,14 @@ private void ListView_SelectionChanged(object sender, SelectionChangedEventArgs
             if (RuntimeList.SelectedIndex >= 0)
             {
                 RuntimeEntry selection = (RuntimeEntry)RuntimeList.SelectedItem;
-                Clipboard.SetText(selection.RuntimeLocation);
+                try
+                {
+                    Clipboard.SetText(selection.RuntimeLocation);
+                }
+                catch (System.Runtime.InteropServices.COMException)
+                {
+                    // We might fail to open clipboard. Just ignore
+                }
             }
         }
 

wv2util/HostAppList.cs

@@ -41,13 +41,13 @@ public class HostAppList : ObservableCollection<HostAppEntry>
     {
         public HostAppList()
         {
-            FromMachine();
+            // FromMachine();
         }
 
         public void FromMachine()
         {
 
-            IEnumerable<HostAppEntry> newEntries = GetHostAppEntriesFromMachine();
+            IEnumerable<HostAppEntry> newEntries = GetHostAppEntriesFromMachine().ToList<HostAppEntry>();
             // Use ToList to get a fixed collection that won't get angry that we're calling
             // Add and Remove on it while enumerating.
             foreach (var entry in this.Except(newEntries).ToList<HostAppEntry>())
@@ -85,7 +85,7 @@ private static IEnumerable<HostAppEntry> GetHostAppEntriesFromMachine()
                 if (processType == null)
                 {
                     HostAppEntry entry = new HostAppEntry(
-                        process.Parent().GetMainModuleFileName(),
+                        process.ParentProcess().GetMainModuleFileName(),
                         process.GetMainModuleFileName(),
                         userDataPath);
                     yield return entry;
@@ -148,4 +148,117 @@ public static string GetMainModuleFileName(this Process process, int buffer = 10
                 null;
         }
     }
+
+    public static class ProcessExtensions2
+    {
+        /// <summary>
+        /// Returns the Parent Process of a Process
+        /// </summary>
+        /// <param name="process">The Windows Process.</param>
+        /// <returns>The Parent Process of the Process.</returns>
+        public static Process ParentProcess(this Process process)
+        {
+            int parentPid = 0;
+            int processPid = process.Id;
+            uint TH32CS_SNAPPROCESS = 2;
+
+            // Take snapshot of processes
+            IntPtr hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
+
+            if (hSnapshot == IntPtr.Zero)
+            {
+                return null;
+            }
+
+            PROCESSENTRY32 procInfo = new PROCESSENTRY32();
+
+            procInfo.dwSize = (uint)Marshal.SizeOf(typeof(PROCESSENTRY32));
+
+            // Read first
+            if (Process32First(hSnapshot, ref procInfo) == false)
+            {
+                return null;
+            }
+
+            // Loop through the snapshot
+            do
+            {
+                // If it's me, then ask for my parent.
+                if (processPid == procInfo.th32ProcessID)
+                {
+                    parentPid = (int)procInfo.th32ParentProcessID;
+                }
+            }
+            while (parentPid == 0 && Process32Next(hSnapshot, ref procInfo)); // Read next
+
+            if (parentPid > 0)
+            {
+                return Process.GetProcessById(parentPid);
+            }
+            else
+            {
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Takes a snapshot of the specified processes, as well as the heaps, 
+        /// modules, and threads used by these processes.
+        /// </summary>
+        /// <param name="dwFlags">
+        /// The portions of the system to be included in the snapshot.
+        /// </param>
+        /// <param name="th32ProcessID">
+        /// The process identifier of the process to be included in the snapshot.
+        /// </param>
+        /// <returns>
+        /// If the function succeeds, it returns an open handle to the specified snapshot.
+        /// If the function fails, it returns INVALID_HANDLE_VALUE.
+        /// </returns>
+        [DllImport("kernel32.dll", SetLastError = true)]
+        private static extern IntPtr CreateToolhelp32Snapshot(uint dwFlags, uint th32ProcessID);
+
+        /// <summary>
+        /// Retrieves information about the first process encountered in a system snapshot.
+        /// </summary>
+        /// <param name="hSnapshot">A handle to the snapshot.</param>
+        /// <param name="lppe">A pointer to a PROCESSENTRY32 structure.</param>
+        /// <returns>
+        /// Returns TRUE if the first entry of the process list has been copied to the buffer.
+        /// Returns FALSE otherwise.
+        /// </returns>
+        [DllImport("kernel32.dll")]
+        private static extern bool Process32First(IntPtr hSnapshot, ref PROCESSENTRY32 lppe);
+
+        /// <summary>
+        /// Retrieves information about the next process recorded in a system snapshot.
+        /// </summary>
+        /// <param name="hSnapshot">A handle to the snapshot.</param>
+        /// <param name="lppe">A pointer to a PROCESSENTRY32 structure.</param>
+        /// <returns>
+        /// Returns TRUE if the next entry of the process list has been copied to the buffer.
+        /// Returns FALSE otherwise.</returns>
+        [DllImport("kernel32.dll")]
+        private static extern bool Process32Next(IntPtr hSnapshot, ref PROCESSENTRY32 lppe);
+
+        /// <summary>
+        /// Describes an entry from a list of the processes residing 
+        /// in the system address space when a snapshot was taken.
+        /// </summary>
+        [StructLayout(LayoutKind.Sequential)]
+        private struct PROCESSENTRY32
+        {
+            public uint dwSize;
+            public uint cntUsage;
+            public uint th32ProcessID;
+            public IntPtr th32DefaultHeapID;
+            public uint th32ModuleID;
+            public uint cntThreads;
+            public uint th32ParentProcessID;
+            public int pcPriClassBase;
+            public uint dwFlags;
+            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
+            public string szExeFile;
+        }
+    }
 }

wv2util/RuntimeList.cs

@@ -21,7 +21,15 @@ public string Version
         {
             get
             {
-                return FileVersionInfo.GetVersionInfo(ExePath).FileVersion;
+                try
+                {
+                    return FileVersionInfo.GetVersionInfo(ExePath).FileVersion;
+                }
+                catch (System.IO.FileNotFoundException e)
+                {
+                    // Somehow this is possible.
+                    return "FileNotFound";
+                }
             }
         }
         public string Channel
@@ -57,7 +65,7 @@ public class RuntimeList : ObservableCollection<RuntimeEntry>
     {
         public RuntimeList()
         {
-            FromDisk();
+            // FromDisk();
         }
 
         public void FromDisk()
@@ -76,24 +84,33 @@ public void FromDisk()
         }
         private static IEnumerable<RuntimeEntry> GetInstalledRuntimes()
         {
-            string microsoftRootPath = Environment.GetEnvironmentVariable("LOCALAPPDATA") + "\\Microsoft\\";
-            var potentialParents = Directory.GetDirectories(microsoftRootPath).Where(path => path.Contains("Edge"));
-                
-            foreach (string potentialParent in potentialParents)
+            string[] rootPaths =
             {
-                string[] foundExes = null;
-                try
-                {
-                    foundExes = Directory.GetFiles(potentialParent, "msedgewebview2.exe", SearchOption.AllDirectories);
-                }
-                catch (UnauthorizedAccessException e)
-                {
-                    Debug.WriteLine("Ignoring unauthorized access exception while searching for WebView2 runtimes: " + e.Message);
-                }
+                Environment.GetEnvironmentVariable("LOCALAPPDATA") + "\\Microsoft\\",
+                Environment.GetEnvironmentVariable("ProgramFiles(x86)") + "\\Microsoft\\",
+                Environment.GetEnvironmentVariable("ProgramFiles") + "\\Microsoft\\"
+            };
 
-                foreach (string path in foundExes)
+            foreach (string rootPath in rootPaths)
+            {
+                var potentialParents = Directory.GetDirectories(rootPath).Where(path => path.Contains("Edge"));
+
+                foreach (string potentialParent in potentialParents)
                 {
-                    yield return new RuntimeEntry(path);
+                    string[] foundExes = null;
+                    try
+                    {
+                        foundExes = Directory.GetFiles(potentialParent, "msedgewebview2.exe", SearchOption.AllDirectories);
+                    }
+                    catch (UnauthorizedAccessException e)
+                    {
+                        Debug.WriteLine("Ignoring unauthorized access exception while searching for WebView2 runtimes: " + e.Message);
+                    }
+
+                    foreach (string path in foundExes)
+                    {
+                        yield return new RuntimeEntry(path);
+                    }
                 }
             }
         }