Only take into account processes that have our plugin loaded

installer/src/installer-lib/process.cpp

 #include <stdexcept>
 #include <functional>
 #include <wctype.h>
 // <thread> is C++11, but implemented in VS2012
 #include <thread>
 
 #include "process.h"
 
 //-------------------------------------------------------
 // Windows_Handle
@@ skipping 13 matching lines @@
 {
   this -> ~Windows_Handle() ;
   handle = h ;
   validate_handle() ;
 }
 
 void Windows_Handle::validate_handle()
 {
   if ( handle == INVALID_HANDLE_VALUE )
   {
-    throw std::runtime_error( "Invalid handle" ) ;
+    // TODO: This code really deserves use of a proper exception class that packages 
+    // Windows API errors consistently.
+    char tmp[256];
+    sprintf_s(tmp, "Invalid handle. Last error: %d", GetLastError());
+    throw std::runtime_error( tmp ) ;
   }
 }
 
 //-------------------------------------------------------
 // process_by_name_CI
 //-------------------------------------------------------
 process_by_name_CI::process_by_name_CI( const wchar_t * name )
   : name( name ), length( wcslen( name ) )
 {}
 
 bool process_by_name_CI::operator()( const PROCESSENTRY32W & process )
 {
   return 0 == wcsncmpi( process.szExeFile, name, length ) ;
 }
 
-//-------------------------------------------------------
-// process_by_any_exe_name_CI
-//-------------------------------------------------------
-bool process_by_any_exe_name_CI::operator()( const PROCESSENTRY32W & process )
+
+bool process_by_any_exe_with_any_module::operator()( const PROCESSENTRY32W & process )
 {
-  return names.find( process.szExeFile ) != names.end() ;
+  if (processNames.find(process.szExeFile) != processNames.end())
+  {
+    if (moduleNames.empty())
+      return true;
+
+    ModulesSnapshot ms(process.th32ProcessID);
+    MODULEENTRY32W* me = ms.first();
+    while (me != NULL)
+    {
+      if (moduleNames.find(me->szModule) != moduleNames.end())
+      {
+        return true;
+      }
+      me = ms.next();
+    }
+  }
+  return false;
 }
 
 //-------------------------------------------------------
 // wcscmpi
 //-------------------------------------------------------
 int wcscmpi( const wchar_t * s1, const wchar_t * s2 )
 {
   // Note: Equality of character sequences is case-insensitive in all predicates below.
   // Loop invariant: s1[0..j) == s2[0..j)
   const size_t LIMIT( 65535 ) ; // Runaway limit of 2^16 - 1 should be acceptably long.
@@ skipping 72 matching lines @@
 
 //-------------------------------------------------------
 // Snapshot
 //-------------------------------------------------------
 Snapshot::Snapshot()
   : handle( ::CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 ) )
 {
   process.dwSize = sizeof( PROCESSENTRY32W ) ;
 }
 
-PROCESSENTRY32W * Snapshot::begin()
+PROCESSENTRY32W * Snapshot::first()
 {
-  return ::Process32FirstW( handle, & process ) ? ( & process ) : 0 ;
+  return ::Process32FirstW(handle, &process) ? (&process) : 0;
 }
 
 PROCESSENTRY32W * Snapshot::next()
 {
-  return ::Process32NextW( handle, & process ) ? ( & process ) : 0 ;
+  return ::Process32NextW(handle, &process) ? (&process) : 0;
 }
 
 void Snapshot::refresh()
 {
-  handle = ::CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 ) ;
+  handle = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
 }
 
 
+//-------------------------------------------------------
+// ModulesSnapshot
+//-------------------------------------------------------
+ModulesSnapshot::ModulesSnapshot(DWORD processId)
+  : handle(::CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, processId))
+{
+  module.dwSize = sizeof(MODULEENTRY32);
+}
+
+MODULEENTRY32W * ModulesSnapshot::first()
+{
+  return ::Module32FirstW(handle, &module) ? (&module) : 0;
+}
+
+MODULEENTRY32W * ModulesSnapshot::next()
+{
+  return ::Module32NextW(handle, &module) ? (&module) : 0;
+}
+
+
 //-------------------------------------------------------
 // send_message, send_endsession_messages
 //-------------------------------------------------------
 /**
  * Default process exit wait time (per message) 5000 ms
  *
  * 5 seconds is time that the system will wait before it considers a process non-responsive.
  */
 static const unsigned int timeout = 5000 ;    // milliseconds
 
@@ skipping 233 matching lines @@
       if ( ! is_running() )
       {
         return true ;
       }
     }
     // Assert is_running()
   }
   // No control path leaves the for-loop.
 } ;