Issue #1186 - Change names that appear in the custom action

installer/src/custom-action/close_application.cpp

 /**
  * \file close_application.cpp
  */
 
 #include <algorithm>
 
 #include "session.h"
 #include "property.h"
 #include "database.h"
 #include "process.h"
@@ skipping 11 matching lines @@
 
   ProcessCloser browserCloser ;
 
   ProcessCloser engineCloser ;
 
 public:
   InternetExplorerCloser()
     : snapshot(), browserCloser( snapshot, browserNames ), engineCloser( snapshot, engineNames )
   {}
 
-  void refresh()
+  void Refresh()
   {
-    snapshot.refresh() ;
-    browserCloser.refresh() ;
-    engineCloser.refresh() ;
-  }
-
-  bool isRunning()

[Felix Dahlke, 2014/10/15 02:46:57]

Functions should start with an upper case letter.

[Eric, 2014/10/15 15:30:44]

Missed that one, apparently.

+    snapshot.Refresh() ;
+    browserCloser.Refresh() ;
+    engineCloser.Refresh() ;
+  }
+
+  bool IsRunning()
   {
-    return browserCloser.isRunning() || engineCloser.isRunning() ;
-  }
-
-  bool shutDown()
+    return browserCloser.IsRunning() || engineCloser.IsRunning() ;
+  }
+
+  bool ShutDown()
   {
-    if ( browserCloser.isRunning() && ! browserCloser.shutDown() )
+    if ( browserCloser.IsRunning() && ! browserCloser.ShutDown() )
     {
       // Assert IE is still running
       // This is after we've tried to shut it down, so we fail
       return false ;
     }
-    if ( engineCloser.isRunning() && ! engineCloser.shutDown() )
+    if ( engineCloser.IsRunning() && ! engineCloser.ShutDown() )
     {
       // Assert the engine is still running
       // This is after IE has shut down itself and after we've tried to shut down the engine. Whatever.
       return false ;
     }
     return true ;
   }
 } ;
 
 
@@ skipping 61 matching lines @@
     // MSI property BROWSERRUNNING is one of the return values of this function.
     Property browserRunning( session, L"BROWSERRUNNING" ) ;
     Property browserClosed( session, L"BROWSERCLOSED" ) ;
 
     // Instantiation of ProcessCloser takes a snapshot.
     InternetExplorerCloser iec ;
 
     /*
      * We take the short path through this function if neither IE nor engine is not running at the outset.
      */
