1 files changed, 25 insertions, 25 deletions

diff --git a/src/mongo/db/operation_context.h b/src/mongo/db/operation_context.h
index 2c8be360a77..15688438561 100644
--- a/src/mongo/db/operation_context.h
+++ b/src/mongo/db/operation_context.h
@@ -425,47 +425,47 @@ class WriteUnitOfWork {
     MONGO_DISALLOW_COPYING(WriteUnitOfWork);
 
 public:
-    WriteUnitOfWork(OperationContext* txn)
-        : _txn(txn),
+    WriteUnitOfWork(OperationContext* opCtx)
+        : _opCtx(opCtx),
           _committed(false),
-          _toplevel(txn->_ruState == OperationContext::kNotInUnitOfWork) {
+          _toplevel(opCtx->_ruState == OperationContext::kNotInUnitOfWork) {
         uassert(ErrorCodes::IllegalOperation,
                 "Cannot execute a write operation in read-only mode",
                 !storageGlobalParams.readOnly);
-        _txn->lockState()->beginWriteUnitOfWork();
+        _opCtx->lockState()->beginWriteUnitOfWork();
         if (_toplevel) {
-            _txn->recoveryUnit()->beginUnitOfWork(_txn);
-            _txn->_ruState = OperationContext::kActiveUnitOfWork;
+            _opCtx->recoveryUnit()->beginUnitOfWork(_opCtx);
+            _opCtx->_ruState = OperationContext::kActiveUnitOfWork;
         }
     }
 
     ~WriteUnitOfWork() {
         dassert(!storageGlobalParams.readOnly);
         if (!_committed) {
-            invariant(_txn->_ruState != OperationContext::kNotInUnitOfWork);
+            invariant(_opCtx->_ruState != OperationContext::kNotInUnitOfWork);
             if (_toplevel) {
-                _txn->recoveryUnit()->abortUnitOfWork();
-                _txn->_ruState = OperationContext::kNotInUnitOfWork;
+                _opCtx->recoveryUnit()->abortUnitOfWork();
+                _opCtx->_ruState = OperationContext::kNotInUnitOfWork;
             } else {
-                _txn->_ruState = OperationContext::kFailedUnitOfWork;
+                _opCtx->_ruState = OperationContext::kFailedUnitOfWork;
             }
-            _txn->lockState()->endWriteUnitOfWork();
+            _opCtx->lockState()->endWriteUnitOfWork();
         }
     }
 
     void commit() {
         invariant(!_committed);
-        invariant(_txn->_ruState == OperationContext::kActiveUnitOfWork);
+        invariant(_opCtx->_ruState == OperationContext::kActiveUnitOfWork);
         if (_toplevel) {
-            _txn->recoveryUnit()->commitUnitOfWork();
-            _txn->_ruState = OperationContext::kNotInUnitOfWork;
+            _opCtx->recoveryUnit()->commitUnitOfWork();
+            _opCtx->_ruState = OperationContext::kNotInUnitOfWork;
         }
-        _txn->lockState()->endWriteUnitOfWork();
+        _opCtx->lockState()->endWriteUnitOfWork();
         _committed = true;
     }
 
 private:
-    OperationContext* const _txn;
+    OperationContext* const _opCtx;
 
     bool _committed;
     bool _toplevel;
@@ -490,16 +490,16 @@ public:
      * only read (MODE_IS), or needs to run without other writers (MODE_S) or any other
      * operations (MODE_X) on the server.
      */
-    ScopedTransaction(OperationContext* txn, LockMode mode) : _txn(txn) {}
+    ScopedTransaction(OperationContext* opCtx, LockMode mode) : _opCtx(opCtx) {}
 
     ~ScopedTransaction() {
-        if (!_txn->lockState()->isLocked()) {
-            _txn->recoveryUnit()->abandonSnapshot();
+        if (!_opCtx->lockState()->isLocked()) {
+            _opCtx->recoveryUnit()->abandonSnapshot();
         }
     }
 
 private:
-    OperationContext* _txn;
+    OperationContext* _opCtx;
 };
 
 namespace repl {
@@ -511,17 +511,17 @@ class UnreplicatedWritesBlock {
     MONGO_DISALLOW_COPYING(UnreplicatedWritesBlock);
 
 public:
-    UnreplicatedWritesBlock(OperationContext* txn)
-        : _txn(txn), _shouldReplicateWrites(txn->writesAreReplicated()) {
-        txn->setReplicatedWrites(false);
+    UnreplicatedWritesBlock(OperationContext* opCtx)
+        : _opCtx(opCtx), _shouldReplicateWrites(opCtx->writesAreReplicated()) {
+        opCtx->setReplicatedWrites(false);
     }
 
     ~UnreplicatedWritesBlock() {
-        _txn->setReplicatedWrites(_shouldReplicateWrites);
+        _opCtx->setReplicatedWrites(_shouldReplicateWrites);
     }
 
 private:
-    OperationContext* _txn;
+    OperationContext* _opCtx;
     const bool _shouldReplicateWrites;
 };
 }  // namespace repl