Use internal function in onlyOwner, onlyAuthorized, and nonReentrant modifiers

contracts/utils/contracts/src/Authorizable.sol

@@ -30,9 +30,7 @@ contract Authorizable is
 {
     /// @dev Only authorized addresses can invoke functions with this modifier.
     modifier onlyAuthorized {
-        if (!authorized[msg.sender]) {
+        _assertSenderIsAuthorized();
-            LibRichErrors.rrevert(LibAuthorizableRichErrors.SenderNotAuthorizedError(msg.sender));
-        }
         _;
     }
 
@@ -122,4 +120,14 @@ contract Authorizable is
     {
         return authorities;
     }
+
+    /// @dev Reverts if msg.sender is not authorized.
+    function _assertSenderIsAuthorized()
+        internal
+        view
+    {
+        if (!authorized[msg.sender]) {
+            LibRichErrors.rrevert(LibAuthorizableRichErrors.SenderNotAuthorizedError(msg.sender));
+        }
+    }
 }

contracts/utils/contracts/src/Ownable.sol

@@ -17,12 +17,7 @@ contract Ownable is
     }
 
     modifier onlyOwner() {
-        if (msg.sender != owner) {
+        _assertSenderIsOwner();
-            LibRichErrors.rrevert(LibOwnableRichErrors.OnlyOwnerError(
-                msg.sender,
-                owner
-            ));
-        }
         _;
     }
 
@@ -36,4 +31,16 @@ contract Ownable is
             owner = newOwner;
         }
     }
+
+    function _assertSenderIsOwner()
+        internal
+        view
+    {
+        if (msg.sender != owner) {
+            LibRichErrors.rrevert(LibOwnableRichErrors.OnlyOwnerError(
+                msg.sender,
+                owner
+            ));
+        }
+    }
 }

contracts/utils/contracts/src/ReentrancyGuard.sol

@@ -30,20 +30,28 @@ contract ReentrancyGuard {
     /// @dev Functions with this modifer cannot be reentered. The mutex will be locked
     ///      before function execution and unlocked after.
     modifier nonReentrant() {
+        _lockMutexOrThrowIfAlreadyLocked();
+        _;
+        _unlockMutex();
+    }
+
+    function _lockMutexOrThrowIfAlreadyLocked()
+        internal
+    {
         // Ensure mutex is unlocked.
         if (locked) {
             LibRichErrors.rrevert(
                 LibReentrancyGuardRichErrors.IllegalReentrancyError()
             );
         }
-
+        // Lock mutex.
-        // Lock mutex before function call
         locked = true;
+    }
 
-        // Perform function call
+    function _unlockMutex()
-        _;
+        internal
-
+    {
-        // Unlock mutex after function call
+        // Unlock mutex.
         locked = false;
     }
 }