Issue #1186 - Change names that appear in the 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 84 matching lines @@
  * Filter by process name. Comparison is case-insensitive. Windows Store app processes excluded
  */
 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,
+   * The set used to instantiate this class is a member of ProcessCloser,
    *   and so also is this class.
    * Hence the lifetimes are coterminous, and the reference is not problematic.
    */
   const file_name_set & processNames;
 public:
   bool operator()( const PROCESSENTRY32W & );
   process_by_any_exe_not_immersive(const file_name_set & names) : processNames( names ) {}
 } ;
 
 
@@ skipping 204 matching lines @@
     buffer.dwSize = sizeof( result_type ) ;
   }
 
 public:
   /**
    * Reconstruct the current instance with a new system snapshot.
    *
    * This function uses reinitialization assignment in the Windows_Handle class,
    *   which takes care of closing the old handle.
    */
-  void refresh()
+  void Refresh()
   {
     handle = make_handle();
   }
 
   /**
    * Retrieve the first snapshot item into our member buffer.
    *
    * \return
    *   Pointer to our member buffer if there was a first item
    *   0 otherwise
@@ skipping 25 matching lines @@
    */
   const result_type * next()
   {
     return Traits::next(handle, &buffer) ? &buffer : 0;
   }
 } ;
 
 /**
  * A snapshot of all processes running on the system.
  */
-struct Process_Snapshot
+struct ProcessSnapshot
   : public Snapshot< Process_Snapshot_Traits >
 {
-  Process_Snapshot()
+  ProcessSnapshot()
     : Snapshot( 0 ) 
   {}
 } ;
 
 /**
  * A snapshot of all modules loaded for a given process.
  */
 struct Module_Snapshot
   : public Snapshot< Module_Snapshot_Traits >
 {
   Module_Snapshot( DWORD process_id )
     : Snapshot( process_id )
   {}
 } ;
 
 //-------------------------------------------------------
 // initialize_process_list
 //-------------------------------------------------------
 /**
  * \tparam T The type into which a PROCESSENTRY32W struture is extracted.
  * \tparam Admittance Function type for argument 'admit'
  * \tparam Extractor Function type for argument 'extract'
  * \param admit A unary predicate function class that determines what's included
  *      A process appears in the list only if the predicate returns true. 
  *      The use of this predicate is analogous to that in std::copy_if.
  * \param convert A conversion function that takes a PROCESSENTRY32W as input argument and returns an element of type T.
  */
 template<class T, class Admittance, class Extractor>
-void initialize_process_list(std::vector<T>& v, Process_Snapshot &snap, Admittance admit = Admittance(), Extractor extract = Extractor())
+void initialize_process_list(std::vector<T>& v, ProcessSnapshot &snap, Admittance admit = Admittance(), Extractor extract = Extractor())
 {
   const PROCESSENTRY32W* p = snap.first();
   while (p != 0)
   {
     if (admit(*p ))
     {
       /*
         * We don't have C++11 emplace_back, which can construct the element in place.
         * Instead, we copy the return value of the converter.
         */
       v.push_back(extract(*p));
     }
     p = snap.next();
   }
 };
 
 //-------------------------------------------------------
 // initialize_process_set
 //-------------------------------------------------------
 /**
  * \tparam T The type into which a PROCESSENTRY32W struture is extracted.
  * \tparam Admittance Function type for argument 'admit'
  * \tparam Extractor Function type for argument 'extract'
  * \param admit A unary predicate function class that determines what's included
  *      A process appears in the list only if the predicate returns true. 
  *      The use of this predicate is analogous to that in std::copy_if.
  * \param convert A conversion function that takes a PROCESSENTRY32W as input argument and returns an element of type T.
  */
 template<class T, class Admittance, class Extractor>
-void initialize_process_set(std::set< T > & set, Process_Snapshot &snap, Admittance admit = Admittance(), Extractor extract = Extractor())
+void initialize_process_set(std::set< T > & set, ProcessSnapshot &snap, Admittance admit = Admittance(), Extractor extract = Extractor())
 {
   const PROCESSENTRY32W* p = snap.first();
   while (p != 0)
   {
     if (admit(*p))
     {
       set.insert(extract(*p));
     }
     p = snap.next();
   }
@@ skipping 132 matching lines @@
     {
       // Assert EnumWindows failed
       data.status = error ;
       r = false ;
     }
   }
   return r ;
 }
 
 //-------------------------------------------------------
-// Process_Closer
+// ProcessCloser
 //-------------------------------------------------------
-class Process_Closer
+class ProcessCloser
 {
   /**
    * Set of process identifiers matching one of the executable names.
    */
   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 ;
 
   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 ;
+  ProcessSnapshot & snapshot ;
 
   void update()
   {
     initialize_process_set( pid_set, snapshot, filter, copy ) ;
   } ;
 
   template< class F >
   class only_our_processes
   {
-    Process_Closer & self ;
+    ProcessCloser & self ;
 
     F f ;
 
   public:
-    only_our_processes( Process_Closer & self, F f )
+    only_our_processes( ProcessCloser & self, F f )
       : f( f ), self( self )
     {}
 
     bool operator()( HWND window )
     {
       bool b ;
       try
       {
         b = self.contains( creator_process( window ) ) ;
       }
       catch ( ... )
       {
         // ignore window handles that are no longer valid
         return true ;
       }
       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>
-  Process_Closer(Process_Snapshot & snapshot, const wchar_t * (&file_name_list)[n_file_names])
+  ProcessCloser(ProcessSnapshot & snapshot, const wchar_t * (&file_name_list)[n_file_names])
     : snapshot(snapshot), process_names(file_name_list), filter(process_names)
   {
     update() ;
   }
 
   /**
    * Refresh our state to match the snapshot state.
    */
-  void refresh()
+  void Refresh()
   {
     pid_set.clear() ;
     update() ;
   }
 
-  bool is_running() { return ! pid_set.empty() ; } ;
+  bool IsRunning() { 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() ;
+  bool ShutDown() ;
 
 } ;
 
 #endif