Make sure IE and Engine are actually being closed by custom action

installer/src/installer-lib/process.h

 /**
  * \file process.h
  */
 
 #ifndef PROCESS_H
 #define PROCESS_H
 
 #include "installer-lib.h"
 #include "handle.h"
 
@@ skipping 74 matching lines @@
     for ( unsigned int j = 0 ; j < n_file_names ; ++ j )
     {
       insert( wstring_ci( file_name_list[ j ] ) ) ;
     }
   }
 } ;
 
 //-------------------------------------------------------
 //-------------------------------------------------------
 /**
- * Filter by process name. Comparison is case-insensitive. With ABP module loaded
+ * Filter by process name. Comparison is case-insensitive. Windows Store app processes excluded
  */
-class process_by_any_exe_with_any_module
-  : public std::binary_function< PROCESSENTRY32W, file_name_set, bool >
+class process_by_any_exe_not_immersive
+  : public std::unary_function<PROCESSENTRY32W, bool>
 {
   /**
    * Set of file names from which to match candidate process names.
    *
    * This is a reference to, not a copy of, the set.
    * The lifetime of this object must be subordinate to that of its referent.
    * The set used to instantiate this class is a member of Process_Closer,
    *   and so also is this class.
    * Hence the lifetimes are coterminous, and the reference is not problematic.
    */
-  const file_name_set & processNames ;
-  const file_name_set & moduleNames;
+  const file_name_set & processNames;
 public:
-  bool operator()( const PROCESSENTRY32W & ) ;
-  process_by_any_exe_with_any_module( const file_name_set & names, const file_name_set & moduleNames )
-    : processNames( names ), moduleNames( moduleNames )
-  {}
+  bool operator()( const PROCESSENTRY32W & );
+  process_by_any_exe_not_immersive(const file_name_set & names) : processNames( names ) {}
 } ;
 
 
 //-------------------------------------------------------
 // Process utility functions.
 //-------------------------------------------------------
 /**
  * A promiscuous filter admits everything.
  */
 struct every_process
@@ skipping 475 matching lines @@
   std::set< DWORD > pid_set ;
 
   /**
    * Set of executable names by which to filter.
    *
    * The argument of the filter constructor is a set by reference.
    * Since it does not make a copy for itself, we define it as a class member to provide its allocation.
    */
   file_name_set process_names ;
 
-  /**
-   * Set of module (DLL) names by which to filter.
-   */
-  file_name_set module_names ;
-
-  process_by_any_exe_with_any_module filter ;
+  process_by_any_exe_not_immersive filter ;
 
   /**
    * Copy function object copies just the process ID.
    */
   copy_PID copy ;
 
   /** 
    * Snapshot of running processes.
    */
   Process_Snapshot & snapshot ;
@@ skipping 30 matching lines @@
       if ( ! b )
       {
         // Assert the process that created the window is not in our pid_set
         return true ;
       }
       return f( window ) ;
     }
   } ;
 
 public:
-  template <size_t n_file_names, size_t n_module_names>
-  Process_Closer(Process_Snapshot & snapshot, const wchar_t* (&file_name_list)[n_file_names], const wchar_t* (&module_name_list)[n_module_names])
-    : snapshot(snapshot), process_names(file_name_list), module_names(module_name_list), filter(process_names, module_names)
+  template <size_t n_file_names>
+  Process_Closer(Process_Snapshot & snapshot, const wchar_t * (&file_name_list)[n_file_names])
+    : snapshot(snapshot), process_names(file_name_list), filter(process_names)
   {
     update() ;
   }
-  template <size_t n_file_names>
-  Process_Closer(Process_Snapshot & snapshot, const wchar_t * (&file_name_list)[n_file_names])
-    : snapshot(snapshot), process_names(file_name_list), module_names(), filter(process_names, module_names)
-  {
-    update() ;
-  }
 
   /**
    * Refresh our state to match the snapshot state.
    */
   void refresh()
   {
     pid_set.clear() ;
     update() ;
   }
 
   bool is_running() { return ! pid_set.empty() ; } ;
 
   bool contains( DWORD pid ) const { return pid_set.find( pid ) != pid_set.end() ; } ;
 
   template< class F >
   bool iterate_our_windows( F f )
   {
     only_our_processes< F > g( * this, f ) ;
     return enumerate_windows( g ) ;
   }
 
   /*
    * Shut down every process in the pid_set.
    */
   bool shut_down() ;
 
 } ;
 
 #endif