Issue #1185 - Fix formatting in installer-lib and its tests

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"
 #include "handle.h"
 #include "session.h"
 
 //-------------------------------------------------------
 //-------------------------------------------------------
-typedef int (__stdcall *IsImmersiveDynamicFunc)(HANDLE);
-bool ProcessByAnyExeNotImmersive::operator()( const PROCESSENTRY32W & process )
+typedef int (__stdcall* IsImmersiveDynamicFunc)(HANDLE);
+bool ProcessByAnyExeNotImmersive::operator()(const PROCESSENTRY32W& process)
 {
   // If the name is not found in our list, it's filtered out
-  if (processNames.find(process.szExeFile) == processNames.end()) return false;
+  if (processNames.find(process.szExeFile) == processNames.end())
+  {
+    return false;
+  }
 
   // Make sure the process is still alive
   HANDLE tmpHandle = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, process.th32ProcessID);
-  if (tmpHandle == NULL) return false;
+  if (tmpHandle == NULL)
+  {
+    return false;
+  }
   WindowsHandle procHandle(tmpHandle);
   DWORD exitCode;
-  if (!GetExitCodeProcess(procHandle, &exitCode)) return false;
-  if (exitCode != STILL_ACTIVE) return false;
+  if (!GetExitCodeProcess(procHandle, &exitCode))
+  {
+    return false;
+  }
+  if (exitCode != STILL_ACTIVE)
+  {
+    return false;
+  }
 
   // Check if this is a Windows Store app process (we don't care for IE in Modern UI)
   HMODULE user32Dll = LoadLibrary(L"user32.dll");
-  if (!user32Dll) return true;
+  if (!user32Dll)
+  {
+    return true;
+  }
   IsImmersiveDynamicFunc IsImmersiveDynamicCall = (IsImmersiveDynamicFunc)GetProcAddress(user32Dll, "IsImmersiveProcess");
-  if (!IsImmersiveDynamicCall) return true;
+  if (!IsImmersiveDynamicCall)
+  {
+    return true;
+  }
   return !IsImmersiveDynamicCall(procHandle);
 }
 
 //-------------------------------------------------------
 // CreatorProcess
 //-------------------------------------------------------
-DWORD CreatorProcess( HWND window )
+DWORD CreatorProcess(HWND window)
 {
-  DWORD pid ;
-  DWORD r = GetWindowThreadProcessId( window, & pid ) ;
-  if ( r == 0 )
+  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 WindowsApiError( "GetWindowThreadProcessId", r ) ;
+    throw WindowsApiError("GetWindowThreadProcessId", r);
   }
-  return pid ;
+  return pid;
 }
 
 //-------------------------------------------------------
 // SendMessageAction, SendEndsessionMessagesAction
 //-------------------------------------------------------
 /**
 * 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 SendMessageAction.
 *
 * We are using SendMessageAction within a system iteration over windows.
 * The system has its own convention for continuing/breaking the iteration.
 * This convention is assured consistently in SendMessageAction, which also provides default behavior.
 * This class provides the base for any variation from the default behavior.
 */
 struct MessageAccumulator
