Combine snapshot classes into a template class

installer/src/installer-lib/process.cpp

 #include <stdexcept>
 #include <functional>
 #include <wctype.h>
 // <thread> is C++11, but implemented in VS2012
 #include <thread>
 
 #include "installer-lib.h"
 #include "process.h"
 
 //-------------------------------------------------------
 //-------------------------------------------------------
 bool process_by_any_exe_with_any_module::operator()( const PROCESSENTRY32W & process )
 {
   if (processNames.find(process.szExeFile) != processNames.end())
   {
     if (moduleNames.empty())
       return true;
 
-    ModulesSnapshot ms(process.th32ProcessID);
-    MODULEENTRY32W* me = ms.first();
-    while (me != NULL)
+    Module_Snapshot ms(process.th32ProcessID);
+    const MODULEENTRY32W* me = ms.first();
+    while (me != 0)
     {
       if (moduleNames.find(me->szModule) != moduleNames.end())
       {
         return true;
       }
       me = ms.next();
     }
   }
   return false;
 }
 
 //-------------------------------------------------------
 // creator_process
 //-------------------------------------------------------
 DWORD creator_process( HWND window )
 {
   DWORD pid ;
   DWORD r = GetWindowThreadProcessId( window, & pid ) ;
   if ( r == 0 )
   {
     // Assert GetWindowThreadProcessId returned an error
     // If the window handle is invalid, we end up here.
     throw windows_api_error( "GetWindowThreadProcessId", r ) ;
   }
   return pid ;
 }
 
 //-------------------------------------------------------
-// Snapshot
-//-------------------------------------------------------
-Snapshot::Snapshot()
-  : handle( ::CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 ) )
-{
-  process.dwSize = sizeof( PROCESSENTRY32W ) ;
-}
-
-PROCESSENTRY32W * Snapshot::first()
-{
-  return ::Process32FirstW(handle, &process) ? (&process) : 0;
-}
-
-PROCESSENTRY32W * Snapshot::next()
-{
-  return ::Process32NextW(handle, &process) ? (&process) : 0;
-}
-
-void Snapshot::refresh()
-{
-  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
 
 /**
  * An function object to process the results of sending window messages in send_message.
  *
  * We are using send_message within a system iteration over windows.
  * The system has its own convention for continuing/breaking the iteration.
  * This convention is assured consistently in send_message, which also provides default behavior.
  * This class provides the base for any variation from the default behavior.
  */
 struct message_accumulator
-  : public std::binary_function< DWORD_PTR, BOOL, bool >
+  : public std::binary_function< DWORD_PTR, bool, bool >
 {
   virtual result_type operator()( first_argument_type result, second_argument_type return_value ) = 0 ;
   virtual ~message_accumulator() {} ;
 } ;
 
 /**
  * Iteration action to send a message to a window and accumulate results.
  *
  * An error sending the message is not a failure for the function a whole.
  * The goal is to close the process, and if the window is no longer present, then the process may have already closed.
@@ skipping 21 matching lines @@
   send_message( UINT message, WPARAM p1, LPARAM p2 )
     : message( message ), p1( p1 ), p2( p2 ), f( 0 )
   {}
 
   /*
    * Enumeration function applied to each window.
    */
   bool operator()( HWND window )
   {
     DWORD_PTR result ;
-    BOOL rv = SendMessageTimeoutW( window, message, p1, p2, SMTO_BLOCK, timeout, & result ) ;
+    LRESULT rv = SendMessageTimeoutW( window, message, p1, p2, SMTO_BLOCK, timeout, & result ) ;
     /*
      * If we have no message accumulator, the default behavior is to iterate everything.
      * If we do have one, we delegate to it the decision whether to break or to continue.
      */
     if ( ! f )
     {
       return true ;
     }
-    return ( * f )( result, rv ) ;
+    return ( * f )( result, (rv != 0) ) ;
   }
 } ;
 
 /**
  * Send WM_QUERYENDSESSION and WM_ENDSESSION to a window.
  *
  * This window processor tries to shut down each application individually.
  * The alternative, gathering all the query results first and only then ending sessions, cannot be done with a single window enumeration.
  */
 class send_endsession_messages
@@ skipping 34 matching lines @@
  * As usual, errors sending messages are ignored.
  */
 struct endsession_accumulator :
   public message_accumulator
 {
   bool permit_end_session ; ///< Accumulator variable yields final result.
 
   /**
    * Enumeration function applied to each window.
    */
-  bool operator()( DWORD_PTR result, BOOL return_value )
+  bool operator()( DWORD_PTR result, bool return_value )
   {
     if ( ( ! return_value ) || result )
     {
       // 1. If the result is true, then the process will permit WM_ENDSESSION
       // 2. An error sending the message counts as "no new information"
       return true ;
     }
     // The first false is the result of the calculation.
     // The second false means to terminate enumeration early.
     permit_end_session = false ;
@@ skipping 107 matching lines @@
       if ( ! is_running() )
       {
         return true ;
       }
     }
     // Assert is_running()
   }
   // No control path leaves the for-loop.
 } ;