-    if ( ! iec.isRunning() )
+    if ( ! iec.IsRunning() )
     {
       browserRunning = L"0" ;       // The browser is not running.
       browserClosed = L"0" ;        // We didn't close the browser (and we couldn't have).
-      session.log( "IE not running. No issue with reboot policy." ) ;
+      session.Log( "IE not running. No issue with reboot policy." ) ;
       return ERROR_SUCCESS ;
     }
 
     /*
      * As a (potentially) user-driven function, a state machine manages control flow.
      * The states are organized around the policy stances.
      */
     enum PolicyState {
       // Non-terminal states
       notKnown,   // We don't know the user's stance at all
@@ skipping 15 matching lines @@
      */
     std::wstring avoidReboot = Property( session, L"AVOIDREBOOT" ) ;
     std::transform( avoidReboot.begin(), avoidReboot.end(), avoidReboot.begin(), ::towupper ) ;
     if ( avoidReboot == L"" )
     {
       state = notKnown ;
     }
     else if ( avoidReboot == L"NO" )
     {
       state = allow ;
-      session.log( "Reboot allowed on command line." ) ;
+      session.Log( "Reboot allowed on command line." ) ;
     }
     else if ( avoidReboot == L"PASSIVE" )
     {
       state = passive ;
-      session.log( "Reboot avoided on command line." ) ;
+      session.Log( "Reboot avoided on command line." ) ;
     }
     else if ( avoidReboot == L"ACTIVE" )
     {
       state = active ;
     }
     else if ( avoidReboot == L"AUTOMATIC" )
     {
       state = automatic ;
     }
     else
@@ skipping 26 matching lines @@
       // Assert installer is running without user interaction.
       interactive = false ;
       if ( state == notKnown )
       {
         // Assert AVOIDREBOOT was not specified
         /*
          * This is where we specify default behavior for non-interactive operation.
          * The choice of "allow" makes it act like other installers, which is to make no effort to avoid a reboot after installation.
          */
         state = allow ;
-        session.log( "Reboot allowed by default in non-interactive session." ) ;
+        session.Log( "Reboot allowed by default in non-interactive session." ) ;
       }
       else if ( state == active )
       {
         throw std::runtime_error( "AVOIDREBOOT=ACTIVE in non-interative session is not consistent" ) ;
       }
       // Assert state is one of { allow, passive, automatic }
     }
     else
     {
       throw std::runtime_error( "unrecognized value for UILevel" ) ;
     }
 
     /*
      * Now that preliminaries are over, we set up the accessors for UI text.
      * We only use the object 'messageText' for interactive sessions, but it's cheap to set up and a hassle to conditionalize.
      *
      * The key "close_ie" is the component name within the file "close_ie.wxi" that defines rows in the localization table.
      * The identifiers for the messageText.text() function are defined within that file.
      */
     InstallationDatabase db( session ) ;
     CustomMessageText messageText( db, L"close_ie" ) ;
 
     /*
      * State machine: Loop through non-terminal states.
      *
-     * Loop invariant: IE was running at last check, that is, iec.isRunning() would return true.
+     * Loop invariant: IE was running at last check, that is, iec.IsRunning() would return true.
      */
     while ( state <= automatic )          // "automatic" is the non-terminal state with the highest value
     {
       switch ( state )
       {
       case notKnown:
         /*
          * Precondition: interactive session
          *
          * Ask the user "Would you like to close IE and avoid reboot?"
          * Yes -> Close IE somehow. Goto partKnown.
          * No -> Install with reboot. Goto allow.
          * Cancel -> terminate installation. Goto abort.
          */
-        {
-          int x = session.WriteMessage( IMB( messageText.text( L"dialog_unknown" ), IMB::warningBox, IMB::yesNoCancel, IMB::defaultButtonThree ) ) ;
+        {
+          int x = session.WriteMessage(IMB( 
+            messageText.Text(L"dialog_unknown"), 
+            IMB::Box::warning, IMB::ButtonSet::yesNoCancel, IMB::DefaultButton::three
+            )) ;
           switch ( x )
           {
           case IDYES:
             state = partKnown ;
             break ;
           case IDNO:
             state = allow ;
-            session.log( "User chose to allow reboot" ) ;
+            session.Log( "User chose to allow reboot" ) ;
             break ;
           case IDCANCEL:
             state = abort ;
-            session.log( "User cancelled installation" ) ;
+            session.Log( "User cancelled installation" ) ;
             break ;
           default:
             throw UnexpectedReturnValueFromMessageBox() ;
           }
         }
         break ;
 
       case partKnown:
         /*
          * Precondition: interactive session
          *
          * Ask the user "Would you like the installer to close IE for you?"
          * Yes -> Goto automatic
          * No -> Goto active
          * Cancel -> Goto notKnown
          */
         {
-          int x = session.WriteMessage( IMB( messageText.text( L"dialog_part_known" ), IMB::warningBox, IMB::yesNoCancel, IMB::defaultButtonThree ) ) ;
+          int x = session.WriteMessage(IMB(
+            messageText.Text(L"dialog_part_known"), 
+            IMB::Box::warning, IMB::ButtonSet::yesNoCancel, IMB::DefaultButton::three
+            )) ;
           switch ( x )
           {
           case IDYES:
             state = automatic ;
             break ;
           case IDNO:
             state = active ;
             break ;
           case IDCANCEL:
             state = notKnown ;
             break ;
           default:
             throw UnexpectedReturnValueFromMessageBox() ;
           }
         }
         break ;
 
       case active:
         /*
          * Precondition: interactive session
          *
          * IE is no longer running -> Goto success
          * IE is still running ->
          *   Ask the user to close IE manually
          *   OK -> re-enter this state
          *   Cancel -> Goto notKnown
          */
         {
-          int x = session.WriteMessage( IMB( messageText.text( L"dialog_active_retry" ), IMB::warningBox, IMB::okCancel, IMB::defaultButtonOne ) ) ;
+          int x = session.WriteMessage(IMB(
+            messageText.Text(L"dialog_active_retry"), 
+            IMB::Box::warning, IMB::ButtonSet::okCancel, IMB::DefaultButton::one
+            )) ;
           switch ( x )
           {
           case IDOK:
             /*
              * Refresh our knowledge of whether IE is running.
              * If it is, we display the dialog again. The state doesn't change, so we just iterate again.
              * If it's not, then the user has closed IE and we're done.
              */
-            iec.refresh() ;
-            if ( ! iec.isRunning() )
+            iec.Refresh() ;
+            if ( ! iec.IsRunning() )
             {
               state = success ;
-              session.log( "User shut down IE manually." ) ;
+              session.Log( "User shut down IE manually." ) ;
             }
             break ;
           case IDCANCEL:
             state = notKnown ;
             break ;
           default:
             throw UnexpectedReturnValueFromMessageBox() ;
           }
         }
         break ;
 
       case automatic:
         /*
          * Close all known IE instances.
          * Unlike other cases, this state starts with an action and not a user query.
          * We first shut down IE, or at least attempt to.
          *
          * Succeeded -> Goto success
          * Failed && interactive ->
          *   Ask user if they would like to try again
          *   Retry -> re-enter this state
          *   Cancel -> Goto notKnown
          * Failed && not interactive -> Goto abort
          */
         {
-          bool ieWasClosed = iec.shutDown() ;
-          if ( iec.isRunning() )
+          bool ieWasClosed = iec.ShutDown() ;
+          if ( iec.IsRunning() )
           {
-            session.log( "Attempt to shut down IE automatically failed." ) ;
+            session.Log( "Attempt to shut down IE automatically failed." ) ;
             if ( interactive )
             {
               // Assert Interactive session and IE did not shut down.
-              int x = session.WriteMessage( IMB( messageText.text( L"dialog_automatic_retry" ), IMB::warningBox, IMB::retryCancel, IMB::defaultButtonOne ) ) ;
+              int x = session.WriteMessage(IMB(
+                messageText.Text(L"dialog_automatic_retry"),
+                IMB::Box::warning, IMB::ButtonSet::retryCancel, IMB::DefaultButton::one
+                )) ;
               switch ( x )
               {
               case IDRETRY:
                 // Don't change the state. Iterate again.
                 break ;
               case IDCANCEL:
                 state = notKnown ;
                 break ;
               default:
                 throw UnexpectedReturnValueFromMessageBox() ;
               }
             }
             else
             {
               // Assert Non-interactive session and IE did not shut down.
               state = abort ;
-              session.log( "Failed to shut down IE automatically." ) ;
+              session.Log( "Failed to shut down IE automatically." ) ;
             }
           }
           else
           {
-            // Assert IE is not running, so shutDown() succeeded.
+            // Assert IE is not running, so ShutDown() succeeded.
             state = success ;
-            session.log( "Automatically shut down IE." ) ;
+            session.Log( "Automatically shut down IE." ) ;
           }
         }
         break;
       }
     }
     /*
      * State machine: Actions for terminal states.
      */
     switch ( state )
     {
       case success:
-        if ( iec.isRunning() )
+        if ( iec.IsRunning() )
         {
           browserRunning = L"1" ;
           browserClosed = L"0" ;
         }
         else
         {
           browserRunning = L"0" ;
           browserClosed = L"1" ;
         }
         return ERROR_SUCCESS ;
         break;
       case abort:
         return ERROR_INSTALL_USEREXIT ;
         break;
     }
   }
   catch( std::exception & e )
   {
     session.LogNoexcept( "terminated by exception: " + std::string( e.what() ) ) ;
     return ERROR_INSTALL_FAILURE ;
   }
   catch( ... )
   {
     session.LogNoexcept( "terminated by unknown exception" ) ;
     return ERROR_INSTALL_FAILURE ;
   }
   // Should be unreachable.
   return ERROR_INSTALL_FAILURE ;
 }