-  : 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 returnValue ) = 0 ;
-  virtual ~MessageAccumulator() {} ;
-} ;
+  virtual result_type operator()(first_argument_type result, second_argument_type returnValue) = 0;
+  virtual ~MessageAccumulator() {};
+};
 
 /**
 * 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.
 * Therefore, we're ignoring both the return value and the result.
 */
 class SendMessageAction
 {
-  UINT message ;                ///< Message type for windows message
-  WPARAM p1 ;                   ///< Generic parameter 1 for windows message
-  LPARAM p2 ;                   ///< Generic parameter 2 for windows message
-  MessageAccumulator * f ;      ///< Processor for results of sending the message.
+  UINT message ;            ///< Message type for windows message
+  WPARAM p1 ;               ///< Generic parameter 1 for windows message
+  LPARAM p2 ;               ///< Generic parameter 2 for windows message
+  MessageAccumulator* f ;   ///< Processor for results of sending the message.
 
 public:
   /**
   * Full contructor gathers message parameters and a message accumulator.
   */
-  SendMessageAction( UINT message, WPARAM p1, LPARAM p2, MessageAccumulator & f )
-    : message( message ), p1( p1 ), p2( p2 ), f( & f )
+  SendMessageAction(UINT message, WPARAM p1, LPARAM p2, MessageAccumulator& f)
+    : message(message), p1(p1), p2(p2), f(& f)
   {}
 
   /**
   * Abbreviated contructor gathers only message parameters.
   * The message accumulator is absent.
   */
-  SendMessageAction( UINT message, WPARAM p1, LPARAM p2 )
-    : message( message ), p1( p1 ), p2( p2 ), f( 0 )
+  SendMessageAction(UINT message, WPARAM p1, LPARAM p2)
+    : message(message), p1(p1), p2(p2), f(0)
   {}
 
   /*
   * Enumeration function applied to each window.
   */
-  bool operator()( HWND window )
+  bool operator()(HWND window)
   {
-    DWORD_PTR result ;
-    LRESULT rv = SendMessageTimeoutW( window, message, p1, p2, SMTO_BLOCK, timeout, & result ) ;
+    DWORD_PTR 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 )
+    if (! f)
     {
-      return true ;
+      return true;
     }
-    return ( * f )( result, (rv != 0) ) ;
+    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 SendEndsessionMessagesAction
 {
 public:
   /*
   * Enumeration function applied to each window.
   */
-  bool operator()( HWND window )
+  bool operator()(HWND window)
   {
-    DWORD_PTR result ;
-    if ( ! SendMessageTimeoutW( window, WM_QUERYENDSESSION, 0, ENDSESSION_CLOSEAPP, SMTO_BLOCK, timeout, & result ) )
+    DWORD_PTR result;
+    if (! SendMessageTimeoutW(window, WM_QUERYENDSESSION, 0, ENDSESSION_CLOSEAPP, SMTO_BLOCK, timeout, & result))
     {
       // Assert sending the message failed
       // Ignore failure, just as with SendMessageAction().
-      return true ;
+      return true;
     }
     // Assert result is FALSE if the process has refused notice that it should shut down.
-    if ( ! result )
+    if (! result)
     {
       /*
       * Returning false terminates iteration over windows.
       * Since this process is refusing to shut down, we can't close all the processes and the operation fails.
       */
-      return false ;
+      return false;
     }
-    SendMessageTimeoutW( window, WM_ENDSESSION, 0, ENDSESSION_CLOSEAPP, SMTO_BLOCK, timeout, 0 ) ;
-    return true ;
+    SendMessageTimeoutW(window, WM_ENDSESSION, 0, ENDSESSION_CLOSEAPP, SMTO_BLOCK, timeout, 0);
+    return true;
   }
-} ;
+};
 
 /**
 * Accumulator for query-endsession message.
 *
 * Implements a conditional-conjunction of the query results.
 * All answers must be true in order for this result to be true,
 *   and the calculation is terminated at the first answer 'false'.
 * As usual, errors sending messages are ignored.
 */
 struct EndsessionAccumulator :
   public MessageAccumulator
 {
   bool permitEndSession ; ///< Accumulator variable yields final result.
 
   /**
   * Enumeration function applied to each window.
   */
-  bool operator()( DWORD_PTR result, bool returnValue )
+  bool operator()(DWORD_PTR result, bool returnValue)
   {
-    if ( ( ! returnValue ) || result )
+    if ((! returnValue) || 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 ;
+      return true;
     }
     // The first false is the result of the calculation.
     // The second false means to terminate enumeration early.
-    permitEndSession = false ;
-    return false ;
+    permitEndSession = false;
+    return false;
   }
 
   /**
   * Ordinary constructor.
   */
   EndsessionAccumulator()
-    : permitEndSession( true )
+    : permitEndSession(true)
   {}
-} ;
+};
 
 //-------------------------------------------------------
 // ProcessCloser
 //-------------------------------------------------------
 /**
 * Shut down all the processes in the pidSet.
 *
 * The method used here uses blocking system calls to send messages to target processes.
 * Message processing delays, therefore, are sequential and the total delay is their sum.
 * Windows has non-blocking message calls available, and using a multi-threaded implementation would shorten that delay.
 * The code, hwoever, is significantly simpler without multi-threading.
 * The present use of this method is not closing dozens of applications, so delay performance is not critical.
 *
 * \return
 *   The negation of IsRunning().
 *   If IsRunning() was true at the beginning, then this function will have run refresh() before returning.
 *
 * \sa
 *   - MSDN [WM_QUERYENDSESSION message](http://msdn.microsoft.com/en-us/library/windows/desktop/aa376890%28v=vs.85%29.aspx)
 *   - MSDN [WM_ENDSESSION message](http://msdn.microsoft.com/en-us/library/windows/desktop/aa376889%28v=vs.85%29.aspx)
 */
 bool ProcessCloser::ShutDown(ImmediateSession& session)
 {
   /*
   * If we're not running, we don't need to shut down.
   */
-  if ( ! IsRunning() )
+  if (! IsRunning())
   {
-    return true ;
+    return true;
   }
 
   /*
   * Shutting down is a structure as an escalating series of attempts to shut down.
   * After each one, we wait to see if the shut down has completed.
   * Even though we're using a blocking call to send messages, applications need not block before exiting.
   * Internet Explorer, in particular, does not.
   *
   * Note that termination occurs inside the default case within the switch statement
   */
-  for ( unsigned int stage = 1 ; ; ++ stage )
+  for (unsigned int stage = 1 ; ; ++ stage)
   {
     // Assert IsRunning()
-    switch( stage )
+    switch (stage)
     {
-    case 1 :
-      /*
-      * Send WM_QUERYENDSESSION to every admissible window.
-      * Send WM_ENDSESSION if all processes are ready to shut down.
-      * We try this technique first, since this allows an application to restore its application state when it starts up again.
-      */
+      case 1 :
       {
-        EndsessionAccumulator acc ;
-        SendMessageAction m1( WM_QUERYENDSESSION, 0, ENDSESSION_CLOSEAPP, acc ) ;
-        IterateOurWindows( m1 ) ;
+        /*
+        * Send WM_QUERYENDSESSION to every admissible window.
+        * Send WM_ENDSESSION if all processes are ready to shut down.
+        * We try this technique first, since this allows an application to restore its application state when it starts up again.
+        */
+        EndsessionAccumulator acc;
+        SendMessageAction m1(WM_QUERYENDSESSION, 0, ENDSESSION_CLOSEAPP, acc);
+        IterateOurWindows(m1);
 
-        if ( acc.permitEndSession )
+        if (acc.permitEndSession)
         {
-          SendMessageAction m2( WM_ENDSESSION, 0, ENDSESSION_CLOSEAPP ) ;
-          IterateOurWindows( m2 ) ;
+          SendMessageAction m2(WM_ENDSESSION, 0, ENDSESSION_CLOSEAPP);
+          IterateOurWindows(m2);
         }
       }
-      break ;
+      break;
 
-    case 2 :
+      case 2 :
       {
         /*
         * Send WM_QUERYENDSESSION and WM_ENDSESSION to every admissible window singly, not accumulating results.
         */
-        SendEndsessionMessagesAction m ;
-        IterateOurWindows( m ) ;
+        SendEndsessionMessagesAction m;
+        IterateOurWindows(m);
       }
-      break ;
+      break;
 
-    case 3 :
+      case 3 :
       {
         /*
         * Send WM_CLOSE to every admissible window.
         */
-        SendMessageAction m( WM_CLOSE, 0, 0 ) ;
-        IterateOurWindows( m ) ;
-      }
-      break ;
-
-    case 4:
-      /*
-      * Oh well. Take cover. It gets violent here. Try to kill all matching processes.
-      */
-      for (auto it = pidSet.begin(); it != pidSet.end(); ++it)
-      {
-        HANDLE tmpHandle = OpenProcess(PROCESS_TERMINATE, FALSE, *it);
-        if (!tmpHandle) 
-        {
-          std::ostringstream stream;
-          stream << "Can't open process for termination. Error: " << GetLastError();
-          session.Log(stream.str());
-          continue;
-        }
-        WindowsHandle procHandle(tmpHandle);
-        if (!TerminateProcess(tmpHandle, 0))
-        {
-          std::ostringstream stream;
-          stream << "Can't terminate process. Error: " << GetLastError();
-          session.Log(stream.str());
-        }
+        SendMessageAction m(WM_CLOSE, 0, 0);
+        IterateOurWindows(m);
       }
       break;
 
-    default:
-      // We're out of ways to try to shut down. 
-      return false;
+      case 4:
+        /*
+        * Oh well. Take cover. It gets violent here. Try to kill all matching processes.
+        */
+        for (auto it = pidSet.begin(); it != pidSet.end(); ++it)
+        {
+          HANDLE tmpHandle = OpenProcess(PROCESS_TERMINATE, FALSE, *it);
+          if (!tmpHandle)
+          {
+            std::ostringstream stream;
+            stream << "Can't open process for termination. Error: " << GetLastError();
+            session.Log(stream.str());
+            continue;
+          }
+          WindowsHandle procHandle(tmpHandle);
+          if (!TerminateProcess(tmpHandle, 0))
+          {
+            std::ostringstream stream;
+            stream << "Can't terminate process. Error: " << GetLastError();
+            session.Log(stream.str());
+          }
+        }
+        break;
+
+      default:
+        // We're out of ways to try to shut down.
+        return false;
     }
 
     /*
     * Wait loop.
     */
-    for ( unsigned int j = 0 ; j < 50 ; ++ j )
+    for (unsigned int j = 0 ; j < 50 ; ++ j)
     {
-      std::this_thread::sleep_for( std::chrono::milliseconds( 30 ) ) ;
-      Refresh() ;
-      if ( ! IsRunning() )
+      std::this_thread::sleep_for(std::chrono::milliseconds(30));
+      Refresh();
+      if (! IsRunning())
       {
-        return true ;
+        return true;
       }
     }
     // Assert IsRunning()
   }
   // No control path leaves the for-loop.
-} ;
+};