SERVER-27938 Rename all OperationContext variables to opCtx

This commit is an automated rename of all whole word instances of txn, _txn, and txnPtr to opCtx, _opCtx, and opCtxPtr, respectively in all .cpp and .h files in src/mongo.
author: Maria van Keulen <maria@mongodb.com> 2017-03-07 12:00:08 -0500
committer: Maria van Keulen <maria@mongodb.com> 2017-03-07 12:00:08 -0500
commit: 589a5c169ced8f6e9ddcd3d182ae1b75db6b7d79 (patch)
tree: c7a090ffdd56a91ae677e2492c61b820af44f964 /src/mongo/db/repl
parent: 3cba97198638df3750e3b455e2ad57af7ee536ae (diff)
download: mongo-589a5c169ced8f6e9ddcd3d182ae1b75db6b7d79.tar.gz
92 files changed, 2914 insertions, 2859 deletions
diff --git a/src/mongo/db/repl/bgsync.cpp b/src/mongo/db/repl/bgsync.cpp
index a0f646f6078..186903d0924 100644
--- a/src/mongo/db/repl/bgsync.cpp
+++ b/src/mongo/db/repl/bgsync.cpp
@@ -140,20 +140,20 @@ BackgroundSync::BackgroundSync(
     bufferMaxSizeGauge.increment(_oplogBuffer->getMaxSize() - bufferMaxSizeGauge.get());
 }
 
-void BackgroundSync::startup(OperationContext* txn) {
-    _oplogBuffer->startup(txn);
+void BackgroundSync::startup(OperationContext* opCtx) {
+    _oplogBuffer->startup(opCtx);
 
     invariant(!_producerThread);
     _producerThread.reset(new stdx::thread(stdx::bind(&BackgroundSync::_run, this)));
 }
 
-void BackgroundSync::shutdown(OperationContext* txn) {
+void BackgroundSync::shutdown(OperationContext* opCtx) {
     stdx::lock_guard<stdx::mutex> lock(_mutex);
 
     // Clear the buffer. This unblocks the OplogFetcher if it is blocked with a full queue, but
     // ensures that it won't add anything. It will also unblock the OpApplier pipeline if it is
     // waiting for an operation to be past the slaveDelay point.
-    clearBuffer(txn);
+    clearBuffer(opCtx);
     _state = ProducerState::Stopped;
 
     if (_syncSourceResolver) {
@@ -167,9 +167,9 @@ void BackgroundSync::shutdown(OperationContext* txn) {
     _inShutdown = true;
 }
 
-void BackgroundSync::join(OperationContext* txn) {
+void BackgroundSync::join(OperationContext* opCtx) {
     _producerThread->join();
-    _oplogBuffer->shutdown(txn);
+    _oplogBuffer->shutdown(opCtx);
 }
 
 bool BackgroundSync::inShutdown() const {
@@ -225,15 +225,15 @@ void BackgroundSync::_runProducer() {
     }
     // we want to start when we're no longer primary
     // start() also loads _lastOpTimeFetched, which we know is set from the "if"
-    auto txn = cc().makeOperationContext();
+    auto opCtx = cc().makeOperationContext();
     if (getState() == ProducerState::Starting) {
-        start(txn.get());
+        start(opCtx.get());
     }
 
-    _produce(txn.get());
+    _produce(opCtx.get());
 }
 
-void BackgroundSync::_produce(OperationContext* txn) {
+void BackgroundSync::_produce(OperationContext* opCtx) {
     if (MONGO_FAIL_POINT(stopReplProducer)) {
         // This log output is used in js tests so please leave it.
         log() << "bgsync - stopReplProducer fail point "
@@ -271,7 +271,7 @@ void BackgroundSync::_produce(OperationContext* txn) {
     HostAndPort source;
     SyncSourceResolverResponse syncSourceResp;
     {
-        const OpTime minValidSaved = StorageInterface::get(txn)->getMinValid(txn);
+        const OpTime minValidSaved = StorageInterface::get(opCtx)->getMinValid(opCtx);
 
         stdx::lock_guard<stdx::mutex> lock(_mutex);
         const auto requiredOpTime = (minValidSaved > _lastOpTimeFetched) ? minValidSaved : OpTime();
@@ -358,8 +358,9 @@ void BackgroundSync::_produce(OperationContext* txn) {
     // Set the applied point if unset. This is most likely the first time we've established a sync
     // source since stepping down or otherwise clearing the applied point. We need to set this here,
     // before the OplogWriter gets a chance to append to the oplog.
-    if (StorageInterface::get(txn)->getAppliedThrough(txn).isNull()) {
-        StorageInterface::get(txn)->setAppliedThrough(txn, _replCoord->getMyLastAppliedOpTime());
+    if (StorageInterface::get(opCtx)->getAppliedThrough(opCtx).isNull()) {
+        StorageInterface::get(opCtx)->setAppliedThrough(opCtx,
+                                                        _replCoord->getMyLastAppliedOpTime());
     }
 
     // "lastFetched" not used. Already set in _enqueueDocuments.
@@ -472,7 +473,7 @@ void BackgroundSync::_produce(OperationContext* txn) {
             }
         }
 
-        _rollback(txn, source, syncSourceResp.rbid, getConnection);
+        _rollback(opCtx, source, syncSourceResp.rbid, getConnection);
         // Reset the producer to clear the sync source and the last optime fetched.
         stop(true);
         startProducerIfStopped();
@@ -540,10 +541,10 @@ Status BackgroundSync::_enqueueDocuments(Fetcher::Documents::const_iterator begi
         return Status::OK();  // Nothing to do.
     }
 
-    auto txn = cc().makeOperationContext();
+    auto opCtx = cc().makeOperationContext();
 
     // Wait for enough space.
-    _oplogBuffer->waitForSpace(txn.get(), info.toApplyDocumentBytes);
+    _oplogBuffer->waitForSpace(opCtx.get(), info.toApplyDocumentBytes);
 
     {
         // Don't add more to the buffer if we are in shutdown. Continue holding the lock until we
@@ -560,7 +561,7 @@ Status BackgroundSync::_enqueueDocuments(Fetcher::Documents::const_iterator begi
         }
 
         // Buffer docs for later application.
-        _oplogBuffer->pushAllNonBlocking(txn.get(), begin, end);
+        _oplogBuffer->pushAllNonBlocking(opCtx.get(), begin, end);
 
         // Update last fetched info.
         _lastFetchedHash = info.lastDocument.value;
@@ -585,8 +586,8 @@ Status BackgroundSync::_enqueueDocuments(Fetcher::Documents::const_iterator begi
     return Status::OK();
 }
 
-bool BackgroundSync::peek(OperationContext* txn, BSONObj* op) {
-    return _oplogBuffer->peek(txn, op);
+bool BackgroundSync::peek(OperationContext* opCtx, BSONObj* op) {
+    return _oplogBuffer->peek(opCtx, op);
 }
 
 void BackgroundSync::waitForMore() {
@@ -594,11 +595,11 @@ void BackgroundSync::waitForMore() {
     _oplogBuffer->waitForData(Seconds(1));
 }
 
-void BackgroundSync::consume(OperationContext* txn) {
+void BackgroundSync::consume(OperationContext* opCtx) {
     // this is just to get the op off the queue, it's been peeked at
     // and queued for application already
     BSONObj op;
-    if (_oplogBuffer->tryPop(txn, &op)) {
+    if (_oplogBuffer->tryPop(opCtx, &op)) {
         bufferCountGauge.decrement(1);
         bufferSizeGauge.decrement(getSize(op));
     } else {
@@ -609,7 +610,7 @@ void BackgroundSync::consume(OperationContext* txn) {
     }
 }
 
-void BackgroundSync::_rollback(OperationContext* txn,
+void BackgroundSync::_rollback(OperationContext* opCtx,
                                const HostAndPort& source,
                                boost::optional<int> requiredRBID,
                                stdx::function<DBClientBase*()> getConnection) {
@@ -635,7 +636,7 @@ void BackgroundSync::_rollback(OperationContext* txn,
     // then.
     {
         log() << "rollback 0";
-        Lock::GlobalWrite globalWrite(txn->lockState());
+        Lock::GlobalWrite globalWrite(opCtx->lockState());
         if (!_replCoord->setFollowerMode(MemberState::RS_ROLLBACK)) {
             log() << "Cannot transition from " << _replCoord->getMemberState().toString() << " to "
                   << MemberState(MemberState::RS_ROLLBACK).toString();
@@ -644,8 +645,8 @@ void BackgroundSync::_rollback(OperationContext* txn,
     }
 
     try {
-        auto status = syncRollback(txn,
-                                   OplogInterfaceLocal(txn, rsOplogName),
+        auto status = syncRollback(opCtx,
+                                   OplogInterfaceLocal(opCtx, rsOplogName),
                                    RollbackSourceImpl(getConnection, source, rsOplogName),
                                    requiredRBID,
                                    _replCoord);
@@ -668,7 +669,7 @@ void BackgroundSync::_rollback(OperationContext* txn,
 
         warning() << "rollback cannot complete at this time (retrying later): " << redact(ex)
                   << " appliedThrough=" << _replCoord->getMyLastAppliedOpTime()
-                  << " minvalid=" << StorageInterface::get(txn)->getMinValid(txn);
+                  << " minvalid=" << StorageInterface::get(opCtx)->getMinValid(opCtx);
 
         // Sleep a bit to allow upstream node to coalesce, if that was the cause of the failure. If
         // we failed in a way that will keep failing, but wasn't flagged as a fatal failure, this
@@ -684,12 +685,12 @@ void BackgroundSync::_rollback(OperationContext* txn,
     // so that if we wind up shutting down uncleanly in response to something we rolled back
     // we know that we won't wind up right back in the same situation when we start back up
     // because the rollback wasn't durable.
-    txn->recoveryUnit()->waitUntilDurable();
+    opCtx->recoveryUnit()->waitUntilDurable();
 
     // If we detected that we rolled back the shardIdentity document as part of this rollback
     // then we must shut down to clear the in-memory ShardingState associated with the
     // shardIdentity document.
-    if (ShardIdentityRollbackNotifier::get(txn)->didRollbackHappen()) {
+    if (ShardIdentityRollbackNotifier::get(opCtx)->didRollbackHappen()) {
         severe() << "shardIdentity document rollback detected.  Shutting down to clear "
                     "in-memory sharding state.  Restarting this process should safely return it "
                     "to a healthy state";
@@ -734,10 +735,10 @@ void BackgroundSync::stop(bool resetLastFetchedOptime) {
     }
 }
 
-void BackgroundSync::start(OperationContext* txn) {
+void BackgroundSync::start(OperationContext* opCtx) {
     OpTimeWithHash lastAppliedOpTimeWithHash;
     do {
-        lastAppliedOpTimeWithHash = _readLastAppliedOpTimeWithHash(txn);
+        lastAppliedOpTimeWithHash = _readLastAppliedOpTimeWithHash(opCtx);
         stdx::lock_guard<stdx::mutex> lk(_mutex);
         // Double check the state after acquiring the mutex.
         if (_state != ProducerState::Starting) {
@@ -762,28 +763,28 @@ void BackgroundSync::start(OperationContext* txn) {
     LOG(1) << "bgsync fetch queue set to: " << _lastOpTimeFetched << " " << _lastFetchedHash;
 }
 
-void BackgroundSync::clearBuffer(OperationContext* txn) {
-    _oplogBuffer->clear(txn);
+void BackgroundSync::clearBuffer(OperationContext* opCtx) {
+    _oplogBuffer->clear(opCtx);
     const auto count = bufferCountGauge.get();
     bufferCountGauge.decrement(count);
     const auto size = bufferSizeGauge.get();
     bufferSizeGauge.decrement(size);
 }
 
-OpTimeWithHash BackgroundSync::_readLastAppliedOpTimeWithHash(OperationContext* txn) {
+OpTimeWithHash BackgroundSync::_readLastAppliedOpTimeWithHash(OperationContext* opCtx) {
     BSONObj oplogEntry;
     try {
         MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
-            ScopedTransaction transaction(txn, MODE_IX);
-            Lock::DBLock lk(txn->lockState(), "local", MODE_X);
-            bool success = Helpers::getLast(txn, rsOplogName.c_str(), oplogEntry);
+            ScopedTransaction transaction(opCtx, MODE_IX);
+            Lock::DBLock lk(opCtx->lockState(), "local", MODE_X);
+            bool success = Helpers::getLast(opCtx, rsOplogName.c_str(), oplogEntry);
             if (!success) {
                 // This can happen when we are to do an initial sync.  lastHash will be set
                 // after the initial sync is complete.
                 return OpTimeWithHash(0);
             }
         }
-        MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "readLastAppliedHash", rsOplogName);
+        MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "readLastAppliedHash", rsOplogName);
     } catch (const DBException& ex) {
         severe() << "Problem reading " << rsOplogName << ": " << redact(ex);
         fassertFailed(18904);
@@ -817,8 +818,8 @@ bool BackgroundSync::shouldStopFetching() const {
     return false;
 }
 
-void BackgroundSync::pushTestOpToBuffer(OperationContext* txn, const BSONObj& op) {
-    _oplogBuffer->push(txn, op);
+void BackgroundSync::pushTestOpToBuffer(OperationContext* opCtx, const BSONObj& op) {
+    _oplogBuffer->push(opCtx, op);
     bufferCountGauge.increment();
     bufferSizeGauge.increment(op.objsize());
 }
diff --git a/src/mongo/db/repl/bgsync.h b/src/mongo/db/repl/bgsync.h
index 479caabaee8..85069066cdd 100644
--- a/src/mongo/db/repl/bgsync.h
+++ b/src/mongo/db/repl/bgsync.h
@@ -84,17 +84,17 @@ public:
     /**
      * Starts oplog buffer, task executor and producer thread, in that order.
      */
-    void startup(OperationContext* txn);
+    void startup(OperationContext* opCtx);
 
     /**
      * Signals producer thread to stop.
      */
-    void shutdown(OperationContext* txn);
+    void shutdown(OperationContext* opCtx);
 
     /**
      * Waits for producer thread to stop before shutting down the task executor and oplog buffer.
      */
-    void join(OperationContext* txn);
+    void join(OperationContext* opCtx);
 
     /**
      * Returns true if shutdown() has been called.
@@ -109,8 +109,8 @@ public:
 
     // Interface implementation
 
-    bool peek(OperationContext* txn, BSONObj* op);
-    void consume(OperationContext* txn);
+    bool peek(OperationContext* opCtx, BSONObj* op);
+    void consume(OperationContext* opCtx);
     void clearSyncTarget();
     void waitForMore();
 
@@ -118,7 +118,7 @@ public:
     BSONObj getCounters();
 
     // Clears any fetched and buffered oplog entries.
-    void clearBuffer(OperationContext* txn);
+    void clearBuffer(OperationContext* opCtx);
 
     /**
      * Returns true if any of the following is true:
@@ -134,7 +134,7 @@ public:
     void startProducerIfStopped();
 
     // Adds a fake oplog entry to buffer. Used for testing only.
-    void pushTestOpToBuffer(OperationContext* txn, const BSONObj& op);
+    void pushTestOpToBuffer(OperationContext* opCtx, const BSONObj& op);
 
 private:
     bool _inShutdown_inlock() const;
@@ -148,7 +148,7 @@ private:
     void _run();
     // Production thread inner loop.
     void _runProducer();
-    void _produce(OperationContext* txn);
+    void _produce(OperationContext* opCtx);
 
     /**
      * Checks current background sync state before pushing operations into blocking queue and
@@ -165,15 +165,15 @@ private:
      * Executes a rollback.
      * 'getConnection' returns a connection to the sync source.
      */
-    void _rollback(OperationContext* txn,
+    void _rollback(OperationContext* opCtx,
                    const HostAndPort& source,
                    boost::optional<int> requiredRBID,
                    stdx::function<DBClientBase*()> getConnection);
 
     // restart syncing
-    void start(OperationContext* txn);
+    void start(OperationContext* opCtx);
 
-    OpTimeWithHash _readLastAppliedOpTimeWithHash(OperationContext* txn);
+    OpTimeWithHash _readLastAppliedOpTimeWithHash(OperationContext* opCtx);
 
     // Production thread
     std::unique_ptr<OplogBuffer> _oplogBuffer;
diff --git a/src/mongo/db/repl/collection_bulk_loader_impl.cpp b/src/mongo/db/repl/collection_bulk_loader_impl.cpp
index ffc6b176032..9b1c96ec95b 100644
--- a/src/mongo/db/repl/collection_bulk_loader_impl.cpp
+++ b/src/mongo/db/repl/collection_bulk_loader_impl.cpp
@@ -51,7 +51,7 @@
 namespace mongo {
 namespace repl {
 
-CollectionBulkLoaderImpl::CollectionBulkLoaderImpl(OperationContext* txn,
+CollectionBulkLoaderImpl::CollectionBulkLoaderImpl(OperationContext* opCtx,
                                                    Collection* coll,
                                                    const BSONObj idIndexSpec,
                                                    std::unique_ptr<OldThreadPool> threadPool,
@@ -62,13 +62,13 @@ CollectionBulkLoaderImpl::CollectionBulkLoaderImpl(OperationContext* txn,
       _runner(std::move(runner)),
       _autoColl(std::move(autoColl)),
       _autoDB(std::move(autoDb)),
-      _txn(txn),
+      _opCtx(opCtx),
       _coll(coll),
       _nss{coll->ns()},
-      _idIndexBlock(stdx::make_unique<MultiIndexBlock>(txn, coll)),
-      _secondaryIndexesBlock(stdx::make_unique<MultiIndexBlock>(txn, coll)),
+      _idIndexBlock(stdx::make_unique<MultiIndexBlock>(opCtx, coll)),
+      _secondaryIndexesBlock(stdx::make_unique<MultiIndexBlock>(opCtx, coll)),
       _idIndexSpec(idIndexSpec) {
-    invariant(txn);
+    invariant(opCtx);
     invariant(coll);
     invariant(_runner);
     invariant(_autoDB);
@@ -89,10 +89,10 @@ CollectionBulkLoaderImpl::~CollectionBulkLoaderImpl() {
 Status CollectionBulkLoaderImpl::init(Collection* coll,
                                       const std::vector<BSONObj>& secondaryIndexSpecs) {
     return _runTaskReleaseResourcesOnFailure(
-        [coll, &secondaryIndexSpecs, this](OperationContext* txn) -> Status {
-            invariant(txn);
+        [coll, &secondaryIndexSpecs, this](OperationContext* opCtx) -> Status {
+            invariant(opCtx);
             invariant(coll);
-            invariant(txn->getClient() == &cc());
+            invariant(opCtx->getClient() == &cc());
             std::vector<BSONObj> specs(secondaryIndexSpecs);
             // This enforces the buildIndexes setting in the replica set configuration.
             _secondaryIndexesBlock->removeExistingIndexes(&specs);
@@ -122,8 +122,8 @@ Status CollectionBulkLoaderImpl::insertDocuments(const std::vector<BSONObj>::con
                                                  const std::vector<BSONObj>::const_iterator end) {
     int count = 0;
     return _runTaskReleaseResourcesOnFailure(
-        [begin, end, &count, this](OperationContext* txn) -> Status {
-            invariant(txn);
+        [begin, end, &count, this](OperationContext* opCtx) -> Status {
+            invariant(opCtx);
 
             for (auto iter = begin; iter != end; ++iter) {
                 std::vector<MultiIndexBlock*> indexers;
@@ -134,15 +134,15 @@ Status CollectionBulkLoaderImpl::insertDocuments(const std::vector<BSONObj>::con
                     indexers.push_back(_secondaryIndexesBlock.get());
                 }
                 MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
-                    WriteUnitOfWork wunit(txn);
-                    const auto status = _coll->insertDocument(txn, *iter, indexers, false);
+                    WriteUnitOfWork wunit(opCtx);
+                    const auto status = _coll->insertDocument(opCtx, *iter, indexers, false);
                     if (!status.isOK()) {
                         return status;
                     }
                     wunit.commit();
                 }
                 MONGO_WRITE_CONFLICT_RETRY_LOOP_END(
-                    _txn, "CollectionBulkLoaderImpl::insertDocuments", _nss.ns());
+                    _opCtx, "CollectionBulkLoaderImpl::insertDocuments", _nss.ns());
 
                 ++count;
             }
@@ -152,11 +152,11 @@ Status CollectionBulkLoaderImpl::insertDocuments(const std::vector<BSONObj>::con
 
 Status CollectionBulkLoaderImpl::commit() {
     return _runTaskReleaseResourcesOnFailure(
-        [this](OperationContext* txn) -> Status {
+        [this](OperationContext* opCtx) -> Status {
             _stats.startBuildingIndexes = Date_t::now();
             LOG(2) << "Creating indexes for ns: " << _nss.ns();
-            invariant(txn->getClient() == &cc());
-            invariant(txn == _txn);
+            invariant(opCtx->getClient() == &cc());
+            invariant(opCtx == _opCtx);
 
             // Commit before deleting dups, so the dups will be removed from secondary indexes when
             // deleted.
@@ -173,12 +173,12 @@ Status CollectionBulkLoaderImpl::commit() {
                                                    "MultiIndexBlock::ignoreUniqueConstraint set."};
                 }
                 MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
-                    WriteUnitOfWork wunit(txn);
+                    WriteUnitOfWork wunit(opCtx);
                     _secondaryIndexesBlock->commit();
                     wunit.commit();
                 }
                 MONGO_WRITE_CONFLICT_RETRY_LOOP_END(
-                    _txn, "CollectionBulkLoaderImpl::commit", _nss.ns());
+                    _opCtx, "CollectionBulkLoaderImpl::commit", _nss.ns());
             }
 
             if (_idIndexBlock) {
@@ -192,8 +192,8 @@ Status CollectionBulkLoaderImpl::commit() {
 
                 for (auto&& it : dups) {
                     MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
-                        WriteUnitOfWork wunit(_txn);
-                        _coll->deleteDocument(_txn,
+                        WriteUnitOfWork wunit(_opCtx);
+                        _coll->deleteDocument(_opCtx,
                                               it,
                                               nullptr /** OpDebug **/,
                                               false /* fromMigrate */,
@@ -201,17 +201,17 @@ Status CollectionBulkLoaderImpl::commit() {
                         wunit.commit();
                     }
                     MONGO_WRITE_CONFLICT_RETRY_LOOP_END(
-                        _txn, "CollectionBulkLoaderImpl::commit", _nss.ns());
+                        _opCtx, "CollectionBulkLoaderImpl::commit", _nss.ns());
                 }
 
                 // Commit _id index, without dups.
                 MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
-                    WriteUnitOfWork wunit(txn);
+                    WriteUnitOfWork wunit(opCtx);
                     _idIndexBlock->commit();
                     wunit.commit();
                 }
                 MONGO_WRITE_CONFLICT_RETRY_LOOP_END(
-                    _txn, "CollectionBulkLoaderImpl::commit", _nss.ns());
+                    _opCtx, "CollectionBulkLoaderImpl::commit", _nss.ns());
             }
             _stats.endBuildingIndexes = Date_t::now();
             LOG(2) << "Done creating indexes for ns: " << _nss.ns()
@@ -244,9 +244,9 @@ void CollectionBulkLoaderImpl::_releaseResources() {
 
 Status CollectionBulkLoaderImpl::_runTaskReleaseResourcesOnFailure(
     TaskRunner::SynchronousTask task, TaskRunner::NextAction nextAction) {
-    auto newTask = [this, &task](OperationContext* txn) -> Status {
+    auto newTask = [this, &task](OperationContext* opCtx) -> Status {
         ScopeGuard guard = MakeGuard(&CollectionBulkLoaderImpl::_releaseResources, this);
-        const auto status = task(txn);
+        const auto status = task(opCtx);
         if (status.isOK()) {
             guard.Dismiss();
         }
diff --git a/src/mongo/db/repl/collection_bulk_loader_impl.h b/src/mongo/db/repl/collection_bulk_loader_impl.h
index 61928e4c385..17b4741ec8f 100644
--- a/src/mongo/db/repl/collection_bulk_loader_impl.h
+++ b/src/mongo/db/repl/collection_bulk_loader_impl.h
@@ -61,7 +61,7 @@ public:
         BSONObj toBSON() const;
     };
 
-    CollectionBulkLoaderImpl(OperationContext* txn,
+    CollectionBulkLoaderImpl(OperationContext* opCtx,
                              Collection* coll,
                              const BSONObj idIndexSpec,
                              std::unique_ptr<OldThreadPool> threadPool,
@@ -91,7 +91,7 @@ private:
     std::unique_ptr<TaskRunner> _runner;
     std::unique_ptr<AutoGetCollection> _autoColl;
     std::unique_ptr<AutoGetOrCreateDb> _autoDB;
-    OperationContext* _txn = nullptr;
+    OperationContext* _opCtx = nullptr;
     Collection* _coll = nullptr;
     NamespaceString _nss;
     std::unique_ptr<MultiIndexBlock> _idIndexBlock;
diff --git a/src/mongo/db/repl/collection_cloner.cpp b/src/mongo/db/repl/collection_cloner.cpp
index ac1b34c1528..85c9f39169d 100644
--- a/src/mongo/db/repl/collection_cloner.cpp
+++ b/src/mongo/db/repl/collection_cloner.cpp
@@ -119,9 +119,9 @@ CollectionCloner::CollectionCloner(executor::TaskExecutor* executor,
       _documents(),
       _dbWorkTaskRunner(_dbWorkThreadPool),
       _scheduleDbWorkFn([this](const executor::TaskExecutor::CallbackFn& work) {
-          auto task = [work](OperationContext* txn,
+          auto task = [work](OperationContext* opCtx,
                              const Status& status) -> TaskRunner::NextAction {
-              work(executor::TaskExecutor::CallbackArgs(nullptr, {}, status, txn));
+              work(executor::TaskExecutor::CallbackArgs(nullptr, {}, status, opCtx));
               return TaskRunner::NextAction::kDisposeOperationContext;
           };
           _dbWorkTaskRunner.schedule(task);
@@ -337,9 +337,10 @@ void CollectionCloner::_listIndexesCallback(const Fetcher::QueryResponseStatus&
                     _finishCallback(cbd.status);
                     return;
                 }
-                auto txn = cbd.txn;
-                txn->setReplicatedWrites(false);
-                auto&& createStatus = _storageInterface->createCollection(txn, _destNss, _options);
+                auto opCtx = cbd.opCtx;
+                opCtx->setReplicatedWrites(false);
+                auto&& createStatus =
+                    _storageInterface->createCollection(opCtx, _destNss, _options);
                 _finishCallback(createStatus);
             });
         if (!scheduleResult.isOK()) {
diff --git a/src/mongo/db/repl/collection_cloner_test.cpp b/src/mongo/db/repl/collection_cloner_test.cpp
index 8c0ac71ba70..440b8dee232 100644
--- a/src/mongo/db/repl/collection_cloner_test.cpp
+++ b/src/mongo/db/repl/collection_cloner_test.cpp
@@ -405,8 +405,8 @@ TEST_F(CollectionClonerTest, ListIndexesReturnedNamespaceNotFound) {
     bool writesAreReplicatedOnOpCtx = false;
     NamespaceString collNss;
     storageInterface->createCollFn = [&collNss, &collectionCreated, &writesAreReplicatedOnOpCtx](
-        OperationContext* txn, const NamespaceString& nss, const CollectionOptions& options) {
-        writesAreReplicatedOnOpCtx = txn->writesAreReplicated();
+        OperationContext* opCtx, const NamespaceString& nss, const CollectionOptions& options) {
+        writesAreReplicatedOnOpCtx = opCtx->writesAreReplicated();
         collectionCreated = true;
         collNss = nss;
         return Status::OK();
@@ -458,14 +458,14 @@ TEST_F(CollectionClonerTest,
     // Replace scheduleDbWork function to schedule the create collection task with an injected error
     // status.
     auto exec = &getExecutor();
-    collectionCloner->setScheduleDbWorkFn_forTest(
-        [exec](const executor::TaskExecutor::CallbackFn& workFn) {
-            auto wrappedTask = [workFn](const executor::TaskExecutor::CallbackArgs& cbd) {
-                workFn(executor::TaskExecutor::CallbackArgs(
-                    cbd.executor, cbd.myHandle, Status(ErrorCodes::CallbackCanceled, ""), cbd.txn));
-            };
-            return exec->scheduleWork(wrappedTask);
-        });
+    collectionCloner->setScheduleDbWorkFn_forTest([exec](
+        const executor::TaskExecutor::CallbackFn& workFn) {
+        auto wrappedTask = [workFn](const executor::TaskExecutor::CallbackArgs& cbd) {
+            workFn(executor::TaskExecutor::CallbackArgs(
+                cbd.executor, cbd.myHandle, Status(ErrorCodes::CallbackCanceled, ""), cbd.opCtx));
+        };
+        return exec->scheduleWork(wrappedTask);
+    });
 
     bool collectionCreated = false;
     storageInterface->createCollFn = [&collectionCreated](
diff --git a/src/mongo/db/repl/data_replicator.cpp b/src/mongo/db/repl/data_replicator.cpp
index ee990aab967..92e64cbb993 100644
--- a/src/mongo/db/repl/data_replicator.cpp
+++ b/src/mongo/db/repl/data_replicator.cpp
@@ -252,9 +252,9 @@ bool DataReplicator::_isActive_inlock() const {
     return State::kRunning == _state || State::kShuttingDown == _state;
 }
 
-Status DataReplicator::startup(OperationContext* txn,
+Status DataReplicator::startup(OperationContext* opCtx,
                                std::uint32_t initialSyncMaxAttempts) noexcept {
-    invariant(txn);
+    invariant(opCtx);
     invariant(initialSyncMaxAttempts >= 1U);
 
     stdx::lock_guard<stdx::mutex> lock(_mutex);
@@ -270,7 +270,7 @@ Status DataReplicator::startup(OperationContext* txn,
             return Status(ErrorCodes::ShutdownInProgress, "data replicator completed");
     }
 
-    _setUp_inlock(txn, initialSyncMaxAttempts);
+    _setUp_inlock(opCtx, initialSyncMaxAttempts);
 
     // Start first initial sync attempt.
     std::uint32_t initialSyncAttempt = 0;
@@ -397,32 +397,32 @@ void DataReplicator::setScheduleDbWorkFn_forTest(const CollectionCloner::Schedul
     _scheduleDbWorkFn = work;
 }
 
-void DataReplicator::_setUp_inlock(OperationContext* txn, std::uint32_t initialSyncMaxAttempts) {
+void DataReplicator::_setUp_inlock(OperationContext* opCtx, std::uint32_t initialSyncMaxAttempts) {
     // This will call through to the storageInterfaceImpl to ReplicationCoordinatorImpl.
-    // 'txn' is passed through from startup().
-    _storage->setInitialSyncFlag(txn);
+    // 'opCtx' is passed through from startup().
+    _storage->setInitialSyncFlag(opCtx);
 
     LOG(1) << "Creating oplogBuffer.";
-    _oplogBuffer = _dataReplicatorExternalState->makeInitialSyncOplogBuffer(txn);
-    _oplogBuffer->startup(txn);
+    _oplogBuffer = _dataReplicatorExternalState->makeInitialSyncOplogBuffer(opCtx);
+    _oplogBuffer->startup(opCtx);
 
     _stats.initialSyncStart = _exec->now();
     _stats.maxFailedInitialSyncAttempts = initialSyncMaxAttempts;
     _stats.failedInitialSyncAttempts = 0;
 }
 
-void DataReplicator::_tearDown_inlock(OperationContext* txn,
+void DataReplicator::_tearDown_inlock(OperationContext* opCtx,
                                       const StatusWith<OpTimeWithHash>& lastApplied) {
     _stats.initialSyncEnd = _exec->now();
 
     // This might not be necessary if we failed initial sync.
     invariant(_oplogBuffer);
-    _oplogBuffer->shutdown(txn);
+    _oplogBuffer->shutdown(opCtx);
 
     if (!lastApplied.isOK()) {
         return;
     }
-    _storage->clearInitialSyncFlag(txn);
+    _storage->clearInitialSyncFlag(opCtx);
     _opts.setMyLastOptime(lastApplied.getValue().opTime);
     log() << "initial sync done; took "
           << duration_cast<Seconds>(_stats.initialSyncEnd - _stats.initialSyncStart) << ".";
@@ -570,28 +570,28 @@ Status DataReplicator::_recreateOplogAndDropReplicatedDatabases() {
     LOG(1) << "About to drop+create the oplog, if it exists, ns:" << _opts.localOplogNS
            << ", and drop all user databases (so that we can clone them).";
 
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     // We are not replicating nor validating these writes.
-    UnreplicatedWritesBlock unreplicatedWritesBlock(txn.get());
+    UnreplicatedWritesBlock unreplicatedWritesBlock(opCtx.get());
 
     // 1.) Drop the oplog.
     LOG(2) << "Dropping the existing oplog: " << _opts.localOplogNS;
-    auto status = _storage->dropCollection(txn.get(), _opts.localOplogNS);
+    auto status = _storage->dropCollection(opCtx.get(), _opts.localOplogNS);
     if (!status.isOK()) {
         return status;
     }
 
     // 2.) Drop user databases.
     LOG(2) << "Dropping  user databases";
-    status = _storage->dropReplicatedDatabases(txn.get());
+    status = _storage->dropReplicatedDatabases(opCtx.get());
     if (!status.isOK()) {
         return status;
     }
 
     // 3.) Create the oplog.
     LOG(2) << "Creating the oplog: " << _opts.localOplogNS;
-    return _storage->createOplog(txn.get(), _opts.localOplogNS);
+    return _storage->createOplog(opCtx.get(), _opts.localOplogNS);
 }
 
 void DataReplicator::_rollbackCheckerResetCallback(
@@ -833,12 +833,12 @@ void DataReplicator::_lastOplogEntryFetcherCallbackForStopTimestamp(
         const auto& oplogSeedDoc = documents.front();
         LOG(1) << "inserting oplog seed document: " << oplogSeedDoc;
 
-        auto txn = makeOpCtx();
+        auto opCtx = makeOpCtx();
         // StorageInterface::insertDocument() has to be called outside the lock because we may
         // override its behavior in tests. See DataReplicatorReturnsCallbackCanceledAndDoesNot-
         // ScheduleRollbackCheckerIfShutdownAfterInsertingInsertOplogSeedDocument in
         // data_replicator_test.cpp
-        auto status = _storage->insertDocument(txn.get(), _opts.localOplogNS, oplogSeedDoc);
+        auto status = _storage->insertDocument(opCtx.get(), _opts.localOplogNS, oplogSeedDoc);
         if (!status.isOK()) {
             stdx::lock_guard<stdx::mutex> lock(_mutex);
             onCompletionGuard->setResultAndCancelRemainingWork_inlock(lock, status);
@@ -1048,7 +1048,7 @@ void DataReplicator::_finishInitialSyncAttempt(const StatusWith<OpTimeWithHash>&
     // For example, if CollectionCloner fails while inserting documents into the
     // CollectionBulkLoader, we will get here via one of CollectionCloner's TaskRunner callbacks
     // which has an active OperationContext bound to the current Client. This would lead to an
-    // invariant when we attempt to create a new OperationContext for _tearDown(txn).
+    // invariant when we attempt to create a new OperationContext for _tearDown(opCtx).
     // To avoid this, we schedule _finishCallback against the TaskExecutor rather than calling it
     // here synchronously.
 
@@ -1139,8 +1139,8 @@ void DataReplicator::_finishCallback(StatusWith<OpTimeWithHash> lastApplied) {
     decltype(_onCompletion) onCompletion;
     {
         stdx::lock_guard<stdx::mutex> lock(_mutex);
-        auto txn = makeOpCtx();
-        _tearDown_inlock(txn.get(), lastApplied);
+        auto opCtx = makeOpCtx();
+        _tearDown_inlock(opCtx.get(), lastApplied);
 
         invariant(_onCompletion);
         std::swap(_onCompletion, onCompletion);
@@ -1395,8 +1395,8 @@ StatusWith<Operations> DataReplicator::_getNextApplierBatch_inlock() {
     //      * only OplogEntries from before the slaveDelay point
     //      * a single command OplogEntry (including index builds, which appear to be inserts)
     //          * consequently, commands bound the previous batch to be in a batch of their own
-    auto txn = makeOpCtx();
-    while (_oplogBuffer->peek(txn.get(), &op)) {
+    auto opCtx = makeOpCtx();
+    while (_oplogBuffer->peek(opCtx.get(), &op)) {
         auto entry = OplogEntry(std::move(op));
 
         // Check for oplog version change. If it is absent, its value is one.
@@ -1417,7 +1417,7 @@ StatusWith<Operations> DataReplicator::_getNextApplierBatch_inlock() {
             if (ops.empty()) {
                 // Apply commands one-at-a-time.
                 ops.push_back(std::move(entry));
-                invariant(_oplogBuffer->tryPop(txn.get(), &op));
+                invariant(_oplogBuffer->tryPop(opCtx.get(), &op));
                 dassert(SimpleBSONObjComparator::kInstance.evaluate(ops.back().raw == op));
             }
 
@@ -1451,7 +1451,7 @@ StatusWith<Operations> DataReplicator::_getNextApplierBatch_inlock() {
         // Add op to buffer.
         ops.push_back(std::move(entry));
         totalBytes += ops.back().raw.objsize();
-        invariant(_oplogBuffer->tryPop(txn.get(), &op));
+        invariant(_oplogBuffer->tryPop(opCtx.get(), &op));
         dassert(SimpleBSONObjComparator::kInstance.evaluate(ops.back().raw == op));
     }
     return std::move(ops);
diff --git a/src/mongo/db/repl/data_replicator.h b/src/mongo/db/repl/data_replicator.h
index 62a8f134988..e2b96a92f6a 100644
--- a/src/mongo/db/repl/data_replicator.h
+++ b/src/mongo/db/repl/data_replicator.h
@@ -186,7 +186,7 @@ public:
     /**
      * Starts initial sync process, with the provided number of attempts
      */
-    Status startup(OperationContext* txn, std::uint32_t maxAttempts) noexcept;
+    Status startup(OperationContext* opCtx, std::uint32_t maxAttempts) noexcept;
 
     /**
      * Shuts down replication if "start" has been called, and blocks until shutdown has completed.
@@ -336,12 +336,12 @@ private:
     /**
      * Sets up internal state to begin initial sync.
      */
-    void _setUp_inlock(OperationContext* txn, std::uint32_t initialSyncMaxAttempts);
+    void _setUp_inlock(OperationContext* opCtx, std::uint32_t initialSyncMaxAttempts);
 
     /**
      * Tears down internal state before reporting final status to caller.
      */
-    void _tearDown_inlock(OperationContext* txn, const StatusWith<OpTimeWithHash>& lastApplied);
+    void _tearDown_inlock(OperationContext* opCtx, const StatusWith<OpTimeWithHash>& lastApplied);
 
     /**
      * Callback to start a single initial sync attempt.
diff --git a/src/mongo/db/repl/data_replicator_external_state.h b/src/mongo/db/repl/data_replicator_external_state.h
index 0102ddab533..a1b4bf61e87 100644
--- a/src/mongo/db/repl/data_replicator_external_state.h
+++ b/src/mongo/db/repl/data_replicator_external_state.h
@@ -110,13 +110,13 @@ public:
      * This function creates an oplog buffer of the type specified at server startup.
      */
     virtual std::unique_ptr<OplogBuffer> makeInitialSyncOplogBuffer(
-        OperationContext* txn) const = 0;
+        OperationContext* opCtx) const = 0;
 
     /**
      * Creates an oplog buffer suitable for steady state replication.
      */
     virtual std::unique_ptr<OplogBuffer> makeSteadyStateOplogBuffer(
-        OperationContext* txn) const = 0;
+        OperationContext* opCtx) const = 0;
 
     /**
      * Returns the current replica set config if there is one, or an error why there isn't.
@@ -130,7 +130,7 @@ private:
      *
      * Used exclusively by the DataReplicator to construct a MultiApplier.
      */
-    virtual StatusWith<OpTime> _multiApply(OperationContext* txn,
+    virtual StatusWith<OpTime> _multiApply(OperationContext* opCtx,
                                            MultiApplier::Operations ops,
                                            MultiApplier::ApplyOperationFn applyOperation) = 0;
 
diff --git a/src/mongo/db/repl/data_replicator_external_state_impl.cpp b/src/mongo/db/repl/data_replicator_external_state_impl.cpp
index eed85a8216e..e486cfd5278 100644
--- a/src/mongo/db/repl/data_replicator_external_state_impl.cpp
+++ b/src/mongo/db/repl/data_replicator_external_state_impl.cpp
@@ -106,13 +106,13 @@ bool DataReplicatorExternalStateImpl::shouldStopFetching(
 }
 
 std::unique_ptr<OplogBuffer> DataReplicatorExternalStateImpl::makeInitialSyncOplogBuffer(
-    OperationContext* txn) const {
-    return _replicationCoordinatorExternalState->makeInitialSyncOplogBuffer(txn);
+    OperationContext* opCtx) const {
+    return _replicationCoordinatorExternalState->makeInitialSyncOplogBuffer(opCtx);
 }
 
 std::unique_ptr<OplogBuffer> DataReplicatorExternalStateImpl::makeSteadyStateOplogBuffer(
-    OperationContext* txn) const {
-    return _replicationCoordinatorExternalState->makeSteadyStateOplogBuffer(txn);
+    OperationContext* opCtx) const {
+    return _replicationCoordinatorExternalState->makeSteadyStateOplogBuffer(opCtx);
 }
 
 StatusWith<ReplSetConfig> DataReplicatorExternalStateImpl::getCurrentConfig() const {
@@ -120,10 +120,10 @@ StatusWith<ReplSetConfig> DataReplicatorExternalStateImpl::getCurrentConfig() co
 }
 
 StatusWith<OpTime> DataReplicatorExternalStateImpl::_multiApply(
-    OperationContext* txn,
+    OperationContext* opCtx,
     MultiApplier::Operations ops,
     MultiApplier::ApplyOperationFn applyOperation) {
-    return _replicationCoordinatorExternalState->multiApply(txn, std::move(ops), applyOperation);
+    return _replicationCoordinatorExternalState->multiApply(opCtx, std::move(ops), applyOperation);
 }
 
 Status DataReplicatorExternalStateImpl::_multiSyncApply(MultiApplier::OperationPtrs* ops) {
diff --git a/src/mongo/db/repl/data_replicator_external_state_impl.h b/src/mongo/db/repl/data_replicator_external_state_impl.h
index 2c5518d7a1d..40a25bcaf67 100644
--- a/src/mongo/db/repl/data_replicator_external_state_impl.h
+++ b/src/mongo/db/repl/data_replicator_external_state_impl.h
@@ -59,14 +59,14 @@ public:
                             const rpc::ReplSetMetadata& replMetadata,
                             boost::optional<rpc::OplogQueryMetadata> oqMetadata) override;
 
-    std::unique_ptr<OplogBuffer> makeInitialSyncOplogBuffer(OperationContext* txn) const override;
+    std::unique_ptr<OplogBuffer> makeInitialSyncOplogBuffer(OperationContext* opCtx) const override;
 
-    std::unique_ptr<OplogBuffer> makeSteadyStateOplogBuffer(OperationContext* txn) const override;
+    std::unique_ptr<OplogBuffer> makeSteadyStateOplogBuffer(OperationContext* opCtx) const override;
 
     StatusWith<ReplSetConfig> getCurrentConfig() const override;
 
 private:
-    StatusWith<OpTime> _multiApply(OperationContext* txn,
+    StatusWith<OpTime> _multiApply(OperationContext* opCtx,
                                    MultiApplier::Operations ops,
                                    MultiApplier::ApplyOperationFn applyOperation) override;
 
diff --git a/src/mongo/db/repl/data_replicator_external_state_mock.cpp b/src/mongo/db/repl/data_replicator_external_state_mock.cpp
index a5eb417b403..1f315aee521 100644
--- a/src/mongo/db/repl/data_replicator_external_state_mock.cpp
+++ b/src/mongo/db/repl/data_replicator_external_state_mock.cpp
@@ -81,12 +81,12 @@ bool DataReplicatorExternalStateMock::shouldStopFetching(
 }
 
 std::unique_ptr<OplogBuffer> DataReplicatorExternalStateMock::makeInitialSyncOplogBuffer(
-    OperationContext* txn) const {
+    OperationContext* opCtx) const {
     return stdx::make_unique<OplogBufferBlockingQueue>();
 }
 
 std::unique_ptr<OplogBuffer> DataReplicatorExternalStateMock::makeSteadyStateOplogBuffer(
-    OperationContext* txn) const {
+    OperationContext* opCtx) const {
     return stdx::make_unique<OplogBufferBlockingQueue>();
 }
 
@@ -95,10 +95,10 @@ StatusWith<ReplSetConfig> DataReplicatorExternalStateMock::getCurrentConfig() co
 }
 
 StatusWith<OpTime> DataReplicatorExternalStateMock::_multiApply(
-    OperationContext* txn,
+    OperationContext* opCtx,
     MultiApplier::Operations ops,
     MultiApplier::ApplyOperationFn applyOperation) {
-    return multiApplyFn(txn, std::move(ops), applyOperation);
+    return multiApplyFn(opCtx, std::move(ops), applyOperation);
 }
 
 Status DataReplicatorExternalStateMock::_multiSyncApply(MultiApplier::OperationPtrs* ops) {
diff --git a/src/mongo/db/repl/data_replicator_external_state_mock.h b/src/mongo/db/repl/data_replicator_external_state_mock.h
index ea2943a0749..88ff0df26c5 100644
--- a/src/mongo/db/repl/data_replicator_external_state_mock.h
+++ b/src/mongo/db/repl/data_replicator_external_state_mock.h
@@ -56,9 +56,9 @@ public:
                             const rpc::ReplSetMetadata& replMetadata,
                             boost::optional<rpc::OplogQueryMetadata> oqMetadata) override;
 
-    std::unique_ptr<OplogBuffer> makeInitialSyncOplogBuffer(OperationContext* txn) const override;
+    std::unique_ptr<OplogBuffer> makeInitialSyncOplogBuffer(OperationContext* opCtx) const override;
 
-    std::unique_ptr<OplogBuffer> makeSteadyStateOplogBuffer(OperationContext* txn) const override;
+    std::unique_ptr<OplogBuffer> makeSteadyStateOplogBuffer(OperationContext* opCtx) const override;
 
     StatusWith<ReplSetConfig> getCurrentConfig() const override;
 
@@ -97,7 +97,7 @@ public:
     StatusWith<ReplSetConfig> replSetConfigResult = ReplSetConfig();
 
 private:
-    StatusWith<OpTime> _multiApply(OperationContext* txn,
+    StatusWith<OpTime> _multiApply(OperationContext* opCtx,
                                    MultiApplier::Operations ops,
                                    MultiApplier::ApplyOperationFn applyOperation) override;
 
diff --git a/src/mongo/db/repl/data_replicator_test.cpp b/src/mongo/db/repl/data_replicator_test.cpp
index 9a6efec3f83..61a5dcb8f2d 100644
--- a/src/mongo/db/repl/data_replicator_test.cpp
+++ b/src/mongo/db/repl/data_replicator_test.cpp
@@ -265,31 +265,32 @@ protected:
     void setUp() override {
         executor::ThreadPoolExecutorTest::setUp();
         _storageInterface = stdx::make_unique<StorageInterfaceMock>();
-        _storageInterface->createOplogFn = [this](OperationContext* txn,
+        _storageInterface->createOplogFn = [this](OperationContext* opCtx,
                                                   const NamespaceString& nss) {
             LockGuard lock(_storageInterfaceWorkDoneMutex);
             _storageInterfaceWorkDone.createOplogCalled = true;
             return Status::OK();
         };
         _storageInterface->insertDocumentFn =
-            [this](OperationContext* txn, const NamespaceString& nss, const BSONObj& doc) {
+            [this](OperationContext* opCtx, const NamespaceString& nss, const BSONObj& doc) {
                 LockGuard lock(_storageInterfaceWorkDoneMutex);
                 ++_storageInterfaceWorkDone.documentsInsertedCount;
                 return Status::OK();
             };
         _storageInterface->insertDocumentsFn = [this](
-            OperationContext* txn, const NamespaceString& nss, const std::vector<BSONObj>& ops) {
+            OperationContext* opCtx, const NamespaceString& nss, const std::vector<BSONObj>& ops) {
             LockGuard lock(_storageInterfaceWorkDoneMutex);
             _storageInterfaceWorkDone.insertedOplogEntries = true;
             ++_storageInterfaceWorkDone.oplogEntriesInserted;
             return Status::OK();
         };
-        _storageInterface->dropCollFn = [this](OperationContext* txn, const NamespaceString& nss) {
+        _storageInterface->dropCollFn = [this](OperationContext* opCtx,
+                                               const NamespaceString& nss) {
             LockGuard lock(_storageInterfaceWorkDoneMutex);
             _storageInterfaceWorkDone.droppedCollections.push_back(nss.ns());
             return Status::OK();
         };
-        _storageInterface->dropUserDBsFn = [this](OperationContext* txn) {
+        _storageInterface->dropUserDBsFn = [this](OperationContext* opCtx) {
             LockGuard lock(_storageInterfaceWorkDoneMutex);
             _storageInterfaceWorkDone.droppedUserDBs = true;
             return Status::OK();
@@ -577,66 +578,66 @@ const std::uint32_t maxAttempts = 1U;
 
 TEST_F(DataReplicatorTest, StartupReturnsIllegalOperationIfAlreadyActive) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
     ASSERT_FALSE(dr->isActive());
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
     ASSERT_TRUE(dr->isActive());
-    ASSERT_EQUALS(ErrorCodes::IllegalOperation, dr->startup(txn.get(), maxAttempts));
+    ASSERT_EQUALS(ErrorCodes::IllegalOperation, dr->startup(opCtx.get(), maxAttempts));
     ASSERT_TRUE(dr->isActive());
 }
 
 TEST_F(DataReplicatorTest, StartupReturnsShutdownInProgressIfDataReplicatorIsShuttingDown) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
     ASSERT_FALSE(dr->isActive());
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
     ASSERT_TRUE(dr->isActive());
     // SyncSourceSelector returns an invalid sync source so DataReplicator is stuck waiting for
     // another sync source in 'Options::syncSourceRetryWait' ms.
     ASSERT_OK(dr->shutdown());
-    ASSERT_EQUALS(ErrorCodes::ShutdownInProgress, dr->startup(txn.get(), maxAttempts));
+    ASSERT_EQUALS(ErrorCodes::ShutdownInProgress, dr->startup(opCtx.get(), maxAttempts));
 }
 
 TEST_F(DataReplicatorTest, StartupReturnsShutdownInProgressIfExecutorIsShutdown) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
     getExecutor().shutdown();
-    ASSERT_EQUALS(ErrorCodes::ShutdownInProgress, dr->startup(txn.get(), maxAttempts));
+    ASSERT_EQUALS(ErrorCodes::ShutdownInProgress, dr->startup(opCtx.get(), maxAttempts));
     ASSERT_FALSE(dr->isActive());
 
     // Cannot startup data replicator again since it's in the Complete state.
-    ASSERT_EQUALS(ErrorCodes::ShutdownInProgress, dr->startup(txn.get(), maxAttempts));
+    ASSERT_EQUALS(ErrorCodes::ShutdownInProgress, dr->startup(opCtx.get(), maxAttempts));
 }
 
 TEST_F(DataReplicatorTest, ShutdownTransitionsStateToCompleteIfCalledBeforeStartup) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
     ASSERT_OK(dr->shutdown());
-    ASSERT_EQUALS(ErrorCodes::ShutdownInProgress, dr->startup(txn.get(), maxAttempts));
+    ASSERT_EQUALS(ErrorCodes::ShutdownInProgress, dr->startup(opCtx.get(), maxAttempts));
     // Data replicator is inactive when it's in the Complete state.
     ASSERT_FALSE(dr->isActive());
 }
 
 TEST_F(DataReplicatorTest, StartupSetsInitialSyncFlagOnSuccess) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     // Initial sync flag should not be set before starting.
-    ASSERT_FALSE(getStorage().getInitialSyncFlag(txn.get()));
+    ASSERT_FALSE(getStorage().getInitialSyncFlag(opCtx.get()));
 
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
     ASSERT_TRUE(dr->isActive());
 
     // Initial sync flag should be set.
-    ASSERT_TRUE(getStorage().getInitialSyncFlag(txn.get()));
+    ASSERT_TRUE(getStorage().getInitialSyncFlag(opCtx.get()));
 }
 
 TEST_F(DataReplicatorTest, DataReplicatorReturnsCallbackCanceledIfShutdownImmediatelyAfterStartup) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     // This will cancel the _startInitialSyncAttemptCallback() task scheduled by startup().
     ASSERT_OK(dr->shutdown());
@@ -655,13 +656,13 @@ TEST_F(DataReplicatorTest, DataReplicatorReturnsCallbackCanceledIfShutdownImmedi
 TEST_F(DataReplicatorTest,
        DataReplicatorRetriesSyncSourceSelectionIfChooseNewSyncSourceReturnsInvalidSyncSource) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     // Override chooseNewSyncSource() result in SyncSourceSelectorMock before calling startup()
     // because DataReplicator will look for a valid sync source immediately after startup.
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort());
 
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     // Run first sync source selection attempt.
     executor::NetworkInterfaceMock::InNetworkGuard(getNet())->runReadyNetworkOperations();
@@ -697,13 +698,13 @@ TEST_F(
     DataReplicatorTest,
     DataReplicatorReturnsInitialSyncOplogSourceMissingIfNoValidSyncSourceCanBeFoundAfterTenFailedChooseSyncSourceAttempts) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     // Override chooseNewSyncSource() result in SyncSourceSelectorMock before calling startup()
     // because DataReplicator will look for a valid sync source immediately after startup.
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort());
 
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     _simulateChooseSyncSourceFailure(getNet(), _options.syncSourceRetryWait);
 
@@ -718,12 +719,12 @@ TEST_F(
 TEST_F(DataReplicatorTest,
        DataReplicatorRetriesInitialSyncUpToMaxAttemptsAndReturnsLastAttemptError) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort());
 
     const std::uint32_t initialSyncMaxAttempts = 3U;
-    ASSERT_OK(dr->startup(txn.get(), initialSyncMaxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), initialSyncMaxAttempts));
 
     auto net = getNet();
     for (std::uint32_t i = 0; i < initialSyncMaxAttempts; ++i) {
@@ -748,10 +749,10 @@ TEST_F(DataReplicatorTest,
 TEST_F(DataReplicatorTest,
        DataReplicatorReturnsCallbackCanceledIfShutdownWhileRetryingSyncSourceSelection) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort());
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     {
@@ -774,11 +775,11 @@ TEST_F(
     DataReplicatorTest,
     DataReplicatorReturnsScheduleErrorIfTaskExecutorFailsToScheduleNextChooseSyncSourceCallback) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort());
     _executorProxy->shouldFailScheduleWorkAt = true;
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     dr->join();
 
@@ -788,13 +789,13 @@ TEST_F(
 TEST_F(DataReplicatorTest,
        DataReplicatorReturnsScheduleErrorIfTaskExecutorFailsToScheduleNextInitialSyncAttempt) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort());
 
     ASSERT_EQUALS(DataReplicator::State::kPreStart, dr->getState_forTest());
 
-    ASSERT_OK(dr->startup(txn.get(), 2U));
+    ASSERT_OK(dr->startup(opCtx.get(), 2U));
     ASSERT_EQUALS(DataReplicator::State::kRunning, dr->getState_forTest());
 
     // Advance clock so that we run all but the last sync source callback.
@@ -816,7 +817,7 @@ TEST_F(DataReplicatorTest,
 // the completion callback function throws an exception.
 TEST_F(DataReplicatorTest, DataReplicatorTransitionsToCompleteWhenFinishCallbackThrowsException) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _onCompletion = [this](const StatusWith<OpTimeWithHash>& lastApplied) {
         _lastApplied = lastApplied;
@@ -824,7 +825,7 @@ TEST_F(DataReplicatorTest, DataReplicatorTransitionsToCompleteWhenFinishCallback
     };
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort());
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     ASSERT_OK(dr->shutdown());
     dr->join();
@@ -862,9 +863,9 @@ TEST_F(DataReplicatorTest, DataReplicatorResetsOnCompletionCallbackFunctionPoint
         });
     ON_BLOCK_EXIT([this]() { getExecutor().shutdown(); });
 
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     sharedCallbackData.reset();
     ASSERT_FALSE(sharedCallbackStateDestroyed);
@@ -891,17 +892,17 @@ TEST_F(DataReplicatorTest, DataReplicatorRecreatesOplogAndDropsReplicatedDatabas
     // We are not interested in proceeding beyond the oplog creation stage so we inject a failure
     // after setting '_storageInterfaceWorkDone.createOplogCalled' to true.
     auto oldCreateOplogFn = _storageInterface->createOplogFn;
-    _storageInterface->createOplogFn = [oldCreateOplogFn](OperationContext* txn,
+    _storageInterface->createOplogFn = [oldCreateOplogFn](OperationContext* opCtx,
                                                           const NamespaceString& nss) {
-        oldCreateOplogFn(txn, nss);
+        oldCreateOplogFn(opCtx, nss);
         return Status(ErrorCodes::OperationFailed, "oplog creation failed");
     };
 
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     dr->join();
     ASSERT_EQUALS(ErrorCodes::OperationFailed, _lastApplied);
@@ -913,7 +914,7 @@ TEST_F(DataReplicatorTest, DataReplicatorRecreatesOplogAndDropsReplicatedDatabas
 
 TEST_F(DataReplicatorTest, DataReplicatorPassesThroughGetRollbackIdScheduleError) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     // replSetGetRBID is the first remote command to be scheduled by the data replicator after
     // creating the oplog collection.
@@ -925,7 +926,7 @@ TEST_F(DataReplicatorTest, DataReplicatorPassesThroughGetRollbackIdScheduleError
 
     HostAndPort syncSource("localhost", 12345);
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(syncSource);
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     dr->join();
     ASSERT_EQUALS(ErrorCodes::OperationFailed, _lastApplied);
@@ -942,18 +943,18 @@ TEST_F(
     // down before returning from createOplog() to make the scheduleRemoteCommand() call for
     // replSetGetRBID fail.
     auto oldCreateOplogFn = _storageInterface->createOplogFn;
-    _storageInterface->createOplogFn = [oldCreateOplogFn, this](OperationContext* txn,
+    _storageInterface->createOplogFn = [oldCreateOplogFn, this](OperationContext* opCtx,
                                                                 const NamespaceString& nss) {
-        auto status = oldCreateOplogFn(txn, nss);
+        auto status = oldCreateOplogFn(opCtx, nss);
         getExecutor().shutdown();
         return status;
     };
 
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     dr->join();
     ASSERT_EQUALS(ErrorCodes::ShutdownInProgress, _lastApplied);
@@ -964,14 +965,14 @@ TEST_F(
 
 TEST_F(DataReplicatorTest, DataReplicatorCancelsRollbackCheckerOnShutdown) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     HostAndPort syncSource("localhost", 12345);
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(syncSource);
 
     ASSERT_EQUALS(DataReplicator::State::kPreStart, dr->getState_forTest());
 
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
     ASSERT_EQUALS(DataReplicator::State::kRunning, dr->getState_forTest());
 
     auto net = getNet();
@@ -1000,10 +1001,10 @@ TEST_F(DataReplicatorTest, DataReplicatorCancelsRollbackCheckerOnShutdown) {
 
 TEST_F(DataReplicatorTest, DataReplicatorPassesThroughRollbackCheckerCallbackError) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     {
@@ -1021,7 +1022,7 @@ TEST_F(DataReplicatorTest, DataReplicatorPassesThroughRollbackCheckerCallbackErr
 
 TEST_F(DataReplicatorTest, DataReplicatorPassesThroughLastOplogEntryFetcherScheduleError) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     // The last oplog entry fetcher is the first component that sends a find command so we reject
     // any find commands and save the request for inspection at the end of this test case.
@@ -1033,7 +1034,7 @@ TEST_F(DataReplicatorTest, DataReplicatorPassesThroughLastOplogEntryFetcherSched
 
     HostAndPort syncSource("localhost", 12345);
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(syncSource);
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     {
@@ -1056,10 +1057,10 @@ TEST_F(DataReplicatorTest, DataReplicatorPassesThroughLastOplogEntryFetcherSched
 
 TEST_F(DataReplicatorTest, DataReplicatorPassesThroughLastOplogEntryFetcherCallbackError) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     {
@@ -1082,10 +1083,10 @@ TEST_F(DataReplicatorTest, DataReplicatorPassesThroughLastOplogEntryFetcherCallb
 
 TEST_F(DataReplicatorTest, DataReplicatorCancelsLastOplogEntryFetcherOnShutdown) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     {
@@ -1108,10 +1109,10 @@ TEST_F(DataReplicatorTest, DataReplicatorCancelsLastOplogEntryFetcherOnShutdown)
 TEST_F(DataReplicatorTest,
        DataReplicatorReturnsNoMatchingDocumentIfLastOplogEntryFetcherReturnsEmptyBatchOfDocuments) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     {
@@ -1132,10 +1133,10 @@ TEST_F(DataReplicatorTest,
 TEST_F(DataReplicatorTest,
        DataReplicatorResendsFindCommandIfLastOplogEntryFetcherReturnsRetriableError) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     executor::NetworkInterfaceMock::InNetworkGuard guard(net);
@@ -1159,10 +1160,10 @@ TEST_F(DataReplicatorTest,
 TEST_F(DataReplicatorTest,
        DataReplicatorReturnsNoSuchKeyIfLastOplogEntryFetcherReturnsEntryWithMissingHash) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     {
@@ -1183,10 +1184,10 @@ TEST_F(DataReplicatorTest,
 TEST_F(DataReplicatorTest,
        DataReplicatorReturnsNoSuchKeyIfLastOplogEntryFetcherReturnsEntryWithMissingTimestamp) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     {
@@ -1207,12 +1208,12 @@ TEST_F(DataReplicatorTest,
 TEST_F(DataReplicatorTest,
        DataReplicatorPassesThroughErrorFromDataReplicatorExternalStateGetCurrentConfig) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     getExternalState()->replSetConfigResult = Status(ErrorCodes::OperationFailed, "");
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     {
@@ -1232,7 +1233,7 @@ TEST_F(DataReplicatorTest,
 
 TEST_F(DataReplicatorTest, DataReplicatorPassesThroughOplogFetcherScheduleError) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     // Make the tailable oplog query fail. Allow all other requests to be scheduled.
     executor::RemoteCommandRequest request;
@@ -1247,7 +1248,7 @@ TEST_F(DataReplicatorTest, DataReplicatorPassesThroughOplogFetcherScheduleError)
 
     HostAndPort syncSource("localhost", 12345);
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(syncSource);
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     {
@@ -1273,10 +1274,10 @@ TEST_F(DataReplicatorTest, DataReplicatorPassesThroughOplogFetcherScheduleError)
 
 TEST_F(DataReplicatorTest, DataReplicatorPassesThroughOplogFetcherCallbackError) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     {
@@ -1311,10 +1312,10 @@ TEST_F(DataReplicatorTest, DataReplicatorPassesThroughOplogFetcherCallbackError)
 TEST_F(DataReplicatorTest,
        DataReplicatorSucceedsOnEarlyOplogFetcherCompletionIfThereAreNoOperationsToApply) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     {
@@ -1363,10 +1364,10 @@ TEST_F(
     DataReplicatorTest,
     DataReplicatorSucceedsOnEarlyOplogFetcherCompletionIfThereAreEnoughOperationsInTheOplogBufferToReachEndTimestamp) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     {
@@ -1412,10 +1413,10 @@ TEST_F(
     DataReplicatorTest,
     DataReplicatorReturnsRemoteResultsUnavailableOnEarlyOplogFetcherCompletionIfThereAreNotEnoughOperationsInTheOplogBufferToReachEndTimestamp) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     {
@@ -1456,7 +1457,7 @@ TEST_F(
 TEST_F(DataReplicatorTest,
        DataReplicatorPassesThroughDatabasesClonerScheduleErrorAndCancelsOplogFetcher) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     // Make the listDatabases command fail. Allow all other requests to be scheduled.
     executor::RemoteCommandRequest request;
@@ -1470,7 +1471,7 @@ TEST_F(DataReplicatorTest,
 
     HostAndPort syncSource("localhost", 12345);
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(syncSource);
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     {
@@ -1504,10 +1505,10 @@ TEST_F(DataReplicatorTest,
 TEST_F(DataReplicatorTest,
        DataReplicatorPassesThroughDatabasesClonerCallbackErrorAndCancelsOplogFetcher) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     {
@@ -1544,10 +1545,10 @@ TEST_F(DataReplicatorTest,
 
 TEST_F(DataReplicatorTest, DataReplicatorIgnoresLocalDatabasesWhenCloningDatabases) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     {
@@ -1604,10 +1605,10 @@ TEST_F(DataReplicatorTest, DataReplicatorIgnoresLocalDatabasesWhenCloningDatabas
 TEST_F(DataReplicatorTest,
        DataReplicatorIgnoresDatabaseInfoDocumentWithoutNameFieldWhenCloningDatabases) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     {
@@ -1670,10 +1671,10 @@ TEST_F(DataReplicatorTest,
 
 TEST_F(DataReplicatorTest, DataReplicatorCancelsBothOplogFetcherAndDatabasesClonerOnShutdown) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     {
@@ -1697,7 +1698,7 @@ TEST_F(DataReplicatorTest, DataReplicatorCancelsBothOplogFetcherAndDatabasesClon
 TEST_F(DataReplicatorTest,
        DataReplicatorPassesThroughSecondLastOplogEntryFetcherScheduleErrorAndCancelsOplogFetcher) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     // Make the second last oplog entry fetcher command fail. Allow all other requests to be
     // scheduled.
@@ -1718,7 +1719,7 @@ TEST_F(DataReplicatorTest,
     };
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     {
@@ -1758,10 +1759,10 @@ TEST_F(DataReplicatorTest,
 TEST_F(DataReplicatorTest,
        DataReplicatorPassesThroughSecondLastOplogEntryFetcherCallbackErrorAndCancelsOplogFetcher) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     {
@@ -1810,10 +1811,10 @@ TEST_F(DataReplicatorTest,
 TEST_F(DataReplicatorTest,
        DataReplicatorCancelsBothSecondLastOplogEntryFetcherAndOplogFetcherOnShutdown) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     {
@@ -1857,10 +1858,10 @@ TEST_F(DataReplicatorTest,
 TEST_F(DataReplicatorTest,
        DataReplicatorCancelsSecondLastOplogEntryFetcherOnOplogFetcherCallbackError) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     {
@@ -1914,10 +1915,10 @@ TEST_F(
     DataReplicatorTest,
     DataReplicatorReturnsTypeMismatchErrorWhenSecondLastOplogEntryFetcherReturnsMalformedDocument) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto oplogEntry = makeOplogEntry(1);
     auto net = getNet();
@@ -1963,10 +1964,10 @@ TEST_F(
 TEST_F(DataReplicatorTest,
        DataReplicatorReturnsOplogOutOfOrderIfStopTimestampPrecedesBeginTimestamp) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     {
@@ -2010,7 +2011,7 @@ TEST_F(
     DataReplicatorTest,
     DataReplicatorPassesThroughInsertOplogSeedDocumentErrorAfterDataCloningFinishesWithNoOperationsToApply) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     NamespaceString insertDocumentNss;
     BSONObj insertDocumentDoc;
@@ -2022,7 +2023,7 @@ TEST_F(
     };
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto oplogEntry = makeOplogEntry(1);
     auto net = getNet();
@@ -2069,7 +2070,7 @@ TEST_F(
     DataReplicatorTest,
     DataReplicatorReturnsCallbackCanceledAndDoesNotScheduleRollbackCheckerIfShutdownAfterInsertingInsertOplogSeedDocument) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     NamespaceString insertDocumentNss;
     BSONObj insertDocumentDoc;
@@ -2082,7 +2083,7 @@ TEST_F(
     };
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto oplogEntry = makeOplogEntry(1);
     auto net = getNet();
@@ -2129,7 +2130,7 @@ TEST_F(
     DataReplicatorTest,
     DataReplicatorPassesThroughRollbackCheckerScheduleErrorAfterCloningFinishesWithNoOperationsToApply) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     // Make the second replSetGetRBID command fail. Allow all other requests to be scheduled.
     executor::RemoteCommandRequest request;
@@ -2147,7 +2148,7 @@ TEST_F(
     };
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto oplogEntry = makeOplogEntry(1);
     auto net = getNet();
@@ -2192,10 +2193,10 @@ TEST_F(
     DataReplicatorTest,
     DataReplicatorPassesThroughRollbackCheckerCallbackErrorAfterCloningFinishesWithNoOperationsToApply) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto oplogEntry = makeOplogEntry(1);
     auto net = getNet();
@@ -2245,10 +2246,10 @@ TEST_F(
 
 TEST_F(DataReplicatorTest, DataReplicatorCancelsLastRollbackCheckerOnShutdown) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto oplogEntry = makeOplogEntry(1);
     auto net = getNet();
@@ -2299,10 +2300,10 @@ TEST_F(DataReplicatorTest, DataReplicatorCancelsLastRollbackCheckerOnShutdown) {
 
 TEST_F(DataReplicatorTest, DataReplicatorCancelsLastRollbackCheckerOnOplogFetcherCallbackError) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto oplogEntry = makeOplogEntry(1);
     auto net = getNet();
@@ -2357,10 +2358,10 @@ TEST_F(DataReplicatorTest, DataReplicatorCancelsLastRollbackCheckerOnOplogFetche
 TEST_F(DataReplicatorTest,
        DataReplicatorReturnsUnrecoverableRollbackErrorIfSyncSourceRolledBackAfterCloningData) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto oplogEntry = makeOplogEntry(1);
     auto net = getNet();
@@ -2405,12 +2406,12 @@ TEST_F(DataReplicatorTest,
 
 TEST_F(DataReplicatorTest, LastOpTimeShouldBeSetEvenIfNoOperationsAreAppliedAfterCloning) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
-    ASSERT_TRUE(_storageInterface->getInitialSyncFlag(txn.get()));
+    ASSERT_TRUE(_storageInterface->getInitialSyncFlag(opCtx.get()));
 
     auto oplogEntry = makeOplogEntry(1);
     auto net = getNet();
@@ -2488,17 +2489,17 @@ TEST_F(DataReplicatorTest, LastOpTimeShouldBeSetEvenIfNoOperationsAreAppliedAfte
     dr->join();
     ASSERT_EQUALS(OplogEntry(oplogEntry).getOpTime(), unittest::assertGet(_lastApplied).opTime);
     ASSERT_EQUALS(oplogEntry["h"].Long(), unittest::assertGet(_lastApplied).value);
-    ASSERT_FALSE(_storageInterface->getInitialSyncFlag(txn.get()));
+    ASSERT_FALSE(_storageInterface->getInitialSyncFlag(opCtx.get()));
 }
 
 TEST_F(DataReplicatorTest, DataReplicatorPassesThroughGetNextApplierBatchScheduleError) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
-    ASSERT_TRUE(_storageInterface->getInitialSyncFlag(txn.get()));
+    ASSERT_TRUE(_storageInterface->getInitialSyncFlag(opCtx.get()));
 
     auto net = getNet();
     int baseRollbackId = 1;
@@ -2547,12 +2548,12 @@ TEST_F(DataReplicatorTest, DataReplicatorPassesThroughGetNextApplierBatchSchedul
 
 TEST_F(DataReplicatorTest, DataReplicatorPassesThroughSecondGetNextApplierBatchScheduleError) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
-    ASSERT_TRUE(_storageInterface->getInitialSyncFlag(txn.get()));
+    ASSERT_TRUE(_storageInterface->getInitialSyncFlag(opCtx.get()));
 
     auto net = getNet();
     int baseRollbackId = 1;
@@ -2601,12 +2602,12 @@ TEST_F(DataReplicatorTest, DataReplicatorPassesThroughSecondGetNextApplierBatchS
 
 TEST_F(DataReplicatorTest, DataReplicatorCancelsGetNextApplierBatchOnShutdown) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
-    ASSERT_TRUE(_storageInterface->getInitialSyncFlag(txn.get()));
+    ASSERT_TRUE(_storageInterface->getInitialSyncFlag(opCtx.get()));
 
     auto net = getNet();
     int baseRollbackId = 1;
@@ -2651,12 +2652,12 @@ TEST_F(DataReplicatorTest, DataReplicatorCancelsGetNextApplierBatchOnShutdown) {
 
 TEST_F(DataReplicatorTest, DataReplicatorPassesThroughGetNextApplierBatchInLockError) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
-    ASSERT_TRUE(_storageInterface->getInitialSyncFlag(txn.get()));
+    ASSERT_TRUE(_storageInterface->getInitialSyncFlag(opCtx.get()));
 
     // _getNextApplierBatch_inlock() returns BadValue when it gets an oplog entry with an unexpected
     // version (not OplogEntry::kOplogVersion).
@@ -2715,12 +2716,12 @@ TEST_F(
     DataReplicatorTest,
     DataReplicatorReturnsEmptyBatchFromGetNextApplierBatchInLockIfRsSyncApplyStopFailPointIsEnabled) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
-    ASSERT_TRUE(_storageInterface->getInitialSyncFlag(txn.get()));
+    ASSERT_TRUE(_storageInterface->getInitialSyncFlag(opCtx.get()));
 
     // _getNextApplierBatch_inlock() returns BadValue when it gets an oplog entry with an unexpected
     // version (not OplogEntry::kOplogVersion).
@@ -2790,12 +2791,12 @@ TEST_F(
 TEST_F(DataReplicatorTest,
        DataReplicatorReturnsNoSuchKeyIfApplierBatchContainsAnOplogEntryWithoutHash) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
-    ASSERT_TRUE(_storageInterface->getInitialSyncFlag(txn.get()));
+    ASSERT_TRUE(_storageInterface->getInitialSyncFlag(opCtx.get()));
 
     // This oplog entry (without a required "h" field) will be read by OplogFetcher and inserted
     // into OplogBuffer to be retrieved by _getNextApplierBatch_inlock().
@@ -2848,12 +2849,12 @@ TEST_F(DataReplicatorTest,
 
 TEST_F(DataReplicatorTest, DataReplicatorPassesThroughMultiApplierScheduleError) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
-    ASSERT_TRUE(_storageInterface->getInitialSyncFlag(txn.get()));
+    ASSERT_TRUE(_storageInterface->getInitialSyncFlag(opCtx.get()));
 
     auto net = getNet();
     int baseRollbackId = 1;
@@ -2920,14 +2921,14 @@ TEST_F(DataReplicatorTest, DataReplicatorPassesThroughMultiApplierScheduleError)
 
 TEST_F(DataReplicatorTest, DataReplicatorPassesThroughMultiApplierCallbackError) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     getExternalState()->multiApplyFn =
         [](OperationContext*, const MultiApplier::Operations&, MultiApplier::ApplyOperationFn) {
             return Status(ErrorCodes::OperationFailed, "multiApply failed");
         };
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     int baseRollbackId = 1;
@@ -2975,10 +2976,10 @@ TEST_F(DataReplicatorTest, DataReplicatorPassesThroughMultiApplierCallbackError)
 
 TEST_F(DataReplicatorTest, DataReplicatorCancelsGetNextApplierBatchCallbackOnOplogFetcherError) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     int baseRollbackId = 1;
@@ -3026,10 +3027,10 @@ TEST_F(DataReplicatorTest, DataReplicatorCancelsGetNextApplierBatchCallbackOnOpl
 TEST_F(DataReplicatorTest,
        DataReplicatorReturnsLastAppliedOnReachingStopTimestampAfterApplyingOneBatch) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto lastOp = makeOplogEntry(2);
 
@@ -3088,10 +3089,10 @@ TEST_F(DataReplicatorTest,
 TEST_F(DataReplicatorTest,
        DataReplicatorReturnsLastAppliedOnReachingStopTimestampAfterApplyingMultipleBatches) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     // To make DataReplicator apply multiple batches, we make the third and last operation a command
     // so that it will go into a separate batch from the second operation. First operation is the
@@ -3186,7 +3187,7 @@ TEST_F(
     DataReplicatorTest,
     DataReplicatorSchedulesLastOplogEntryFetcherToGetNewStopTimestampIfMissingDocumentsHaveBeenFetchedDuringMultiInitialSyncApply) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     // Override DataReplicatorExternalState::_multiInitialSyncApply() so that it will also fetch a
     // missing document.
@@ -3210,7 +3211,7 @@ TEST_F(
     };
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     // Use command for third and last operation to ensure we have two batches to apply.
     auto lastOp = makeOplogEntry(3, "c");
@@ -3281,7 +3282,7 @@ TEST_F(
 TEST_F(DataReplicatorTest,
        DataReplicatorReturnsInvalidSyncSourceWhenFailInitialSyncWithBadHostFailpointIsEnabled) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     // This fail point makes chooseSyncSourceCallback fail with an InvalidSyncSource error.
     auto failPoint = getGlobalFailPointRegistry()->getFailPoint("failInitialSyncWithBadHost");
@@ -3289,7 +3290,7 @@ TEST_F(DataReplicatorTest,
     ON_BLOCK_EXIT([failPoint]() { failPoint->setMode(FailPoint::off); });
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     dr->join();
     ASSERT_EQUALS(ErrorCodes::InvalidSyncSource, _lastApplied);
@@ -3297,10 +3298,10 @@ TEST_F(DataReplicatorTest,
 
 TEST_F(DataReplicatorTest, OplogOutOfOrderOnOplogFetchFinish) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
-    ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+    ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
 
     auto net = getNet();
     int baseRollbackId = 1;
@@ -3346,10 +3347,10 @@ TEST_F(DataReplicatorTest, OplogOutOfOrderOnOplogFetchFinish) {
 
 TEST_F(DataReplicatorTest, GetInitialSyncProgressReturnsCorrectProgress) {
     auto dr = &getDR();
-    auto txn = makeOpCtx();
+    auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 27017));
-    ASSERT_OK(dr->startup(txn.get(), 2U));
+    ASSERT_OK(dr->startup(opCtx.get(), 2U));
 
     auto net = getNet();
     int baseRollbackId = 1;
diff --git a/src/mongo/db/repl/database_task.cpp b/src/mongo/db/repl/database_task.cpp
index b19bf201b5d..5c4f9422ea9 100644
--- a/src/mongo/db/repl/database_task.cpp
+++ b/src/mongo/db/repl/database_task.cpp
@@ -41,16 +41,16 @@ namespace repl {
 // static
 DatabaseTask::Task DatabaseTask::makeGlobalExclusiveLockTask(const Task& task) {
     invariant(task);
-    DatabaseTask::Task newTask = [task](OperationContext* txn, const Status& status) {
+    DatabaseTask::Task newTask = [task](OperationContext* opCtx, const Status& status) {
         if (!status.isOK()) {
-            return task(txn, status);
+            return task(opCtx, status);
         }
         MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
-            ScopedTransaction transaction(txn, MODE_X);
-            Lock::GlobalWrite lock(txn->lockState());
-            return task(txn, status);
+            ScopedTransaction transaction(opCtx, MODE_X);
+            Lock::GlobalWrite lock(opCtx->lockState());
+            return task(opCtx, status);
         }
-        MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "globalExclusiveLockTask", "global");
+        MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "globalExclusiveLockTask", "global");
         MONGO_UNREACHABLE;
     };
     return newTask;
@@ -61,17 +61,17 @@ DatabaseTask::Task DatabaseTask::makeDatabaseLockTask(const Task& task,
                                                       const std::string& databaseName,
                                                       LockMode mode) {
     invariant(task);
-    DatabaseTask::Task newTask = [=](OperationContext* txn, const Status& status) {
+    DatabaseTask::Task newTask = [=](OperationContext* opCtx, const Status& status) {
         if (!status.isOK()) {
-            return task(txn, status);
+            return task(opCtx, status);
         }
         MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
             LockMode permissiveLockMode = isSharedLockMode(mode) ? MODE_IS : MODE_IX;
-            ScopedTransaction transaction(txn, permissiveLockMode);
-            Lock::DBLock lock(txn->lockState(), databaseName, mode);
-            return task(txn, status);
+            ScopedTransaction transaction(opCtx, permissiveLockMode);
+            Lock::DBLock lock(opCtx->lockState(), databaseName, mode);
+            return task(opCtx, status);
         }
-        MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "databaseLockTask", databaseName);
+        MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "databaseLockTask", databaseName);
         MONGO_UNREACHABLE;
     };
     return newTask;
@@ -82,18 +82,18 @@ DatabaseTask::Task DatabaseTask::makeCollectionLockTask(const Task& task,
                                                         const NamespaceString& nss,
                                                         LockMode mode) {
     invariant(task);
-    DatabaseTask::Task newTask = [=](OperationContext* txn, const Status& status) {
+    DatabaseTask::Task newTask = [=](OperationContext* opCtx, const Status& status) {
         if (!status.isOK()) {
-            return task(txn, status);
+            return task(opCtx, status);
         }
         MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
             LockMode permissiveLockMode = isSharedLockMode(mode) ? MODE_IS : MODE_IX;
-            ScopedTransaction transaction(txn, permissiveLockMode);
-            Lock::DBLock lock(txn->lockState(), nss.db(), permissiveLockMode);
-            Lock::CollectionLock collectionLock(txn->lockState(), nss.toString(), mode);
-            return task(txn, status);
+            ScopedTransaction transaction(opCtx, permissiveLockMode);
+            Lock::DBLock lock(opCtx->lockState(), nss.db(), permissiveLockMode);
+            Lock::CollectionLock collectionLock(opCtx->lockState(), nss.toString(), mode);
+            return task(opCtx, status);
         }
-        MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "collectionLockTask", nss.toString());
+        MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "collectionLockTask", nss.toString());
         MONGO_UNREACHABLE;
     };
     return newTask;
diff --git a/src/mongo/db/repl/database_task_test.cpp b/src/mongo/db/repl/database_task_test.cpp
index 5c004c466d7..beaa896acf0 100644
--- a/src/mongo/db/repl/database_task_test.cpp
+++ b/src/mongo/db/repl/database_task_test.cpp
@@ -49,8 +49,8 @@ class DatabaseTaskTest : public TaskRunnerTest {};
 
 TEST_F(DatabaseTaskTest, TaskRunnerErrorStatus) {
     // Should not attempt to acquire lock on error status from task runner.
-    auto task = [](OperationContext* txn, const Status& status) {
-        ASSERT_FALSE(txn);
+    auto task = [](OperationContext* opCtx, const Status& status) {
+        ASSERT_FALSE(opCtx);
         ASSERT_EQUALS(ErrorCodes::BadValue, status.code());
         return TaskRunner::NextAction::kInvalid;
     };
@@ -66,15 +66,15 @@ TEST_F(DatabaseTaskTest, TaskRunnerErrorStatus) {
 TEST_F(DatabaseTaskTest, RunGlobalExclusiveLockTask) {
     stdx::mutex mutex;
     bool called = false;
-    OperationContext* txn = nullptr;
+    OperationContext* opCtx = nullptr;
     bool lockIsW = false;
     Status status = getDetectableErrorStatus();
     // Task returning 'void' implies NextAction::NoAction.
     auto task = [&](OperationContext* theTxn, const Status& theStatus) {
         stdx::lock_guard<stdx::mutex> lk(mutex);
         called = true;
-        txn = theTxn;
-        lockIsW = txn->lockState()->isW();
+        opCtx = theTxn;
+        lockIsW = opCtx->lockState()->isW();
         status = theStatus;
         return TaskRunner::NextAction::kCancel;
     };
@@ -84,7 +84,7 @@ TEST_F(DatabaseTaskTest, RunGlobalExclusiveLockTask) {
 
     stdx::lock_guard<stdx::mutex> lk(mutex);
     ASSERT_TRUE(called);
-    ASSERT(txn);
+    ASSERT(opCtx);
     ASSERT_TRUE(lockIsW);
     ASSERT_OK(status);
 }
@@ -92,15 +92,15 @@ TEST_F(DatabaseTaskTest, RunGlobalExclusiveLockTask) {
 void _testRunDatabaseLockTask(DatabaseTaskTest& test, LockMode mode) {
     stdx::mutex mutex;
     bool called = false;
-    OperationContext* txn = nullptr;
+    OperationContext* opCtx = nullptr;
     bool isDatabaseLockedForMode = false;
     Status status = test.getDetectableErrorStatus();
     // Task returning 'void' implies NextAction::NoAction.
     auto task = [&](OperationContext* theTxn, const Status& theStatus) {
         stdx::lock_guard<stdx::mutex> lk(mutex);
         called = true;
-        txn = theTxn;
-        isDatabaseLockedForMode = txn->lockState()->isDbLockedForMode(databaseName, mode);
+        opCtx = theTxn;
+        isDatabaseLockedForMode = opCtx->lockState()->isDbLockedForMode(databaseName, mode);
         status = theStatus;
         return TaskRunner::NextAction::kCancel;
     };
@@ -110,7 +110,7 @@ void _testRunDatabaseLockTask(DatabaseTaskTest& test, LockMode mode) {
 
     stdx::lock_guard<stdx::mutex> lk(mutex);
     ASSERT_TRUE(called);
-    ASSERT(txn);
+    ASSERT(opCtx);
     ASSERT_TRUE(isDatabaseLockedForMode);
     ASSERT_OK(status);
 }
@@ -134,16 +134,16 @@ TEST_F(DatabaseTaskTest, RunDatabaseLockTaskModeIS) {
 void _testRunCollectionLockTask(DatabaseTaskTest& test, LockMode mode) {
     stdx::mutex mutex;
     bool called = false;
-    OperationContext* txn = nullptr;
+    OperationContext* opCtx = nullptr;
     bool isCollectionLockedForMode = false;
     Status status = test.getDetectableErrorStatus();
     // Task returning 'void' implies NextAction::NoAction.
     auto task = [&](OperationContext* theTxn, const Status& theStatus) {
         stdx::lock_guard<stdx::mutex> lk(mutex);
         called = true;
-        txn = theTxn;
+        opCtx = theTxn;
         isCollectionLockedForMode =
-            txn->lockState()->isCollectionLockedForMode(nss.toString(), mode);
+            opCtx->lockState()->isCollectionLockedForMode(nss.toString(), mode);
         status = theStatus;
         return TaskRunner::NextAction::kCancel;
     };
@@ -153,7 +153,7 @@ void _testRunCollectionLockTask(DatabaseTaskTest& test, LockMode mode) {
 
     stdx::lock_guard<stdx::mutex> lk(mutex);
     ASSERT_TRUE(called);
-    ASSERT(txn);
+    ASSERT(opCtx);
     ASSERT_TRUE(isCollectionLockedForMode);
     ASSERT_OK(status);
 }
diff --git a/src/mongo/db/repl/databases_cloner.cpp b/src/mongo/db/repl/databases_cloner.cpp
index 3f7c1ce11e4..ff0c9170e15 100644
--- a/src/mongo/db/repl/databases_cloner.cpp
+++ b/src/mongo/db/repl/databases_cloner.cpp
@@ -354,13 +354,13 @@ void DatabasesCloner::_onEachDBCloneFinish(const Status& status, const std::stri
         auto adminStatus = Status(ErrorCodes::NotYetInitialized, "");
         {
             // TODO: Move isAdminDbValid() out of the collection/database cloner code paths.
-            OperationContext* txn = cc().getOperationContext();
-            ServiceContext::UniqueOperationContext txnPtr;
-            if (!txn) {
-                txnPtr = cc().makeOperationContext();
-                txn = txnPtr.get();
+            OperationContext* opCtx = cc().getOperationContext();
+            ServiceContext::UniqueOperationContext opCtxPtr;
+            if (!opCtx) {
+                opCtxPtr = cc().makeOperationContext();
+                opCtx = opCtxPtr.get();
             }
-            adminStatus = _storage->isAdminDbValid(txn);
+            adminStatus = _storage->isAdminDbValid(opCtx);
         }
         if (!adminStatus.isOK()) {
             LOG(1) << "Validation failed on 'admin' db due to " << adminStatus;
diff --git a/src/mongo/db/repl/databases_cloner_test.cpp b/src/mongo/db/repl/databases_cloner_test.cpp
index 366e8c04a7c..777a4eedacd 100644
--- a/src/mongo/db/repl/databases_cloner_test.cpp
+++ b/src/mongo/db/repl/databases_cloner_test.cpp
@@ -142,27 +142,27 @@ protected:
         executor::ThreadPoolExecutorTest::setUp();
         launchExecutorThread();
 
-        _storageInterface.createOplogFn = [this](OperationContext* txn,
+        _storageInterface.createOplogFn = [this](OperationContext* opCtx,
                                                  const NamespaceString& nss) {
             _storageInterfaceWorkDone.createOplogCalled = true;
             return Status::OK();
         };
         _storageInterface.insertDocumentFn =
-            [this](OperationContext* txn, const NamespaceString& nss, const BSONObj& doc) {
+            [this](OperationContext* opCtx, const NamespaceString& nss, const BSONObj& doc) {
                 ++_storageInterfaceWorkDone.documentsInsertedCount;
                 return Status::OK();
             };
         _storageInterface.insertDocumentsFn = [this](
-            OperationContext* txn, const NamespaceString& nss, const std::vector<BSONObj>& ops) {
+            OperationContext* opCtx, const NamespaceString& nss, const std::vector<BSONObj>& ops) {
             _storageInterfaceWorkDone.insertedOplogEntries = true;
             ++_storageInterfaceWorkDone.oplogEntriesInserted;
             return Status::OK();
         };
-        _storageInterface.dropCollFn = [this](OperationContext* txn, const NamespaceString& nss) {
+        _storageInterface.dropCollFn = [this](OperationContext* opCtx, const NamespaceString& nss) {
             _storageInterfaceWorkDone.droppedCollections.push_back(nss.ns());
             return Status::OK();
         };
-        _storageInterface.dropUserDBsFn = [this](OperationContext* txn) {
+        _storageInterface.dropUserDBsFn = [this](OperationContext* opCtx) {
             _storageInterfaceWorkDone.droppedUserDBs = true;
             return Status::OK();
         };
@@ -728,9 +728,9 @@ TEST_F(DBsClonerTest, DatabaseClonerChecksAdminDbUsingStorageInterfaceAfterCopyi
     bool isAdminDbValidFnCalled = false;
     OperationContext* isAdminDbValidFnOpCtx = nullptr;
     _storageInterface.isAdminDbValidFn = [&isAdminDbValidFnCalled,
-                                          &isAdminDbValidFnOpCtx](OperationContext* txn) {
+                                          &isAdminDbValidFnOpCtx](OperationContext* opCtx) {
         isAdminDbValidFnCalled = true;
-        isAdminDbValidFnOpCtx = txn;
+        isAdminDbValidFnOpCtx = opCtx;
         return Status::OK();
     };
 
@@ -770,7 +770,7 @@ TEST_F(DBsClonerTest, AdminDbValidationErrorShouldAbortTheCloner) {
     Status result = getDetectableErrorStatus();
 
     bool isAdminDbValidFnCalled = false;
-    _storageInterface.isAdminDbValidFn = [&isAdminDbValidFnCalled](OperationContext* txn) {
+    _storageInterface.isAdminDbValidFn = [&isAdminDbValidFnCalled](OperationContext* opCtx) {
         isAdminDbValidFnCalled = true;
         return Status(ErrorCodes::OperationFailed, "admin db invalid");
     };
diff --git a/src/mongo/db/repl/initial_sync.cpp b/src/mongo/db/repl/initial_sync.cpp
index 3c010185e64..ba5953f0035 100644
--- a/src/mongo/db/repl/initial_sync.cpp
+++ b/src/mongo/db/repl/initial_sync.cpp
@@ -52,26 +52,26 @@ InitialSync::~InitialSync() {}
 
 /* initial oplog application, during initial sync, after cloning.
 */
-void InitialSync::oplogApplication(OperationContext* txn, const OpTime& endOpTime) {
+void InitialSync::oplogApplication(OperationContext* opCtx, const OpTime& endOpTime) {
     if (replSetForceInitialSyncFailure > 0) {
         log() << "test code invoked, forced InitialSync failure: "
               << replSetForceInitialSyncFailure;
         replSetForceInitialSyncFailure--;
         throw DBException("forced error", 0);
     }
-    _applyOplogUntil(txn, endOpTime);
+    _applyOplogUntil(opCtx, endOpTime);
 }
 
 
 /* applies oplog from "now" until endOpTime using the applier threads for initial sync*/
-void InitialSync::_applyOplogUntil(OperationContext* txn, const OpTime& endOpTime) {
+void InitialSync::_applyOplogUntil(OperationContext* opCtx, const OpTime& endOpTime) {
     unsigned long long bytesApplied = 0;
     unsigned long long entriesApplied = 0;
     while (true) {
         OpQueue ops;
 
-        auto replCoord = repl::ReplicationCoordinator::get(txn);
-        while (!tryPopAndWaitForMore(txn, &ops, BatchLimits{})) {
+        auto replCoord = repl::ReplicationCoordinator::get(opCtx);
+        while (!tryPopAndWaitForMore(opCtx, &ops, BatchLimits{})) {
             if (globalInShutdownDeprecated()) {
                 return;
             }
@@ -108,10 +108,10 @@ void InitialSync::_applyOplogUntil(OperationContext* txn, const OpTime& endOpTim
         // Tally operation information and apply batch. Don't use ops again after these lines.
         bytesApplied += ops.getBytes();
         entriesApplied += ops.getCount();
-        const OpTime lastOpTime = multiApply(txn, ops.releaseBatch());
+        const OpTime lastOpTime = multiApply(opCtx, ops.releaseBatch());
 
         replCoord->setMyLastAppliedOpTime(lastOpTime);
-        setNewTimestamp(txn->getServiceContext(), lastOpTime.getTimestamp());
+        setNewTimestamp(opCtx->getServiceContext(), lastOpTime.getTimestamp());
 
         if (globalInShutdownDeprecated()) {
             return;
diff --git a/src/mongo/db/repl/initial_sync.h b/src/mongo/db/repl/initial_sync.h
index 167038363a7..3afce50a11d 100644
--- a/src/mongo/db/repl/initial_sync.h
+++ b/src/mongo/db/repl/initial_sync.h
@@ -47,7 +47,7 @@ public:
     /**
      * applies up to endOpTime, fetching missing documents as needed.
      */
-    void oplogApplication(OperationContext* txn, const OpTime& endOpTime);
+    void oplogApplication(OperationContext* opCtx, const OpTime& endOpTime);
 
 private:
     /**
@@ -55,7 +55,7 @@ private:
      *
      * NOTE:Will not transition or check states
      */
-    void _applyOplogUntil(OperationContext* txn, const OpTime& endOpTime);
+    void _applyOplogUntil(OperationContext* opCtx, const OpTime& endOpTime);
 };
 
 // Used for ReplSetTest testing.
diff --git a/src/mongo/db/repl/master_slave.cpp b/src/mongo/db/repl/master_slave.cpp
index 7c48ec8671c..10540c0fd3c 100644
--- a/src/mongo/db/repl/master_slave.cpp
+++ b/src/mongo/db/repl/master_slave.cpp
@@ -95,7 +95,7 @@ const int restartSync = 0;
 const int restartSyncAfterSleep = 1;
 }  // namespace
 
-void pretouchOperation(OperationContext* txn, const BSONObj& op);
+void pretouchOperation(OperationContext* opCtx, const BSONObj& op);
 void pretouchN(vector<BSONObj>&, unsigned a, unsigned b);
 
 /* if 1 sync() is running */
@@ -114,12 +114,12 @@ struct ReplInfo {
 };
 
 
-ReplSource::ReplSource(OperationContext* txn) {
+ReplSource::ReplSource(OperationContext* opCtx) {
     nClonedThisPass = 0;
-    ensureMe(txn);
+    ensureMe(opCtx);
 }
 
-ReplSource::ReplSource(OperationContext* txn, BSONObj o) : nClonedThisPass(0) {
+ReplSource::ReplSource(OperationContext* opCtx, BSONObj o) : nClonedThisPass(0) {
     only = o.getStringField("only");
     hostName = o.getStringField("host");
     _sourceName = o.getStringField("source");
@@ -155,7 +155,7 @@ ReplSource::ReplSource(OperationContext* txn, BSONObj o) : nClonedThisPass(0) {
             incompleteCloneDbs.insert(e.fieldName());
         }
     }
-    ensureMe(txn);
+    ensureMe(opCtx);
 }
 
 /* Turn our C++ Source object into a BSONObj */
@@ -189,31 +189,31 @@ BSONObj ReplSource::jsobj() {
     return b.obj();
 }
 
-void ReplSource::ensureMe(OperationContext* txn) {
+void ReplSource::ensureMe(OperationContext* opCtx) {
     string myname = getHostName();
 
     // local.me is an identifier for a server for getLastError w:2+
-    bool exists = Helpers::getSingleton(txn, "local.me", _me);
+    bool exists = Helpers::getSingleton(opCtx, "local.me", _me);
 
     if (!exists || !_me.hasField("host") || _me["host"].String() != myname) {
-        ScopedTransaction transaction(txn, MODE_IX);
-        Lock::DBLock dblk(txn->lockState(), "local", MODE_X);
-        WriteUnitOfWork wunit(txn);
+        ScopedTransaction transaction(opCtx, MODE_IX);
+        Lock::DBLock dblk(opCtx->lockState(), "local", MODE_X);
+        WriteUnitOfWork wunit(opCtx);
         // clean out local.me
-        Helpers::emptyCollection(txn, "local.me");
+        Helpers::emptyCollection(opCtx, "local.me");
 
         // repopulate
         BSONObjBuilder b;
         b.appendOID("_id", 0, true);
         b.append("host", myname);
         _me = b.obj();
-        Helpers::putSingleton(txn, "local.me", _me);
+        Helpers::putSingleton(opCtx, "local.me", _me);
         wunit.commit();
     }
     _me = _me.getOwned();
 }
 
-void ReplSource::save(OperationContext* txn) {
+void ReplSource::save(OperationContext* opCtx) {
     BSONObjBuilder b;
     verify(!hostName.empty());
     b.append("host", hostName);
@@ -226,7 +226,7 @@ void ReplSource::save(OperationContext* txn) {
     LOG(1) << "Saving repl source: " << o << endl;
 
     {
-        OldClientContext ctx(txn, "local.sources", false);
+        OldClientContext ctx(opCtx, "local.sources", false);
 
         const NamespaceString requestNs("local.sources");
         UpdateRequest request(requestNs);
@@ -235,14 +235,14 @@ void ReplSource::save(OperationContext* txn) {
         request.setUpdates(o);
         request.setUpsert();
 
-        UpdateResult res = update(txn, ctx.db(), request);
+        UpdateResult res = update(opCtx, ctx.db(), request);
 
         verify(!res.modifiers);
         verify(res.numMatched == 1 || !res.upserted.isEmpty());
     }
 }
 
-static void addSourceToList(OperationContext* txn,
+static void addSourceToList(OperationContext* opCtx,
                             ReplSource::SourceVector& v,
                             ReplSource& s,
                             ReplSource::SourceVector& old) {
@@ -263,9 +263,9 @@ static void addSourceToList(OperationContext* txn,
 /* we reuse our existing objects so that we can keep our existing connection
    and cursor in effect.
 */
-void ReplSource::loadAll(OperationContext* txn, SourceVector& v) {
+void ReplSource::loadAll(OperationContext* opCtx, SourceVector& v) {
     const char* localSources = "local.sources";
-    OldClientContext ctx(txn, localSources, false);
+    OldClientContext ctx(opCtx, localSources, false);
     SourceVector old = v;
     v.clear();
 
@@ -275,13 +275,16 @@ void ReplSource::loadAll(OperationContext* txn, SourceVector& v) {
         // check that no items are in sources other than that
         // add if missing
         int n = 0;
-        unique_ptr<PlanExecutor> exec(InternalPlanner::collectionScan(
-            txn, localSources, ctx.db()->getCollection(localSources), PlanExecutor::YIELD_MANUAL));
+        unique_ptr<PlanExecutor> exec(
+            InternalPlanner::collectionScan(opCtx,
+                                            localSources,
+                                            ctx.db()->getCollection(localSources),
+                                            PlanExecutor::YIELD_MANUAL));
         BSONObj obj;
         PlanExecutor::ExecState state;
         while (PlanExecutor::ADVANCED == (state = exec->getNext(&obj, NULL))) {
             n++;
-            ReplSource tmp(txn, obj);
+            ReplSource tmp(opCtx, obj);
             if (tmp.hostName != replSettings.getSource()) {
                 log() << "--source " << replSettings.getSource() << " != " << tmp.hostName
                       << " from local.sources collection" << endl;
@@ -303,10 +306,10 @@ void ReplSource::loadAll(OperationContext* txn, SourceVector& v) {
         uassert(10002, "local.sources collection corrupt?", n < 2);
         if (n == 0) {
             // source missing.  add.
-            ReplSource s(txn);
+            ReplSource s(opCtx);
             s.hostName = replSettings.getSource();
             s.only = replSettings.getOnly();
-            s.save(txn);
+            s.save(opCtx);
         }
     } else {
         try {
@@ -317,41 +320,41 @@ void ReplSource::loadAll(OperationContext* txn, SourceVector& v) {
     }
 
     unique_ptr<PlanExecutor> exec(InternalPlanner::collectionScan(
-        txn, localSources, ctx.db()->getCollection(localSources), PlanExecutor::YIELD_MANUAL));
+        opCtx, localSources, ctx.db()->getCollection(localSources), PlanExecutor::YIELD_MANUAL));
     BSONObj obj;
     PlanExecutor::ExecState state;
     while (PlanExecutor::ADVANCED == (state = exec->getNext(&obj, NULL))) {
-        ReplSource tmp(txn, obj);
+        ReplSource tmp(opCtx, obj);
         if (tmp.syncedTo.isNull()) {
-            DBDirectClient c(txn);
+            DBDirectClient c(opCtx);
             BSONObj op = c.findOne("local.oplog.$main",
                                    QUERY("op" << NE << "n").sort(BSON("$natural" << -1)));
             if (!op.isEmpty()) {
                 tmp.syncedTo = op["ts"].timestamp();
             }
         }
-        addSourceToList(txn, v, tmp, old);
+        addSourceToList(opCtx, v, tmp, old);
     }
     uassert(17066, "Internal error reading from local.sources", PlanExecutor::IS_EOF == state);
 }
 
-bool ReplSource::throttledForceResyncDead(OperationContext* txn, const char* requester) {
+bool ReplSource::throttledForceResyncDead(OperationContext* opCtx, const char* requester) {
     if (time(0) - lastForcedResync > 600) {
-        forceResyncDead(txn, requester);
+        forceResyncDead(opCtx, requester);
         lastForcedResync = time(0);
         return true;
     }
     return false;
 }
 
-void ReplSource::forceResyncDead(OperationContext* txn, const char* requester) {
+void ReplSource::forceResyncDead(OperationContext* opCtx, const char* requester) {
     if (!replAllDead)
         return;
     SourceVector sources;
-    ReplSource::loadAll(txn, sources);
+    ReplSource::loadAll(opCtx, sources);
     for (SourceVector::iterator i = sources.begin(); i != sources.end(); ++i) {
         log() << requester << " forcing resync from " << (*i)->hostName << endl;
-        (*i)->forceResync(txn, requester);
+        (*i)->forceResync(opCtx, requester);
     }
     replAllDead = 0;
 }
@@ -379,7 +382,7 @@ public:
         out->push_back(Privilege(ResourcePattern::forClusterResource(), actions));
     }
 
-    virtual bool run(OperationContext* txn,
+    virtual bool run(OperationContext* opCtx,
                      const string& ns,
                      BSONObj& cmdObj,
                      int options,
@@ -391,9 +394,9 @@ public:
             return appendCommandStatus(result, status);
         }
 
-        ReplClientInfo::forClient(txn->getClient()).setRemoteID(handshake.getRid());
+        ReplClientInfo::forClient(opCtx->getClient()).setRemoteID(handshake.getRid());
 
-        status = getGlobalReplicationCoordinator()->processHandshake(txn, handshake);
+        status = getGlobalReplicationCoordinator()->processHandshake(opCtx, handshake);
         return appendCommandStatus(result, status);
     }
 
@@ -429,12 +432,12 @@ bool ReplSource::_connect(OplogReader* reader, const HostAndPort& host, const OI
 }
 
 
-void ReplSource::forceResync(OperationContext* txn, const char* requester) {
+void ReplSource::forceResync(OperationContext* opCtx, const char* requester) {
     BSONObj info;
     {
         // This is always a GlobalWrite lock (so no ns/db used from the context)
-        invariant(txn->lockState()->isW());
-        Lock::TempRelease tempRelease(txn->lockState());
+        invariant(opCtx->lockState()->isW());
+        Lock::TempRelease tempRelease(opCtx->lockState());
 
         if (!_connect(&oplogReader,
                       HostAndPort(hostName),
@@ -456,14 +459,14 @@ void ReplSource::forceResync(OperationContext* txn, const char* requester) {
         if (!e.embeddedObject().getBoolField("empty")) {
             if (name != "local") {
                 if (only.empty() || only == name) {
-                    resyncDrop(txn, name);
+                    resyncDrop(opCtx, name);
                 }
             }
         }
     }
     syncedTo = Timestamp();
     addDbNextPass.clear();
-    save(txn);
+    save(opCtx);
 }
 
 Status ReplSource::_updateIfDoneWithInitialSync() {
@@ -483,23 +486,23 @@ Status ReplSource::_updateIfDoneWithInitialSync() {
     return Status::OK();
 }
 
-void ReplSource::resyncDrop(OperationContext* txn, const string& dbName) {
+void ReplSource::resyncDrop(OperationContext* opCtx, const string& dbName) {
     log() << "resync: dropping database " << dbName;
-    invariant(txn->lockState()->isW());
+    invariant(opCtx->lockState()->isW());
 
-    Database* const db = dbHolder().get(txn, dbName);
+    Database* const db = dbHolder().get(opCtx, dbName);
     if (!db) {
         log() << "resync: dropping database " << dbName
               << " - database does not exist. nothing to do.";
         return;
     }
-    Database::dropDatabase(txn, db);
+    Database::dropDatabase(opCtx, db);
 }
 
 /* grab initial copy of a database from the master */
-void ReplSource::resync(OperationContext* txn, const std::string& dbName) {
+void ReplSource::resync(OperationContext* opCtx, const std::string& dbName) {
     const std::string db(dbName);  // need local copy of the name, we're dropping the original
-    resyncDrop(txn, db);
+    resyncDrop(opCtx, db);
 
     {
         log() << "resync: cloning database " << db << " to get an initial copy" << endl;
@@ -512,11 +515,11 @@ void ReplSource::resync(OperationContext* txn, const std::string& dbName) {
         cloneOptions.snapshot = true;
 
         Cloner cloner;
-        Status status = cloner.copyDb(txn, db, hostName.c_str(), cloneOptions, NULL);
+        Status status = cloner.copyDb(opCtx, db, hostName.c_str(), cloneOptions, NULL);
 
         if (!status.isOK()) {
             if (status.code() == ErrorCodes::DatabaseDifferCase) {
-                resyncDrop(txn, db);
+                resyncDrop(opCtx, db);
                 log() << "resync: database " << db
                       << " not valid on the master due to a name conflict, dropping.";
                 return;
@@ -552,12 +555,12 @@ bool DatabaseIgnorer::ignoreAt(const string& db, const Timestamp& currentOplogTi
     }
 }
 
-bool ReplSource::handleDuplicateDbName(OperationContext* txn,
+bool ReplSource::handleDuplicateDbName(OperationContext* opCtx,
                                        const BSONObj& op,
                                        const char* ns,
                                        const char* db) {
     // We are already locked at this point
-    if (dbHolder().get(txn, ns) != NULL) {
+    if (dbHolder().get(opCtx, ns) != NULL) {
         // Database is already present.
         return true;
     }
@@ -577,8 +580,8 @@ bool ReplSource::handleDuplicateDbName(OperationContext* txn,
     bool dbOk = false;
     {
         // This is always a GlobalWrite lock (so no ns/db used from the context)
-        invariant(txn->lockState()->isW());
-        Lock::TempRelease tempRelease(txn->lockState());
+        invariant(opCtx->lockState()->isW());
+        Lock::TempRelease tempRelease(opCtx->lockState());
 
         // We always log an operation after executing it (never before), so
         // a database list will always be valid as of an oplog entry generated
@@ -634,8 +637,8 @@ bool ReplSource::handleDuplicateDbName(OperationContext* txn,
         incompleteCloneDbs.erase(*i);
         addDbNextPass.erase(*i);
 
-        AutoGetDb autoDb(txn, *i, MODE_X);
-        Database::dropDatabase(txn, autoDb.getDb());
+        AutoGetDb autoDb(opCtx, *i, MODE_X);
+        Database::dropDatabase(opCtx, autoDb.getDb());
     }
 
     massert(14034,
@@ -644,16 +647,16 @@ bool ReplSource::handleDuplicateDbName(OperationContext* txn,
     return true;
 }
 
-void ReplSource::applyCommand(OperationContext* txn, const BSONObj& op) {
+void ReplSource::applyCommand(OperationContext* opCtx, const BSONObj& op) {
     try {
-        Status status = applyCommand_inlock(txn, op, true);
+        Status status = applyCommand_inlock(opCtx, op, true);
         if (!status.isOK()) {
             SyncTail sync(nullptr, SyncTail::MultiSyncApplyFunc());
             sync.setHostname(hostName);
-            if (sync.shouldRetry(txn, op)) {
+            if (sync.shouldRetry(opCtx, op)) {
                 uassert(28639,
                         "Failure retrying initial sync update",
-                        applyCommand_inlock(txn, op, true).isOK());
+                        applyCommand_inlock(opCtx, op, true).isOK());
             }
         }
     } catch (UserException& e) {
@@ -667,16 +670,16 @@ void ReplSource::applyCommand(OperationContext* txn, const BSONObj& op) {
     }
 }
 
-void ReplSource::applyOperation(OperationContext* txn, Database* db, const BSONObj& op) {
+void ReplSource::applyOperation(OperationContext* opCtx, Database* db, const BSONObj& op) {
     try {
-        Status status = applyOperation_inlock(txn, db, op);
+        Status status = applyOperation_inlock(opCtx, db, op);
         if (!status.isOK()) {
             SyncTail sync(nullptr, SyncTail::MultiSyncApplyFunc());
             sync.setHostname(hostName);
-            if (sync.shouldRetry(txn, op)) {
+            if (sync.shouldRetry(opCtx, op)) {
                 uassert(15914,
                         "Failure retrying initial sync update",
-                        applyOperation_inlock(txn, db, op).isOK());
+                        applyOperation_inlock(opCtx, db, op).isOK());
             }
         }
     } catch (UserException& e) {
@@ -697,7 +700,7 @@ void ReplSource::applyOperation(OperationContext* txn, Database* db, const BSONO
 
    @param alreadyLocked caller already put us in write lock if true
 */
-void ReplSource::_sync_pullOpLog_applyOperation(OperationContext* txn,
+void ReplSource::_sync_pullOpLog_applyOperation(OperationContext* opCtx,
                                                 BSONObj& op,
                                                 bool alreadyLocked) {
     LOG(6) << "processing op: " << redact(op) << endl;
@@ -725,10 +728,10 @@ void ReplSource::_sync_pullOpLog_applyOperation(OperationContext* txn,
     if (!only.empty() && only != dbName)
         return;
 
-    // Push the CurOp stack for "txn" so each individual oplog entry application is separately
+    // Push the CurOp stack for "opCtx" so each individual oplog entry application is separately
     // reported.
-    CurOp individualOp(txn);
-    txn->setReplicatedWrites(false);
+    CurOp individualOp(opCtx);
+    opCtx->setReplicatedWrites(false);
     const ReplSettings& replSettings = getGlobalReplicationCoordinator()->getSettings();
     if (replSettings.getPretouch() &&
         !alreadyLocked /*doesn't make sense if in write lock already*/) {
@@ -759,16 +762,16 @@ void ReplSource::_sync_pullOpLog_applyOperation(OperationContext* txn,
                     a += m;
                 }
                 // we do one too...
-                pretouchOperation(txn, op);
+                pretouchOperation(opCtx, op);
                 tp->join();
                 countdown = v.size();
             }
         } else {
-            pretouchOperation(txn, op);
+            pretouchOperation(opCtx, op);
         }
     }
 
-    unique_ptr<Lock::GlobalWrite> lk(alreadyLocked ? 0 : new Lock::GlobalWrite(txn->lockState()));
+    unique_ptr<Lock::GlobalWrite> lk(alreadyLocked ? 0 : new Lock::GlobalWrite(opCtx->lockState()));
 
     if (replAllDead) {
         // hmmm why is this check here and not at top of this function? does it get set between top
@@ -777,20 +780,20 @@ void ReplSource::_sync_pullOpLog_applyOperation(OperationContext* txn,
         throw SyncException();
     }
 
-    if (!handleDuplicateDbName(txn, op, ns, dbName)) {
+    if (!handleDuplicateDbName(opCtx, op, ns, dbName)) {
         return;
     }
 
     // special case apply for commands to avoid implicit database creation
     if (*op.getStringField("op") == 'c') {
-        applyCommand(txn, op);
+        applyCommand(opCtx, op);
         return;
     }
 
     // This code executes on the slaves only, so it doesn't need to be sharding-aware since
     // mongos will not send requests there. That's why the last argument is false (do not do
     // version checking).
-    OldClientContext ctx(txn, ns, false);
+    OldClientContext ctx(opCtx, ns, false);
 
     bool empty = !ctx.db()->getDatabaseCatalogEntry()->hasUserData();
     bool incompleteClone = incompleteCloneDbs.count(dbName) != 0;
@@ -813,16 +816,16 @@ void ReplSource::_sync_pullOpLog_applyOperation(OperationContext* txn,
                 log() << "An earlier initial clone of '" << dbName
                       << "' did not complete, now resyncing." << endl;
             }
-            save(txn);
-            OldClientContext ctx(txn, ns, false);
+            save(opCtx);
+            OldClientContext ctx(opCtx, ns, false);
             nClonedThisPass++;
-            resync(txn, ctx.db()->name());
+            resync(opCtx, ctx.db()->name());
             addDbNextPass.erase(dbName);
             incompleteCloneDbs.erase(dbName);
         }
-        save(txn);
+        save(opCtx);
     } else {
-        applyOperation(txn, ctx.db(), op);
+        applyOperation(opCtx, ctx.db(), op);
         addDbNextPass.erase(dbName);
     }
 }
@@ -877,7 +880,7 @@ public:
            0 ok, don't sleep
            1 ok, sleep
 */
-int ReplSource::_sync_pullOpLog(OperationContext* txn, int& nApplied) {
+int ReplSource::_sync_pullOpLog(OperationContext* opCtx, int& nApplied) {
     int okResultCode = restartSyncAfterSleep;
     string ns = string("local.oplog.$") + sourceName();
     LOG(2) << "sync_pullOpLog " << ns << " syncedTo:" << syncedTo.toStringLong() << '\n';
@@ -911,9 +914,9 @@ int ReplSource::_sync_pullOpLog(OperationContext* txn, int& nApplied) {
             }
             // obviously global isn't ideal, but non-repl set is old so
             // keeping it simple
-            ScopedTransaction transaction(txn, MODE_X);
-            Lock::GlobalWrite lk(txn->lockState());
-            save(txn);
+            ScopedTransaction transaction(opCtx, MODE_X);
+            Lock::GlobalWrite lk(opCtx->lockState());
+            save(opCtx);
         }
 
         BSONObjBuilder gte;
@@ -948,7 +951,7 @@ int ReplSource::_sync_pullOpLog(OperationContext* txn, int& nApplied) {
             b.append("ns", *i + '.');
             b.append("op", "db");
             BSONObj op = b.done();
-            _sync_pullOpLog_applyOperation(txn, op, false);
+            _sync_pullOpLog_applyOperation(opCtx, op, false);
         }
     }
 
@@ -974,9 +977,9 @@ int ReplSource::_sync_pullOpLog(OperationContext* txn, int& nApplied) {
             log() << ns << " oplog is empty" << endl;
         }
         {
-            ScopedTransaction transaction(txn, MODE_X);
-            Lock::GlobalWrite lk(txn->lockState());
-            save(txn);
+            ScopedTransaction transaction(opCtx, MODE_X);
+            Lock::GlobalWrite lk(opCtx->lockState());
+            save(opCtx);
         }
         return okResultCode;
     }
@@ -1042,26 +1045,26 @@ int ReplSource::_sync_pullOpLog(OperationContext* txn, int& nApplied) {
             const bool moreInitialSyncsPending = !addDbNextPass.empty() && n;
 
             if (moreInitialSyncsPending || !oplogReader.more()) {
-                ScopedTransaction transaction(txn, MODE_X);
-                Lock::GlobalWrite lk(txn->lockState());
+                ScopedTransaction transaction(opCtx, MODE_X);
+                Lock::GlobalWrite lk(opCtx->lockState());
 
                 if (tailing) {
                     okResultCode = restartSync;  // don't sleep
                 }
 
                 syncedTo = nextOpTime;
-                save(txn);  // note how far we are synced up to now
+                save(opCtx);  // note how far we are synced up to now
                 nApplied = n;
                 break;
             }
 
             OCCASIONALLY if (n > 0 && (n > 100000 || time(0) - saveLast > 60)) {
                 // periodically note our progress, in case we are doing a lot of work and crash
-                ScopedTransaction transaction(txn, MODE_X);
-                Lock::GlobalWrite lk(txn->lockState());
+                ScopedTransaction transaction(opCtx, MODE_X);
+                Lock::GlobalWrite lk(opCtx->lockState());
                 syncedTo = nextOpTime;
                 // can't update local log ts since there are pending operations from our peer
-                save(txn);
+                save(opCtx);
                 log() << "checkpoint applied " << n << " operations" << endl;
                 log() << "syncedTo: " << syncedTo.toStringLong() << endl;
                 saveLast = time(0);
@@ -1072,7 +1075,8 @@ int ReplSource::_sync_pullOpLog(OperationContext* txn, int& nApplied) {
 
             int b = replApplyBatchSize.load();
             bool justOne = b == 1;
-            unique_ptr<Lock::GlobalWrite> lk(justOne ? 0 : new Lock::GlobalWrite(txn->lockState()));
+            unique_ptr<Lock::GlobalWrite> lk(justOne ? 0
+                                                     : new Lock::GlobalWrite(opCtx->lockState()));
             while (1) {
                 BSONElement ts = op.getField("ts");
                 if (!(ts.type() == Date || ts.type() == bsonTimestamp)) {
@@ -1104,11 +1108,11 @@ int ReplSource::_sync_pullOpLog(OperationContext* txn, int& nApplied) {
                     oplogReader.putBack(op);
                     _sleepAdviceTime = nextOpTime.getSecs() +
                         durationCount<Seconds>(replSettings.getSlaveDelaySecs()) + 1;
-                    ScopedTransaction transaction(txn, MODE_X);
-                    Lock::GlobalWrite lk(txn->lockState());
+                    ScopedTransaction transaction(opCtx, MODE_X);
+                    Lock::GlobalWrite lk(opCtx->lockState());
                     if (n > 0) {
                         syncedTo = last;
-                        save(txn);
+                        save(opCtx);
                     }
                     log() << "applied " << n << " operations" << endl;
                     log() << "syncedTo: " << syncedTo.toStringLong() << endl;
@@ -1116,7 +1120,7 @@ int ReplSource::_sync_pullOpLog(OperationContext* txn, int& nApplied) {
                     return okResultCode;
                 }
 
-                _sync_pullOpLog_applyOperation(txn, op, !justOne);
+                _sync_pullOpLog_applyOperation(opCtx, op, !justOne);
                 n++;
 
                 if (--b == 0)
@@ -1139,7 +1143,7 @@ int ReplSource::_sync_pullOpLog(OperationContext* txn, int& nApplied) {
    returns >= 0 if ok.  return -1 if you want to reconnect.
    return value of zero indicates no sleep necessary before next call
 */
-int ReplSource::sync(OperationContext* txn, int& nApplied) {
+int ReplSource::sync(OperationContext* opCtx, int& nApplied) {
     _sleepAdviceTime = 0;
     ReplInfo r("sync");
     if (!serverGlobalParams.quiet.load()) {
@@ -1167,7 +1171,7 @@ int ReplSource::sync(OperationContext* txn, int& nApplied) {
         return -1;
     }
 
-    return _sync_pullOpLog(txn, nApplied);
+    return _sync_pullOpLog(opCtx, nApplied);
 }
 
 /* --------------------------------------------------------------*/
@@ -1184,12 +1188,12 @@ _ reuse that cursor when we can
             0 = no sleep recommended
             1 = special sentinel indicating adaptive sleep recommended
 */
-int _replMain(OperationContext* txn, ReplSource::SourceVector& sources, int& nApplied) {
+int _replMain(OperationContext* opCtx, ReplSource::SourceVector& sources, int& nApplied) {
     {
         ReplInfo r("replMain load sources");
-        ScopedTransaction transaction(txn, MODE_X);
-        Lock::GlobalWrite lk(txn->lockState());
-        ReplSource::loadAll(txn, sources);
+        ScopedTransaction transaction(opCtx, MODE_X);
+        Lock::GlobalWrite lk(opCtx->lockState());
+        ReplSource::loadAll(opCtx, sources);
 
         // only need this param for initial reset
         _replMainStarted = true;
@@ -1208,7 +1212,7 @@ int _replMain(OperationContext* txn, ReplSource::SourceVector& sources, int& nAp
         ReplSource* s = i->get();
         int res = forceReconnect;
         try {
-            res = s->sync(txn, nApplied);
+            res = s->sync(opCtx, nApplied);
             bool moreToSync = s->haveMoreDbsToSync();
             if (res < 0) {
                 sleepAdvice = 3;
@@ -1245,17 +1249,17 @@ int _replMain(OperationContext* txn, ReplSource::SourceVector& sources, int& nAp
     return sleepAdvice;
 }
 
-static void replMain(OperationContext* txn) {
+static void replMain(OperationContext* opCtx) {
     ReplSource::SourceVector sources;
     while (1) {
         auto s = restartSync;
         {
-            ScopedTransaction transaction(txn, MODE_X);
-            Lock::GlobalWrite lk(txn->lockState());
+            ScopedTransaction transaction(opCtx, MODE_X);
+            Lock::GlobalWrite lk(opCtx->lockState());
             if (replAllDead) {
                 // throttledForceResyncDead can throw
                 if (!getGlobalReplicationCoordinator()->getSettings().isAutoResyncEnabled() ||
-                    !ReplSource::throttledForceResyncDead(txn, "auto")) {
+                    !ReplSource::throttledForceResyncDead(opCtx, "auto")) {
                     log() << "all sources dead: " << replAllDead << ", sleeping for 5 seconds"
                           << endl;
                     break;
@@ -1268,7 +1272,7 @@ static void replMain(OperationContext* txn) {
 
         try {
             int nApplied = 0;
-            s = _replMain(txn, sources, nApplied);
+            s = _replMain(opCtx, sources, nApplied);
             if (s == restartSyncAfterSleep) {
                 if (nApplied == 0)
                     s = 2;
@@ -1284,8 +1288,8 @@ static void replMain(OperationContext* txn) {
         }
 
         {
-            ScopedTransaction transaction(txn, MODE_X);
-            Lock::GlobalWrite lk(txn->lockState());
+            ScopedTransaction transaction(opCtx, MODE_X);
+            Lock::GlobalWrite lk(opCtx->lockState());
             invariant(syncing.swap(0) == 1);
         }
 
@@ -1316,17 +1320,17 @@ static void replMasterThread() {
         // Write a keep-alive like entry to the log. This will make things like
         // printReplicationStatus() and printSlaveReplicationStatus() stay up-to-date even
         // when things are idle.
-        const ServiceContext::UniqueOperationContext txnPtr = cc().makeOperationContext();
-        OperationContext& txn = *txnPtr;
-        AuthorizationSession::get(txn.getClient())->grantInternalAuthorization();
+        const ServiceContext::UniqueOperationContext opCtxPtr = cc().makeOperationContext();
+        OperationContext& opCtx = *opCtxPtr;
+        AuthorizationSession::get(opCtx.getClient())->grantInternalAuthorization();
 
-        Lock::GlobalWrite globalWrite(txn.lockState(), 1);
+        Lock::GlobalWrite globalWrite(opCtx.lockState(), 1);
         if (globalWrite.isLocked()) {
             toSleep = 10;
 
             try {
-                WriteUnitOfWork wuow(&txn);
-                getGlobalServiceContext()->getOpObserver()->onOpMessage(&txn, BSONObj());
+                WriteUnitOfWork wuow(&opCtx);
+                getGlobalServiceContext()->getOpObserver()->onOpMessage(&opCtx, BSONObj());
                 wuow.commit();
             } catch (...) {
                 log() << "caught exception in replMasterThread()" << endl;
@@ -1342,14 +1346,14 @@ static void replSlaveThread() {
     sleepsecs(1);
     Client::initThread("replslave");
 
-    const ServiceContext::UniqueOperationContext txnPtr = cc().makeOperationContext();
-    OperationContext& txn = *txnPtr;
-    AuthorizationSession::get(txn.getClient())->grantInternalAuthorization();
-    DisableDocumentValidation validationDisabler(&txn);
+    const ServiceContext::UniqueOperationContext opCtxPtr = cc().makeOperationContext();
+    OperationContext& opCtx = *opCtxPtr;
+    AuthorizationSession::get(opCtx.getClient())->grantInternalAuthorization();
+    DisableDocumentValidation validationDisabler(&opCtx);
 
     while (1) {
         try {
-            replMain(&txn);
+            replMain(&opCtx);
             sleepsecs(5);
         } catch (AssertionException&) {
             ReplInfo r("Assertion in replSlaveThread(): sleeping 5 minutes before retry");
@@ -1366,15 +1370,15 @@ static void replSlaveThread() {
     }
 }
 
-void startMasterSlave(OperationContext* txn) {
+void startMasterSlave(OperationContext* opCtx) {
     const ReplSettings& replSettings = getGlobalReplicationCoordinator()->getSettings();
     if (!replSettings.isSlave() && !replSettings.isMaster())
         return;
 
-    AuthorizationSession::get(txn->getClient())->grantInternalAuthorization();
+    AuthorizationSession::get(opCtx->getClient())->grantInternalAuthorization();
 
     {
-        ReplSource temp(txn);  // Ensures local.me is populated
+        ReplSource temp(opCtx);  // Ensures local.me is populated
     }
 
     if (replSettings.isSlave()) {
@@ -1385,7 +1389,7 @@ void startMasterSlave(OperationContext* txn) {
 
     if (replSettings.isMaster()) {
         LOG(1) << "master=true" << endl;
-        createOplog(txn);
+        createOplog(opCtx);
         stdx::thread t(replMasterThread);
         t.detach();
     }
@@ -1400,10 +1404,10 @@ int _dummy_z;
 void pretouchN(vector<BSONObj>& v, unsigned a, unsigned b) {
     Client::initThreadIfNotAlready("pretouchN");
 
-    const ServiceContext::UniqueOperationContext txnPtr = cc().makeOperationContext();
-    OperationContext& txn = *txnPtr;  // XXX
-    ScopedTransaction transaction(&txn, MODE_S);
-    Lock::GlobalRead lk(txn.lockState());
+    const ServiceContext::UniqueOperationContext opCtxPtr = cc().makeOperationContext();
+    OperationContext& opCtx = *opCtxPtr;  // XXX
+    ScopedTransaction transaction(&opCtx, MODE_S);
+    Lock::GlobalRead lk(opCtx.lockState());
 
     for (unsigned i = a; i <= b; i++) {
         const BSONObj& op = v[i];
@@ -1425,8 +1429,8 @@ void pretouchN(vector<BSONObj>& v, unsigned a, unsigned b) {
                 BSONObjBuilder b;
                 b.append(_id);
                 BSONObj result;
-                OldClientContext ctx(&txn, ns, false);
-                if (Helpers::findById(&txn, ctx.db(), ns, b.done(), result))
+                OldClientContext ctx(&opCtx, ns, false);
+                if (Helpers::findById(&opCtx, ctx.db(), ns, b.done(), result))
                     _dummy_z += result.objsize();  // touch
             }
         } catch (DBException& e) {
@@ -1436,8 +1440,8 @@ void pretouchN(vector<BSONObj>& v, unsigned a, unsigned b) {
     }
 }
 
-void pretouchOperation(OperationContext* txn, const BSONObj& op) {
-    if (txn->lockState()->isWriteLocked()) {
+void pretouchOperation(OperationContext* opCtx, const BSONObj& op) {
+    if (opCtx->lockState()->isWriteLocked()) {
         // no point pretouching if write locked. not sure if this will ever fire, but just in case.
         return;
     }
@@ -1460,8 +1464,8 @@ void pretouchOperation(OperationContext* txn, const BSONObj& op) {
             BSONObjBuilder b;
             b.append(_id);
             BSONObj result;
-            AutoGetCollectionForRead ctx(txn, NamespaceString(ns));
-            if (Helpers::findById(txn, ctx.getDb(), ns, b.done(), result)) {
+            AutoGetCollectionForRead ctx(opCtx, NamespaceString(ns));
+            if (Helpers::findById(opCtx, ctx.getDb(), ns, b.done(), result)) {
                 _dummy_z += result.objsize();  // touch
             }
         }
diff --git a/src/mongo/db/repl/master_slave.h b/src/mongo/db/repl/master_slave.h
index 3a869a750ba..627223efd16 100644
--- a/src/mongo/db/repl/master_slave.h
+++ b/src/mongo/db/repl/master_slave.h
@@ -50,7 +50,7 @@ class OperationContext;
 namespace repl {
 
 // Main entry point for master/slave at startup time.
-void startMasterSlave(OperationContext* txn);
+void startMasterSlave(OperationContext* opCtx);
 
 // externed for use with resync.cpp
 extern AtomicInt32 relinquishSyncingSome;
@@ -78,15 +78,15 @@ public:
 class ReplSource {
     std::shared_ptr<OldThreadPool> tp;
 
-    void resync(OperationContext* txn, const std::string& dbName);
+    void resync(OperationContext* opCtx, const std::string& dbName);
 
     /** @param alreadyLocked caller already put us in write lock if true */
-    void _sync_pullOpLog_applyOperation(OperationContext* txn, BSONObj& op, bool alreadyLocked);
+    void _sync_pullOpLog_applyOperation(OperationContext* opCtx, BSONObj& op, bool alreadyLocked);
 
     /* pull some operations from the master's oplog, and apply them.
        calls sync_pullOpLog_applyOperation
     */
-    int _sync_pullOpLog(OperationContext* txn, int& nApplied);
+    int _sync_pullOpLog(OperationContext* opCtx, int& nApplied);
 
     /* we only clone one database per pass, even if a lot need done.  This helps us
        avoid overflowing the master's transaction log by doing too much work before going
@@ -106,7 +106,7 @@ class ReplSource {
      */
     bool _doHandshake = false;
 
-    void resyncDrop(OperationContext* txn, const std::string& dbName);
+    void resyncDrop(OperationContext* opCtx, const std::string& dbName);
     // call without the db mutex
     void syncToTailOfRemoteLog();
     std::string ns() const {
@@ -120,16 +120,16 @@ class ReplSource {
      * master.
      * @return true iff an op with the specified ns may be applied.
      */
-    bool handleDuplicateDbName(OperationContext* txn,
+    bool handleDuplicateDbName(OperationContext* opCtx,
                                const BSONObj& op,
                                const char* ns,
                                const char* db);
 
     // populates _me so that it can be passed to oplogreader for handshakes
     /// TODO(spencer): Remove this function once the LegacyReplicationCoordinator is gone.
-    void ensureMe(OperationContext* txn);
+    void ensureMe(OperationContext* opCtx);
 
-    void forceResync(OperationContext* txn, const char* requester);
+    void forceResync(OperationContext* opCtx, const char* requester);
 
     bool _connect(OplogReader* reader, const HostAndPort& host, const OID& myRID);
 
@@ -138,8 +138,8 @@ class ReplSource {
 public:
     OplogReader oplogReader;
 
-    void applyCommand(OperationContext* txn, const BSONObj& op);
-    void applyOperation(OperationContext* txn, Database* db, const BSONObj& op);
+    void applyCommand(OperationContext* opCtx, const BSONObj& op);
+    void applyOperation(OperationContext* opCtx, Database* db, const BSONObj& op);
     std::string hostName;     // ip addr or hostname plus optionally, ":<port>"
     std::string _sourceName;  // a logical source name.
     std::string sourceName() const {
@@ -156,18 +156,18 @@ public:
     int nClonedThisPass;
 
     typedef std::vector<std::shared_ptr<ReplSource>> SourceVector;
-    static void loadAll(OperationContext* txn, SourceVector&);
+    static void loadAll(OperationContext* opCtx, SourceVector&);
 
-    explicit ReplSource(OperationContext* txn, BSONObj);
+    explicit ReplSource(OperationContext* opCtx, BSONObj);
     // This is not the constructor you are looking for. Always prefer the version that takes
     // a BSONObj.  This is public only as a hack so that the ReplicationCoordinator can find
     // out the process's RID in master/slave setups.
-    ReplSource(OperationContext* txn);
+    ReplSource(OperationContext* opCtx);
 
     /* -1 = error */
-    int sync(OperationContext* txn, int& nApplied);
+    int sync(OperationContext* opCtx, int& nApplied);
 
-    void save(OperationContext* txn);  // write ourself to local.sources
+    void save(OperationContext* opCtx);  // write ourself to local.sources
 
     // make a jsobj from our member fields of the form
     //   { host: ..., source: ..., syncedTo: ... }
@@ -190,8 +190,8 @@ public:
         return wait > 0 ? wait : 0;
     }
 
-    static bool throttledForceResyncDead(OperationContext* txn, const char* requester);
-    static void forceResyncDead(OperationContext* txn, const char* requester);
+    static bool throttledForceResyncDead(OperationContext* opCtx, const char* requester);
+    static void forceResyncDead(OperationContext* opCtx, const char* requester);
 };
 
 /**
diff --git a/src/mongo/db/repl/multiapplier.cpp b/src/mongo/db/repl/multiapplier.cpp
index 036ab4f0d4d..ac78a4f2c8c 100644
--- a/src/mongo/db/repl/multiapplier.cpp
+++ b/src/mongo/db/repl/multiapplier.cpp
@@ -159,8 +159,8 @@ void MultiApplier::_callback(const executor::TaskExecutor::CallbackArgs& cbd) {
 
     StatusWith<OpTime> applyStatus(ErrorCodes::InternalError, "not mutated");
     try {
-        auto txn = cc().makeOperationContext();
-        applyStatus = _multiApply(txn.get(), _operations, _applyOperation);
+        auto opCtx = cc().makeOperationContext();
+        applyStatus = _multiApply(opCtx.get(), _operations, _applyOperation);
     } catch (...) {
         applyStatus = exceptionToStatus();
     }
diff --git a/src/mongo/db/repl/multiapplier_test.cpp b/src/mongo/db/repl/multiapplier_test.cpp
index 9df868384c2..dcbd6979adf 100644
--- a/src/mongo/db/repl/multiapplier_test.cpp
+++ b/src/mongo/db/repl/multiapplier_test.cpp
@@ -156,7 +156,7 @@ TEST_F(MultiApplierTest, MultiApplierInvokesCallbackWithCallbackCanceledStatusUp
     const MultiApplier::Operations operations{OplogEntry(BSON("ts" << Timestamp(Seconds(123), 0)))};
 
     bool multiApplyInvoked = false;
-    auto multiApply = [&](OperationContext* txn,
+    auto multiApply = [&](OperationContext* opCtx,
                           MultiApplier::Operations operations,
                           MultiApplier::ApplyOperationFn) -> StatusWith<OpTime> {
         multiApplyInvoked = true;
@@ -223,7 +223,7 @@ TEST_F(MultiApplierTest, MultiApplierCatchesMultiApplyExceptionAndConvertsToCall
 
     bool multiApplyInvoked = false;
     Status multiApplyError(ErrorCodes::OperationFailed, "multi apply failed");
-    auto multiApply = [&](OperationContext* txn,
+    auto multiApply = [&](OperationContext* opCtx,
                           MultiApplier::Operations operations,
                           MultiApplier::ApplyOperationFn) -> StatusWith<OpTime> {
         multiApplyInvoked = true;
@@ -255,10 +255,10 @@ TEST_F(
 
     OperationContext* multiApplyTxn = nullptr;
     MultiApplier::Operations operationsToApply;
-    auto multiApply = [&](OperationContext* txn,
+    auto multiApply = [&](OperationContext* opCtx,
                           MultiApplier::Operations operations,
                           MultiApplier::ApplyOperationFn) -> StatusWith<OpTime> {
-        multiApplyTxn = txn;
+        multiApplyTxn = opCtx;
         operationsToApply = operations;
         return operationsToApply.back().getOpTime();
     };
diff --git a/src/mongo/db/repl/noop_writer.cpp b/src/mongo/db/repl/noop_writer.cpp
index c12425fd423..f127b236614 100644
--- a/src/mongo/db/repl/noop_writer.cpp
+++ b/src/mongo/db/repl/noop_writer.cpp
@@ -77,8 +77,8 @@ private:
     void run(Seconds waitTime, NoopWriteFn noopWrite) {
         Client::initThread("NoopWriter");
         while (true) {
-            const ServiceContext::UniqueOperationContext txnPtr = cc().makeOperationContext();
-            OperationContext& txn = *txnPtr;
+            const ServiceContext::UniqueOperationContext opCtxPtr = cc().makeOperationContext();
+            OperationContext& opCtx = *opCtxPtr;
             {
                 stdx::unique_lock<stdx::mutex> lk(_mutex);
                 _cv.wait_for(lk, waitTime.toSystemDuration(), [&] { return _inShutdown; });
@@ -86,7 +86,7 @@ private:
                 if (_inShutdown)
                     return;
             }
-            noopWrite(&txn);
+            noopWrite(&opCtx);
         }
     }
 
@@ -126,7 +126,7 @@ Status NoopWriter::startWritingPeriodicNoops(OpTime lastKnownOpTime) {
 
     invariant(!_noopRunner);
     _noopRunner = stdx::make_unique<PeriodicNoopRunner>(
-        _writeInterval, [this](OperationContext* txn) { _writeNoop(txn); });
+        _writeInterval, [this](OperationContext* opCtx) { _writeNoop(opCtx); });
     return Status::OK();
 }
 
@@ -135,20 +135,20 @@ void NoopWriter::stopWritingPeriodicNoops() {
     _noopRunner.reset();
 }
 
-void NoopWriter::_writeNoop(OperationContext* txn) {
-    ScopedTransaction transaction(txn, MODE_IX);
+void NoopWriter::_writeNoop(OperationContext* opCtx) {
+    ScopedTransaction transaction(opCtx, MODE_IX);
     // Use GlobalLock + lockMMAPV1Flush instead of DBLock to allow return when the lock is not
     // available. It may happen when the primary steps down and a shared global lock is acquired.
-    Lock::GlobalLock lock(txn->lockState(), MODE_IX, 1);
+    Lock::GlobalLock lock(opCtx->lockState(), MODE_IX, 1);
     if (!lock.isLocked()) {
         LOG(1) << "Global lock is not available skipping noopWrite";
         return;
     }
-    txn->lockState()->lockMMAPV1Flush();
+    opCtx->lockState()->lockMMAPV1Flush();
 
-    auto replCoord = ReplicationCoordinator::get(txn);
+    auto replCoord = ReplicationCoordinator::get(opCtx);
     // Its a proxy for being a primary
-    if (!replCoord->canAcceptWritesForDatabase(txn, "admin")) {
+    if (!replCoord->canAcceptWritesForDatabase(opCtx, "admin")) {
         LOG(1) << "Not a primary, skipping the noop write";
         return;
     }
@@ -166,11 +166,12 @@ void NoopWriter::_writeNoop(OperationContext* txn) {
                 << "Writing noop to oplog as there has been no writes to this replica set in over "
                 << _writeInterval;
             MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
-                WriteUnitOfWork uow(txn);
-                txn->getClient()->getServiceContext()->getOpObserver()->onOpMessage(txn, kMsgObj);
+                WriteUnitOfWork uow(opCtx);
+                opCtx->getClient()->getServiceContext()->getOpObserver()->onOpMessage(opCtx,
+                                                                                      kMsgObj);
                 uow.commit();
             }
-            MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "writeNoop", rsOplogName);
+            MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "writeNoop", rsOplogName);
         }
     }
 
diff --git a/src/mongo/db/repl/oplog.cpp b/src/mongo/db/repl/oplog.cpp
index e394df05efd..9db957bb00c 100644
--- a/src/mongo/db/repl/oplog.cpp
+++ b/src/mongo/db/repl/oplog.cpp
@@ -145,13 +145,13 @@ struct OplogSlot {
  * function registers the new optime with the storage system and the replication coordinator,
  * and provides no facility to revert those registrations on rollback.
  */
-void getNextOpTime(OperationContext* txn,
+void getNextOpTime(OperationContext* opCtx,
                    Collection* oplog,
                    ReplicationCoordinator* replCoord,
                    ReplicationCoordinator::Mode replicationMode,
                    unsigned count,
                    OplogSlot* slotsOut) {
-    synchronizeOnCappedInFlightResource(txn->lockState(), oplog->ns());
+    synchronizeOnCappedInFlightResource(opCtx->lockState(), oplog->ns());
     long long term = OpTime::kUninitializedTerm;
 
     // Fetch term out of the newOpMutex.
@@ -163,10 +163,10 @@ void getNextOpTime(OperationContext* txn,
 
     stdx::lock_guard<stdx::mutex> lk(newOpMutex);
 
-    auto ts = LogicalClock::get(txn)->reserveTicks(count).asTimestamp();
+    auto ts = LogicalClock::get(opCtx)->reserveTicks(count).asTimestamp();
     newTimestampNotifier.notify_all();
 
-    fassert(28560, oplog->getRecordStore()->oplogDiskLocRegister(txn, ts));
+    fassert(28560, oplog->getRecordStore()->oplogDiskLocRegister(opCtx, ts));
 
     // Set hash if we're in replset mode, otherwise it remains 0 in master/slave.
     const bool needHash = (replicationMode == ReplicationCoordinator::modeReplSet);
@@ -229,11 +229,12 @@ void setOplogCollectionName() {
 
 namespace {
 
-Collection* getLocalOplogCollection(OperationContext* txn, const std::string& oplogCollectionName) {
+Collection* getLocalOplogCollection(OperationContext* opCtx,
+                                    const std::string& oplogCollectionName) {
     if (_localOplogCollection)
         return _localOplogCollection;
 
-    AutoGetCollection autoColl(txn, NamespaceString(oplogCollectionName), MODE_IX);
+    AutoGetCollection autoColl(opCtx, NamespaceString(oplogCollectionName), MODE_IX);
     _localOplogCollection = autoColl.getCollection();
     massert(13347,
             "the oplog collection " + oplogCollectionName +
@@ -243,7 +244,7 @@ Collection* getLocalOplogCollection(OperationContext* txn, const std::string& op
     return _localOplogCollection;
 }
 
-bool oplogDisabled(OperationContext* txn,
+bool oplogDisabled(OperationContext* opCtx,
                    ReplicationCoordinator::Mode replicationMode,
                    const NamespaceString& nss) {
     if (replicationMode == ReplicationCoordinator::modeNone)
@@ -255,15 +256,15 @@ bool oplogDisabled(OperationContext* txn,
     if (nss.isSystemDotProfile())
         return true;
 
-    if (!txn->writesAreReplicated())
+    if (!opCtx->writesAreReplicated())
         return true;
 
-    fassert(28626, txn->recoveryUnit());
+    fassert(28626, opCtx->recoveryUnit());
 
     return false;
 }
 
-OplogDocWriter _logOpWriter(OperationContext* txn,
+OplogDocWriter _logOpWriter(OperationContext* opCtx,
                             const char* opstr,
                             const NamespaceString& nss,
                             const BSONObj& obj,
@@ -290,11 +291,11 @@ OplogDocWriter _logOpWriter(OperationContext* txn,
 }  // end anon namespace
 
 // Truncates the oplog after and including the "truncateTimestamp" entry.
-void truncateOplogTo(OperationContext* txn, Timestamp truncateTimestamp) {
+void truncateOplogTo(OperationContext* opCtx, Timestamp truncateTimestamp) {
     const NamespaceString oplogNss(rsOplogName);
-    ScopedTransaction transaction(txn, MODE_IX);
-    AutoGetDb autoDb(txn, oplogNss.db(), MODE_IX);
-    Lock::CollectionLock oplogCollectionLoc(txn->lockState(), oplogNss.ns(), MODE_X);
+    ScopedTransaction transaction(opCtx, MODE_IX);
+    AutoGetDb autoDb(opCtx, oplogNss.db(), MODE_IX);
+    Lock::CollectionLock oplogCollectionLoc(opCtx->lockState(), oplogNss.ns(), MODE_X);
     Collection* oplogCollection = autoDb.getDb()->getCollection(oplogNss);
     if (!oplogCollection) {
         fassertFailedWithStatusNoTrace(
@@ -305,7 +306,7 @@ void truncateOplogTo(OperationContext* txn, Timestamp truncateTimestamp) {
     // Scan through oplog in reverse, from latest entry to first, to find the truncateTimestamp.
     RecordId oldestIDToDelete;  // Non-null if there is something to delete.
     auto oplogRs = oplogCollection->getRecordStore();
-    auto oplogReverseCursor = oplogRs->getCursor(txn, /*forward=*/false);
+    auto oplogReverseCursor = oplogRs->getCursor(opCtx, /*forward=*/false);
     size_t count = 0;
     while (auto next = oplogReverseCursor->next()) {
         const BSONObj entry = next->data.releaseToBson();
@@ -325,7 +326,7 @@ void truncateOplogTo(OperationContext* txn, Timestamp truncateTimestamp) {
             // oplog is < truncateTimestamp.
             if (count != 1) {
                 invariant(!oldestIDToDelete.isNull());
-                oplogCollection->cappedTruncateAfter(txn, oldestIDToDelete, /*inclusive=*/true);
+                oplogCollection->cappedTruncateAfter(opCtx, oldestIDToDelete, /*inclusive=*/true);
             }
             return;
         }
@@ -356,7 +357,7 @@ void truncateOplogTo(OperationContext* txn, Timestamp truncateTimestamp) {
      if not null, specifies a boolean to pass along to the other side as b: param.
      used for "justOne" or "upsert" flags on 'd', 'u'
 */
-void _logOpsInner(OperationContext* txn,
+void _logOpsInner(OperationContext* opCtx,
                   const NamespaceString& nss,
                   const DocWriter* const* writers,
                   size_t nWriters,
@@ -366,79 +367,80 @@ void _logOpsInner(OperationContext* txn,
     ReplicationCoordinator* replCoord = getGlobalReplicationCoordinator();
 
     if (nss.size() && replicationMode == ReplicationCoordinator::modeReplSet &&
-        !replCoord->canAcceptWritesFor(txn, nss)) {
+        !replCoord->canAcceptWritesFor(opCtx, nss)) {
         severe() << "logOp() but can't accept write to collection " << nss.ns();
         fassertFailed(17405);
     }
 
     // we jump through a bunch of hoops here to avoid copying the obj buffer twice --
     // instead we do a single copy to the destination in the record store.
-    checkOplogInsert(oplogCollection->insertDocumentsForOplog(txn, writers, nWriters));
+    checkOplogInsert(oplogCollection->insertDocumentsForOplog(opCtx, writers, nWriters));
 
     // Set replCoord last optime only after we're sure the WUOW didn't abort and roll back.
-    txn->recoveryUnit()->onCommit([txn, replCoord, finalOpTime] {
+    opCtx->recoveryUnit()->onCommit([opCtx, replCoord, finalOpTime] {
         replCoord->setMyLastAppliedOpTimeForward(finalOpTime);
-        ReplClientInfo::forClient(txn->getClient()).setLastOp(finalOpTime);
+        ReplClientInfo::forClient(opCtx->getClient()).setLastOp(finalOpTime);
     });
 }
 
-void logOp(OperationContext* txn,
+void logOp(OperationContext* opCtx,
            const char* opstr,
            const char* ns,
            const BSONObj& obj,
            const BSONObj* o2,
            bool fromMigrate) {
-    ReplicationCoordinator::Mode replMode = ReplicationCoordinator::get(txn)->getReplicationMode();
+    ReplicationCoordinator::Mode replMode =
+        ReplicationCoordinator::get(opCtx)->getReplicationMode();
     NamespaceString nss(ns);
-    if (oplogDisabled(txn, replMode, nss))
+    if (oplogDisabled(opCtx, replMode, nss))
         return;
 
     ReplicationCoordinator* replCoord = getGlobalReplicationCoordinator();
-    Collection* oplog = getLocalOplogCollection(txn, _oplogCollectionName);
-    Lock::DBLock lk(txn->lockState(), "local", MODE_IX);
-    Lock::CollectionLock lock(txn->lockState(), _oplogCollectionName, MODE_IX);
+    Collection* oplog = getLocalOplogCollection(opCtx, _oplogCollectionName);
+    Lock::DBLock lk(opCtx->lockState(), "local", MODE_IX);
+    Lock::CollectionLock lock(opCtx->lockState(), _oplogCollectionName, MODE_IX);
     OplogSlot slot;
-    getNextOpTime(txn, oplog, replCoord, replMode, 1, &slot);
-    auto writer = _logOpWriter(txn, opstr, nss, obj, o2, fromMigrate, slot.opTime, slot.hash);
+    getNextOpTime(opCtx, oplog, replCoord, replMode, 1, &slot);
+    auto writer = _logOpWriter(opCtx, opstr, nss, obj, o2, fromMigrate, slot.opTime, slot.hash);
     const DocWriter* basePtr = &writer;
-    _logOpsInner(txn, nss, &basePtr, 1, oplog, replMode, slot.opTime);
+    _logOpsInner(opCtx, nss, &basePtr, 1, oplog, replMode, slot.opTime);
 }
 
-void logOps(OperationContext* txn,
+void logOps(OperationContext* opCtx,
             const char* opstr,
             const NamespaceString& nss,
             std::vector<BSONObj>::const_iterator begin,
             std::vector<BSONObj>::const_iterator end,
             bool fromMigrate) {
-    ReplicationCoordinator* replCoord = ReplicationCoordinator::get(txn);
+    ReplicationCoordinator* replCoord = ReplicationCoordinator::get(opCtx);
     ReplicationCoordinator::Mode replMode = replCoord->getReplicationMode();
 
     invariant(begin != end);
-    if (oplogDisabled(txn, replMode, nss))
+    if (oplogDisabled(opCtx, replMode, nss))
         return;
 
     const size_t count = end - begin;
     std::vector<OplogDocWriter> writers;
     writers.reserve(count);
-    Collection* oplog = getLocalOplogCollection(txn, _oplogCollectionName);
-    Lock::DBLock lk(txn->lockState(), "local", MODE_IX);
-    Lock::CollectionLock lock(txn->lockState(), _oplogCollectionName, MODE_IX);
+    Collection* oplog = getLocalOplogCollection(opCtx, _oplogCollectionName);
+    Lock::DBLock lk(opCtx->lockState(), "local", MODE_IX);
+    Lock::CollectionLock lock(opCtx->lockState(), _oplogCollectionName, MODE_IX);
     std::unique_ptr<OplogSlot[]> slots(new OplogSlot[count]);
-    getNextOpTime(txn, oplog, replCoord, replMode, count, slots.get());
+    getNextOpTime(opCtx, oplog, replCoord, replMode, count, slots.get());
     for (size_t i = 0; i < count; i++) {
         writers.emplace_back(_logOpWriter(
-            txn, opstr, nss, begin[i], NULL, fromMigrate, slots[i].opTime, slots[i].hash));
+            opCtx, opstr, nss, begin[i], NULL, fromMigrate, slots[i].opTime, slots[i].hash));
     }
 
     std::unique_ptr<DocWriter const* []> basePtrs(new DocWriter const*[count]);
     for (size_t i = 0; i < count; i++) {
         basePtrs[i] = &writers[i];
     }
-    _logOpsInner(txn, nss, basePtrs.get(), count, oplog, replMode, slots[count - 1].opTime);
+    _logOpsInner(opCtx, nss, basePtrs.get(), count, oplog, replMode, slots[count - 1].opTime);
 }
 
 namespace {
-long long getNewOplogSizeBytes(OperationContext* txn, const ReplSettings& replSettings) {
+long long getNewOplogSizeBytes(OperationContext* opCtx, const ReplSettings& replSettings) {
     if (replSettings.getOplogSizeBytes() != 0) {
         return replSettings.getOplogSizeBytes();
     }
@@ -459,7 +461,7 @@ long long getNewOplogSizeBytes(OperationContext* txn, const ReplSettings& replSe
 #else
     long long lowerBound = 0;
     double bytes = 0;
-    if (txn->getClient()->getServiceContext()->getGlobalStorageEngine()->isEphemeral()) {
+    if (opCtx->getClient()->getServiceContext()->getGlobalStorageEngine()->isEphemeral()) {
         // in memory: 50MB minimum size
         lowerBound = 50LL * 1024 * 1024;
         bytes = pi.getMemSizeMB() * 1024 * 1024;
@@ -482,19 +484,19 @@ long long getNewOplogSizeBytes(OperationContext* txn, const ReplSettings& replSe
 }
 }  // namespace
 
-void createOplog(OperationContext* txn, const std::string& oplogCollectionName, bool isReplSet) {
-    ScopedTransaction transaction(txn, MODE_X);
-    Lock::GlobalWrite lk(txn->lockState());
+void createOplog(OperationContext* opCtx, const std::string& oplogCollectionName, bool isReplSet) {
+    ScopedTransaction transaction(opCtx, MODE_X);
+    Lock::GlobalWrite lk(opCtx->lockState());
 
-    const ReplSettings& replSettings = ReplicationCoordinator::get(txn)->getSettings();
+    const ReplSettings& replSettings = ReplicationCoordinator::get(opCtx)->getSettings();
 
-    OldClientContext ctx(txn, oplogCollectionName);
+    OldClientContext ctx(opCtx, oplogCollectionName);
     Collection* collection = ctx.db()->getCollection(oplogCollectionName);
 
     if (collection) {
         if (replSettings.getOplogSizeBytes() != 0) {
             const CollectionOptions oplogOpts =
-                collection->getCatalogEntry()->getCollectionOptions(txn);
+                collection->getCatalogEntry()->getCollectionOptions(opCtx);
 
             int o = (int)(oplogOpts.cappedSize / (1024 * 1024));
             int n = (int)(replSettings.getOplogSizeBytes() / (1024 * 1024));
@@ -508,12 +510,12 @@ void createOplog(OperationContext* txn, const std::string& oplogCollectionName,
         }
 
         if (!isReplSet)
-            initTimestampFromOplog(txn, oplogCollectionName);
+            initTimestampFromOplog(opCtx, oplogCollectionName);
         return;
     }
 
     /* create an oplog collection, if it doesn't yet exist. */
-    const auto sz = getNewOplogSizeBytes(txn, replSettings);
+    const auto sz = getNewOplogSizeBytes(opCtx, replSettings);
 
     log() << "******" << endl;
     log() << "creating replication oplog of size: " << (int)(sz / (1024 * 1024)) << "MB..." << endl;
@@ -524,24 +526,24 @@ void createOplog(OperationContext* txn, const std::string& oplogCollectionName,
     options.autoIndexId = CollectionOptions::NO;
 
     MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
-        WriteUnitOfWork uow(txn);
-        invariant(ctx.db()->createCollection(txn, oplogCollectionName, options));
+        WriteUnitOfWork uow(opCtx);
+        invariant(ctx.db()->createCollection(opCtx, oplogCollectionName, options));
         if (!isReplSet)
-            getGlobalServiceContext()->getOpObserver()->onOpMessage(txn, BSONObj());
+            getGlobalServiceContext()->getOpObserver()->onOpMessage(opCtx, BSONObj());
         uow.commit();
     }
-    MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "createCollection", oplogCollectionName);
+    MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "createCollection", oplogCollectionName);
 
     /* sync here so we don't get any surprising lag later when we try to sync */
     StorageEngine* storageEngine = getGlobalServiceContext()->getGlobalStorageEngine();
-    storageEngine->flushAllFiles(txn, true);
+    storageEngine->flushAllFiles(opCtx, true);
     log() << "******" << endl;
 }
 
-void createOplog(OperationContext* txn) {
-    const auto isReplSet = ReplicationCoordinator::get(txn)->getReplicationMode() ==
+void createOplog(OperationContext* opCtx) {
+    const auto isReplSet = ReplicationCoordinator::get(opCtx)->getReplicationMode() ==
         ReplicationCoordinator::modeReplSet;
-    createOplog(txn, _oplogCollectionName, isReplSet);
+    createOplog(opCtx, _oplogCollectionName, isReplSet);
 }
 
 // -------------------------------------
@@ -575,13 +577,13 @@ struct ApplyOpMetadata {
 
 std::map<std::string, ApplyOpMetadata> opsMap = {
     {"create",
-     {[](OperationContext* txn, const char* ns, BSONObj& cmd) -> Status {
+     {[](OperationContext* opCtx, const char* ns, BSONObj& cmd) -> Status {
           const NamespaceString nss(parseNs(ns, cmd));
           if (auto idIndexElem = cmd["idIndex"]) {
               // Remove "idIndex" field from command.
               auto cmdWithoutIdIndex = cmd.removeField("idIndex");
               return createCollection(
-                  txn, nss.db().toString(), cmdWithoutIdIndex, idIndexElem.Obj());
+                  opCtx, nss.db().toString(), cmdWithoutIdIndex, idIndexElem.Obj());
           }
 
           // No _id index spec was provided, so we should build a v:1 _id index.
@@ -591,55 +593,55 @@ std::map<std::string, ApplyOpMetadata> opsMap = {
           idIndexSpecBuilder.append(IndexDescriptor::kIndexNameFieldName, "_id_");
           idIndexSpecBuilder.append(IndexDescriptor::kNamespaceFieldName, nss.ns());
           idIndexSpecBuilder.append(IndexDescriptor::kKeyPatternFieldName, BSON("_id" << 1));
-          return createCollection(txn, nss.db().toString(), cmd, idIndexSpecBuilder.done());
+          return createCollection(opCtx, nss.db().toString(), cmd, idIndexSpecBuilder.done());
       },
       {ErrorCodes::NamespaceExists}}},
     {"collMod",
-     {[](OperationContext* txn, const char* ns, BSONObj& cmd) -> Status {
+     {[](OperationContext* opCtx, const char* ns, BSONObj& cmd) -> Status {
           BSONObjBuilder resultWeDontCareAbout;
-          return collMod(txn, parseNs(ns, cmd), cmd, &resultWeDontCareAbout);
+          return collMod(opCtx, parseNs(ns, cmd), cmd, &resultWeDontCareAbout);
       },
       {ErrorCodes::IndexNotFound, ErrorCodes::NamespaceNotFound}}},
     {"dropDatabase",
-     {[](OperationContext* txn, const char* ns, BSONObj& cmd) -> Status {
-          return dropDatabase(txn, NamespaceString(ns).db().toString());
+     {[](OperationContext* opCtx, const char* ns, BSONObj& cmd) -> Status {
+          return dropDatabase(opCtx, NamespaceString(ns).db().toString());
       },
       {ErrorCodes::NamespaceNotFound}}},
     {"drop",
-     {[](OperationContext* txn, const char* ns, BSONObj& cmd) -> Status {
+     {[](OperationContext* opCtx, const char* ns, BSONObj& cmd) -> Status {
           BSONObjBuilder resultWeDontCareAbout;
-          return dropCollection(txn, parseNs(ns, cmd), resultWeDontCareAbout);
+          return dropCollection(opCtx, parseNs(ns, cmd), resultWeDontCareAbout);
       },
       // IllegalOperation is necessary because in 3.0 we replicate drops of system.profile
       // TODO(dannenberg) remove IllegalOperation once we no longer need 3.0 compatibility
       {ErrorCodes::NamespaceNotFound, ErrorCodes::IllegalOperation}}},
     // deleteIndex(es) is deprecated but still works as of April 10, 2015
     {"deleteIndex",
-     {[](OperationContext* txn, const char* ns, BSONObj& cmd) -> Status {
+     {[](OperationContext* opCtx, const char* ns, BSONObj& cmd) -> Status {
           BSONObjBuilder resultWeDontCareAbout;
-          return dropIndexes(txn, parseNs(ns, cmd), cmd, &resultWeDontCareAbout);
+          return dropIndexes(opCtx, parseNs(ns, cmd), cmd, &resultWeDontCareAbout);
       },
       {ErrorCodes::NamespaceNotFound, ErrorCodes::IndexNotFound}}},
     {"deleteIndexes",
-     {[](OperationContext* txn, const char* ns, BSONObj& cmd) -> Status {
+     {[](OperationContext* opCtx, const char* ns, BSONObj& cmd) -> Status {
           BSONObjBuilder resultWeDontCareAbout;
-          return dropIndexes(txn, parseNs(ns, cmd), cmd, &resultWeDontCareAbout);
+          return dropIndexes(opCtx, parseNs(ns, cmd), cmd, &resultWeDontCareAbout);
       },
       {ErrorCodes::NamespaceNotFound, ErrorCodes::IndexNotFound}}},
     {"dropIndex",
-     {[](OperationContext* txn, const char* ns, BSONObj& cmd) -> Status {
+     {[](OperationContext* opCtx, const char* ns, BSONObj& cmd) -> Status {
           BSONObjBuilder resultWeDontCareAbout;
-          return dropIndexes(txn, parseNs(ns, cmd), cmd, &resultWeDontCareAbout);
+          return dropIndexes(opCtx, parseNs(ns, cmd), cmd, &resultWeDontCareAbout);
       },
       {ErrorCodes::NamespaceNotFound, ErrorCodes::IndexNotFound}}},
     {"dropIndexes",
-     {[](OperationContext* txn, const char* ns, BSONObj& cmd) -> Status {
+     {[](OperationContext* opCtx, const char* ns, BSONObj& cmd) -> Status {
           BSONObjBuilder resultWeDontCareAbout;
-          return dropIndexes(txn, parseNs(ns, cmd), cmd, &resultWeDontCareAbout);
+          return dropIndexes(opCtx, parseNs(ns, cmd), cmd, &resultWeDontCareAbout);
       },
       {ErrorCodes::NamespaceNotFound, ErrorCodes::IndexNotFound}}},
     {"renameCollection",
-     {[](OperationContext* txn, const char* ns, BSONObj& cmd) -> Status {
+     {[](OperationContext* opCtx, const char* ns, BSONObj& cmd) -> Status {
           const auto sourceNsElt = cmd.firstElement();
           const auto targetNsElt = cmd["to"];
           uassert(ErrorCodes::TypeMismatch,
@@ -648,7 +650,7 @@ std::map<std::string, ApplyOpMetadata> opsMap = {
           uassert(ErrorCodes::TypeMismatch,
                   "'to' must be of type String",
                   targetNsElt.type() == BSONType::String);
-          return renameCollection(txn,
+          return renameCollection(opCtx,
                                   NamespaceString(sourceNsElt.valueStringData()),
                                   NamespaceString(targetNsElt.valueStringData()),
                                   cmd["dropTarget"].trueValue(),
@@ -656,16 +658,16 @@ std::map<std::string, ApplyOpMetadata> opsMap = {
       },
       {ErrorCodes::NamespaceNotFound, ErrorCodes::NamespaceExists}}},
     {"applyOps",
-     {[](OperationContext* txn, const char* ns, BSONObj& cmd) -> Status {
+     {[](OperationContext* opCtx, const char* ns, BSONObj& cmd) -> Status {
           BSONObjBuilder resultWeDontCareAbout;
-          return applyOps(txn, nsToDatabase(ns), cmd, &resultWeDontCareAbout);
+          return applyOps(opCtx, nsToDatabase(ns), cmd, &resultWeDontCareAbout);
       },
       {ErrorCodes::UnknownError}}},
-    {"convertToCapped", {[](OperationContext* txn, const char* ns, BSONObj& cmd) -> Status {
-         return convertToCapped(txn, parseNs(ns, cmd), cmd["size"].number());
+    {"convertToCapped", {[](OperationContext* opCtx, const char* ns, BSONObj& cmd) -> Status {
+         return convertToCapped(opCtx, parseNs(ns, cmd), cmd["size"].number());
      }}},
-    {"emptycapped", {[](OperationContext* txn, const char* ns, BSONObj& cmd) -> Status {
-         return emptyCapped(txn, parseNs(ns, cmd));
+    {"emptycapped", {[](OperationContext* opCtx, const char* ns, BSONObj& cmd) -> Status {
+         return emptyCapped(opCtx, parseNs(ns, cmd));
      }}},
 };
 
@@ -673,14 +675,14 @@ std::map<std::string, ApplyOpMetadata> opsMap = {
 
 // @return failure status if an update should have happened and the document DNE.
 // See replset initial sync code.
-Status applyOperation_inlock(OperationContext* txn,
+Status applyOperation_inlock(OperationContext* opCtx,
                              Database* db,
                              const BSONObj& op,
                              bool inSteadyStateReplication,
                              IncrementOpsAppliedStatsFn incrementOpsAppliedStats) {
     LOG(3) << "applying op: " << redact(op);
 
-    OpCounters* opCounters = txn->writesAreReplicated() ? &globalOpCounters : &replOpCounters;
+    OpCounters* opCounters = opCtx->writesAreReplicated() ? &globalOpCounters : &replOpCounters;
 
     const char* names[] = {"o", "ns", "op", "b", "o2"};
     BSONElement fields[5];
@@ -710,19 +712,19 @@ Status applyOperation_inlock(OperationContext* txn,
         if (supportsDocLocking()) {
             // WiredTiger, and others requires MODE_IX since the applier threads driving
             // this allow writes to the same collection on any thread.
-            dassert(txn->lockState()->isCollectionLockedForMode(ns, MODE_IX));
+            dassert(opCtx->lockState()->isCollectionLockedForMode(ns, MODE_IX));
         } else {
             // mmapV1 ensures that all operations to the same collection are executed from
             // the same worker thread, so it takes an exclusive lock (MODE_X)
-            dassert(txn->lockState()->isCollectionLockedForMode(ns, MODE_X));
+            dassert(opCtx->lockState()->isCollectionLockedForMode(ns, MODE_X));
         }
     }
     Collection* collection = db->getCollection(ns);
     IndexCatalog* indexCatalog = collection == nullptr ? nullptr : collection->getIndexCatalog();
-    const bool haveWrappingWriteUnitOfWork = txn->lockState()->inAWriteUnitOfWork();
+    const bool haveWrappingWriteUnitOfWork = opCtx->lockState()->inAWriteUnitOfWork();
     uassert(ErrorCodes::CommandNotSupportedOnView,
             str::stream() << "applyOps not supported on view: " << ns,
-            collection || !db->getViewCatalog()->lookup(txn, ns));
+            collection || !db->getViewCatalog()->lookup(opCtx, ns));
 
     // operation type -- see logOp() comments for types
     const char* opType = fieldOp.valuestrsafe();
@@ -768,15 +770,15 @@ Status applyOperation_inlock(OperationContext* txn,
             }
 
             bool relaxIndexConstraints =
-                ReplicationCoordinator::get(txn)->shouldRelaxIndexConstraints(txn, indexNss);
+                ReplicationCoordinator::get(opCtx)->shouldRelaxIndexConstraints(opCtx, indexNss);
             if (indexSpec["background"].trueValue()) {
-                Lock::TempRelease release(txn->lockState());
-                if (txn->lockState()->isLocked()) {
+                Lock::TempRelease release(opCtx->lockState());
+                if (opCtx->lockState()->isLocked()) {
                     // If TempRelease fails, background index build will deadlock.
                     LOG(3) << "apply op: building background index " << indexSpec
                            << " in the foreground because temp release failed";
                     IndexBuilder builder(indexSpec, relaxIndexConstraints);
-                    Status status = builder.buildInForeground(txn, db);
+                    Status status = builder.buildInForeground(opCtx, db);
                     uassertStatusOK(status);
                 } else {
                     IndexBuilder* builder = new IndexBuilder(indexSpec, relaxIndexConstraints);
@@ -785,10 +787,10 @@ Status applyOperation_inlock(OperationContext* txn,
                     // Wait for thread to start and register itself
                     IndexBuilder::waitForBgIndexStarting();
                 }
-                txn->recoveryUnit()->abandonSnapshot();
+                opCtx->recoveryUnit()->abandonSnapshot();
             } else {
                 IndexBuilder builder(indexSpec, relaxIndexConstraints);
-                Status status = builder.buildInForeground(txn, db);
+                Status status = builder.buildInForeground(opCtx, db);
                 uassertStatusOK(status);
             }
             // Since this is an index operation we can return without falling through.
@@ -812,10 +814,10 @@ Status applyOperation_inlock(OperationContext* txn,
                     str::stream() << "Failed to apply insert due to empty array element: "
                                   << op.toString(),
                     !insertObjs.empty());
-            WriteUnitOfWork wuow(txn);
+            WriteUnitOfWork wuow(opCtx);
             OpDebug* const nullOpDebug = nullptr;
             Status status = collection->insertDocuments(
-                txn, insertObjs.begin(), insertObjs.end(), nullOpDebug, true);
+                opCtx, insertObjs.begin(), insertObjs.end(), nullOpDebug, true);
             if (!status.isOK()) {
                 return status;
             }
@@ -849,10 +851,10 @@ Status applyOperation_inlock(OperationContext* txn,
             bool needToDoUpsert = haveWrappingWriteUnitOfWork;
 
             if (!needToDoUpsert) {
-                WriteUnitOfWork wuow(txn);
+                WriteUnitOfWork wuow(opCtx);
                 try {
                     OpDebug* const nullOpDebug = nullptr;
-                    status = collection->insertDocument(txn, o, nullOpDebug, true);
+                    status = collection->insertDocument(opCtx, o, nullOpDebug, true);
                 } catch (DBException dbe) {
                     status = dbe.toStatus();
                 }
@@ -881,7 +883,7 @@ Status applyOperation_inlock(OperationContext* txn,
                 UpdateLifecycleImpl updateLifecycle(requestNs);
                 request.setLifecycle(&updateLifecycle);
 
-                UpdateResult res = update(txn, db, request);
+                UpdateResult res = update(opCtx, db, request);
                 if (res.numMatched == 0 && res.upserted.isEmpty()) {
                     error() << "No document was updated even though we got a DuplicateKey "
                                "error when inserting";
@@ -912,7 +914,7 @@ Status applyOperation_inlock(OperationContext* txn,
         UpdateLifecycleImpl updateLifecycle(requestNs);
         request.setLifecycle(&updateLifecycle);
 
-        UpdateResult ur = update(txn, db, request);
+        UpdateResult ur = update(opCtx, db, request);
 
         if (ur.numMatched == 0 && ur.upserted.isEmpty()) {
             if (ur.modifiers) {
@@ -929,11 +931,11 @@ Status applyOperation_inlock(OperationContext* txn,
                 //   { _id:..., { x : {$size:...} }
                 // thus this is not ideal.
                 if (collection == NULL ||
-                    (indexCatalog->haveIdIndex(txn) &&
-                     Helpers::findById(txn, collection, updateCriteria).isNull()) ||
+                    (indexCatalog->haveIdIndex(opCtx) &&
+                     Helpers::findById(opCtx, collection, updateCriteria).isNull()) ||
                     // capped collections won't have an _id index
-                    (!indexCatalog->haveIdIndex(txn) &&
-                     Helpers::findOne(txn, collection, updateCriteria, false).isNull())) {
+                    (!indexCatalog->haveIdIndex(opCtx) &&
+                     Helpers::findOne(opCtx, collection, updateCriteria, false).isNull())) {
                     string msg = str::stream() << "couldn't find doc: " << redact(op);
                     error() << msg;
                     return Status(ErrorCodes::OperationFailed, msg);
@@ -963,7 +965,7 @@ Status applyOperation_inlock(OperationContext* txn,
                 o.hasField("_id"));
 
         if (opType[1] == 0) {
-            deleteObjects(txn, collection, ns, o, PlanExecutor::YIELD_MANUAL, /*justOne*/ valueB);
+            deleteObjects(opCtx, collection, ns, o, PlanExecutor::YIELD_MANUAL, /*justOne*/ valueB);
         } else
             verify(opType[1] == 'b');  // "db" advertisement
         if (incrementOpsAppliedStats) {
@@ -984,15 +986,15 @@ Status applyOperation_inlock(OperationContext* txn,
     // have a wrapping WUOW, the extra nexting is harmless. The logOp really should have been
     // done in the WUOW that did the write, but this won't happen because applyOps turns off
     // observers.
-    WriteUnitOfWork wuow(txn);
+    WriteUnitOfWork wuow(opCtx);
     getGlobalAuthorizationManager()->logOp(
-        txn, opType, ns.toString().c_str(), o, fieldO2.isABSONObj() ? &o2 : NULL);
+        opCtx, opType, ns.toString().c_str(), o, fieldO2.isABSONObj() ? &o2 : NULL);
     wuow.commit();
 
     return Status::OK();
 }
 
-Status applyCommand_inlock(OperationContext* txn,
+Status applyCommand_inlock(OperationContext* opCtx,
                            const BSONObj& op,
                            bool inSteadyStateReplication) {
     const char* names[] = {"o", "ns", "op"};
@@ -1023,8 +1025,8 @@ Status applyCommand_inlock(OperationContext* txn,
         return {ErrorCodes::InvalidNamespace, "invalid ns: " + std::string(nss.ns())};
     }
     {
-        Database* db = dbHolder().get(txn, nss.ns());
-        if (db && !db->getCollection(nss.ns()) && db->getViewCatalog()->lookup(txn, nss.ns())) {
+        Database* db = dbHolder().get(opCtx, nss.ns());
+        if (db && !db->getCollection(nss.ns()) && db->getViewCatalog()->lookup(opCtx, nss.ns())) {
             return {ErrorCodes::CommandNotSupportedOnView,
                     str::stream() << "applyOps not supported on view:" << nss.ns()};
         }
@@ -1040,7 +1042,7 @@ Status applyCommand_inlock(OperationContext* txn,
 
     // Applying commands in repl is done under Global W-lock, so it is safe to not
     // perform the current DB checks after reacquiring the lock.
-    invariant(txn->lockState()->isW());
+    invariant(opCtx->lockState()->isW());
 
     bool done = false;
 
@@ -1054,7 +1056,7 @@ Status applyCommand_inlock(OperationContext* txn,
         ApplyOpMetadata curOpToApply = op->second;
         Status status = Status::OK();
         try {
-            status = curOpToApply.applyFunc(txn, nss.ns().c_str(), o);
+            status = curOpToApply.applyFunc(opCtx, nss.ns().c_str(), o);
         } catch (...) {
             status = exceptionToStatus();
         }
@@ -1065,21 +1067,21 @@ Status applyCommand_inlock(OperationContext* txn,
                 throw WriteConflictException();
             }
             case ErrorCodes::BackgroundOperationInProgressForDatabase: {
-                Lock::TempRelease release(txn->lockState());
+                Lock::TempRelease release(opCtx->lockState());
 
                 BackgroundOperation::awaitNoBgOpInProgForDb(nss.db());
-                txn->recoveryUnit()->abandonSnapshot();
-                txn->checkForInterrupt();
+                opCtx->recoveryUnit()->abandonSnapshot();
+                opCtx->checkForInterrupt();
                 break;
             }
             case ErrorCodes::BackgroundOperationInProgressForNamespace: {
-                Lock::TempRelease release(txn->lockState());
+                Lock::TempRelease release(opCtx->lockState());
 
                 Command* cmd = Command::findCommand(o.firstElement().fieldName());
                 invariant(cmd);
                 BackgroundOperation::awaitNoBgOpInProgForNs(cmd->parseNs(nss.db().toString(), o));
-                txn->recoveryUnit()->abandonSnapshot();
-                txn->checkForInterrupt();
+                opCtx->recoveryUnit()->abandonSnapshot();
+                opCtx->checkForInterrupt();
                 break;
             }
             default:
@@ -1101,8 +1103,8 @@ Status applyCommand_inlock(OperationContext* txn,
 
     // AuthorizationManager's logOp method registers a RecoveryUnit::Change
     // and to do so we need to have begun a UnitOfWork
-    WriteUnitOfWork wuow(txn);
-    getGlobalAuthorizationManager()->logOp(txn, opType, nss.ns().c_str(), o, nullptr);
+    WriteUnitOfWork wuow(opCtx);
+    getGlobalAuthorizationManager()->logOp(opCtx, opType, nss.ns().c_str(), o, nullptr);
     wuow.commit();
 
     return Status::OK();
@@ -1114,19 +1116,19 @@ void setNewTimestamp(ServiceContext* service, const Timestamp& newTime) {
     newTimestampNotifier.notify_all();
 }
 
-void initTimestampFromOplog(OperationContext* txn, const std::string& oplogNS) {
-    DBDirectClient c(txn);
+void initTimestampFromOplog(OperationContext* opCtx, const std::string& oplogNS) {
+    DBDirectClient c(opCtx);
     BSONObj lastOp = c.findOne(oplogNS, Query().sort(reverseNaturalObj), NULL, QueryOption_SlaveOk);
 
     if (!lastOp.isEmpty()) {
         LOG(1) << "replSet setting last Timestamp";
         const OpTime opTime = fassertStatusOK(28696, OpTime::parseFromOplogEntry(lastOp));
-        setNewTimestamp(txn->getServiceContext(), opTime.getTimestamp());
+        setNewTimestamp(opCtx->getServiceContext(), opTime.getTimestamp());
     }
 }
 
-void oplogCheckCloseDatabase(OperationContext* txn, Database* db) {
-    invariant(txn->lockState()->isW());
+void oplogCheckCloseDatabase(OperationContext* opCtx, Database* db) {
+    invariant(opCtx->lockState()->isW());
 
     _localOplogCollection = nullptr;
 }
@@ -1213,8 +1215,8 @@ void SnapshotThread::run() {
         }
 
         try {
-            auto txn = client.makeOperationContext();
-            Lock::GlobalLock globalLock(txn->lockState(), MODE_IS, UINT_MAX);
+            auto opCtx = client.makeOperationContext();
+            Lock::GlobalLock globalLock(opCtx->lockState(), MODE_IS, UINT_MAX);
 
             if (!replCoord->getMemberState().readable()) {
                 // If our MemberState isn't readable, we may not be in a consistent state so don't
@@ -1231,9 +1233,9 @@ void SnapshotThread::run() {
                 // Make sure there are no in-flight capped inserts while we create our snapshot.
                 // This lock cannot be aquired until all writes holding the resource commit/abort.
                 Lock::ResourceLock cappedInsertLockForOtherDb(
-                    txn->lockState(), resourceCappedInFlightForOtherDb, MODE_X);
+                    opCtx->lockState(), resourceCappedInFlightForOtherDb, MODE_X);
                 Lock::ResourceLock cappedInsertLockForLocalDb(
-                    txn->lockState(), resourceCappedInFlightForLocalDb, MODE_X);
+                    opCtx->lockState(), resourceCappedInFlightForLocalDb, MODE_X);
 
                 // Reserve the name immediately before we take our snapshot. This ensures that all
                 // names that compare lower must be from points in time visible to this named
@@ -1241,15 +1243,15 @@ void SnapshotThread::run() {
                 name = replCoord->reserveSnapshotName(nullptr);
 
                 // This establishes the view that we will name.
-                _manager->prepareForCreateSnapshot(txn.get());
+                _manager->prepareForCreateSnapshot(opCtx.get());
             }
 
             auto opTimeOfSnapshot = OpTime();
             {
-                AutoGetCollectionForRead oplog(txn.get(), NamespaceString(rsOplogName));
+                AutoGetCollectionForRead oplog(opCtx.get(), NamespaceString(rsOplogName));
                 invariant(oplog.getCollection());
                 // Read the latest op from the oplog.
-                auto cursor = oplog.getCollection()->getCursor(txn.get(), /*forward*/ false);
+                auto cursor = oplog.getCollection()->getCursor(opCtx.get(), /*forward*/ false);
                 auto record = cursor->next();
                 if (!record)
                     continue;  // oplog is completely empty.
@@ -1259,7 +1261,7 @@ void SnapshotThread::run() {
                 invariant(!opTimeOfSnapshot.isNull());
             }
 
-            replCoord->createSnapshot(txn.get(), opTimeOfSnapshot, name);
+            replCoord->createSnapshot(opCtx.get(), opTimeOfSnapshot, name);
         } catch (const WriteConflictException& wce) {
             log() << "skipping storage snapshot pass due to write conflict";
             continue;
diff --git a/src/mongo/db/repl/oplog.h b/src/mongo/db/repl/oplog.h
index dc61805e789..fcff70fb607 100644
--- a/src/mongo/db/repl/oplog.h
+++ b/src/mongo/db/repl/oplog.h
@@ -50,20 +50,20 @@ class ReplSettings;
 /**
  * Truncates the oplog after, and including, the "truncateTimestamp" entry.
  */
-void truncateOplogTo(OperationContext* txn, Timestamp truncateTimestamp);
+void truncateOplogTo(OperationContext* opCtx, Timestamp truncateTimestamp);
 
 /**
  * Create a new capped collection for the oplog if it doesn't yet exist.
  * If the collection already exists (and isReplSet is false),
  * set the 'last' Timestamp from the last entry of the oplog collection (side effect!)
  */
-void createOplog(OperationContext* txn, const std::string& oplogCollectionName, bool isReplSet);
+void createOplog(OperationContext* opCtx, const std::string& oplogCollectionName, bool isReplSet);
 
 /*
  * Shortcut for above function using oplogCollectionName = _oplogCollectionName,
  * and replEnabled = replCoord::isReplSet();
  */
-void createOplog(OperationContext* txn);
+void createOplog(OperationContext* opCtx);
 
 extern std::string rsOplogName;
 extern std::string masterSlaveOplogName;
@@ -81,7 +81,7 @@ extern int OPLOG_VERSION;
  *  "db" declares presence of a database (ns is set to the db name + '.')
  */
 
-void logOps(OperationContext* txn,
+void logOps(OperationContext* opCtx,
             const char* opstr,
             const NamespaceString& nss,
             std::vector<BSONObj>::const_iterator begin,
@@ -91,7 +91,7 @@ void logOps(OperationContext* txn,
 /* For 'u' records, 'obj' captures the mutation made to the object but not
  * the object itself. 'o2' captures the the criteria for the object that will be modified.
  */
-void logOp(OperationContext* txn,
+void logOp(OperationContext* opCtx,
            const char* opstr,
            const char* ns,
            const BSONObj& obj,
@@ -100,7 +100,7 @@ void logOp(OperationContext* txn,
 
 // Flush out the cached pointers to the local database and oplog.
 // Used by the closeDatabase command to ensure we don't cache closed things.
-void oplogCheckCloseDatabase(OperationContext* txn, Database* db);
+void oplogCheckCloseDatabase(OperationContext* opCtx, Database* db);
 
 using IncrementOpsAppliedStatsFn = stdx::function<void()>;
 /**
@@ -110,7 +110,7 @@ using IncrementOpsAppliedStatsFn = stdx::function<void()>;
  * @param incrementOpsAppliedStats is called whenever an op is applied.
  * Returns failure status if the op was an update that could not be applied.
  */
-Status applyOperation_inlock(OperationContext* txn,
+Status applyOperation_inlock(OperationContext* opCtx,
                              Database* db,
                              const BSONObj& op,
                              bool inSteadyStateReplication = false,
@@ -123,17 +123,19 @@ Status applyOperation_inlock(OperationContext* txn,
  * initial sync.
  * Returns failure status if the op that could not be applied.
  */
-Status applyCommand_inlock(OperationContext* txn, const BSONObj& op, bool inSteadyStateReplication);
+Status applyCommand_inlock(OperationContext* opCtx,
+                           const BSONObj& op,
+                           bool inSteadyStateReplication);
 
 /**
  * Initializes the global Timestamp with the value from the timestamp of the last oplog entry.
  */
-void initTimestampFromOplog(OperationContext* txn, const std::string& oplogNS);
+void initTimestampFromOplog(OperationContext* opCtx, const std::string& oplogNS);
 
 /**
  * Sets the global Timestamp to be 'newTime'.
  */
-void setNewTimestamp(ServiceContext* txn, const Timestamp& newTime);
+void setNewTimestamp(ServiceContext* opCtx, const Timestamp& newTime);
 
 /**
  * Detects the current replication mode and sets the "_oplogCollectionName" accordingly.
diff --git a/src/mongo/db/repl/oplog_buffer.h b/src/mongo/db/repl/oplog_buffer.h
index 9695260c691..f177808a991 100644
--- a/src/mongo/db/repl/oplog_buffer.h
+++ b/src/mongo/db/repl/oplog_buffer.h
@@ -70,7 +70,7 @@ public:
      * create backing storage, etc). This method may be called at most once for the lifetime of an
      * oplog buffer.
      */
-    virtual void startup(OperationContext* txn) = 0;
+    virtual void startup(OperationContext* opCtx) = 0;
 
     /**
      * Signals to the oplog buffer that it should shut down. This method may block. After
@@ -79,7 +79,7 @@ public:
      * It is legal to call this method multiple times, but it should only be called after startup
      * has been called.
      */
-    virtual void shutdown(OperationContext* txn) = 0;
+    virtual void shutdown(OperationContext* opCtx) = 0;
 
     /**
      * Pushes operation into oplog buffer, ignoring any size constraints. Does not block.
@@ -87,26 +87,26 @@ public:
      * the limit returned by getMaxSize() but should not otherwise adversely affect normal
      * functionality such as pushing and popping operations from the oplog buffer.
      */
-    virtual void pushEvenIfFull(OperationContext* txn, const Value& value) = 0;
+    virtual void pushEvenIfFull(OperationContext* opCtx, const Value& value) = 0;
 
     /**
      * Pushes operation into oplog buffer.
      * If there are size constraints on the oplog buffer, this may block until sufficient space
      * is made available (by popping) to complete this operation.
      */
-    virtual void push(OperationContext* txn, const Value& value) = 0;
+    virtual void push(OperationContext* opCtx, const Value& value) = 0;
 
     /**
      * Pushes operations in the iterator range [begin, end) into the oplog buffer without blocking.
      */
-    virtual void pushAllNonBlocking(OperationContext* txn,
+    virtual void pushAllNonBlocking(OperationContext* opCtx,
                                     Batch::const_iterator begin,
                                     Batch::const_iterator end) = 0;
 
     /**
      * Returns when enough space is available.
      */
-    virtual void waitForSpace(OperationContext* txn, std::size_t size) = 0;
+    virtual void waitForSpace(OperationContext* opCtx, std::size_t size) = 0;
 
     /**
      * Returns true if oplog buffer is empty.
@@ -135,13 +135,13 @@ public:
     /**
      * Clears oplog buffer.
      */
-    virtual void clear(OperationContext* txn) = 0;
+    virtual void clear(OperationContext* opCtx) = 0;
 
     /**
      * Returns false if oplog buffer is empty. "value" is left unchanged.
      * Otherwise, removes last item (saves in "value") from the oplog buffer and returns true.
      */
-    virtual bool tryPop(OperationContext* txn, Value* value) = 0;
+    virtual bool tryPop(OperationContext* opCtx, Value* value) = 0;
 
     /**
      * Waits "waitDuration" for an operation to be pushed into the oplog buffer.
@@ -154,12 +154,12 @@ public:
      * Returns false if oplog buffer is empty.
      * Otherwise, returns true and sets "value" to last item in oplog buffer.
      */
-    virtual bool peek(OperationContext* txn, Value* value) = 0;
+    virtual bool peek(OperationContext* opCtx, Value* value) = 0;
 
     /**
      * Returns the item most recently added to the oplog buffer or nothing if the buffer is empty.
      */
-    virtual boost::optional<Value> lastObjectPushed(OperationContext* txn) const = 0;
+    virtual boost::optional<Value> lastObjectPushed(OperationContext* opCtx) const = 0;
 };
 
 }  // namespace repl
diff --git a/src/mongo/db/repl/oplog_buffer_blocking_queue.cpp b/src/mongo/db/repl/oplog_buffer_blocking_queue.cpp
index 9b9cdb82dac..72eb401ddb5 100644
--- a/src/mongo/db/repl/oplog_buffer_blocking_queue.cpp
+++ b/src/mongo/db/repl/oplog_buffer_blocking_queue.cpp
@@ -49,8 +49,8 @@ OplogBufferBlockingQueue::OplogBufferBlockingQueue() : _queue(kOplogBufferSize,
 
 void OplogBufferBlockingQueue::startup(OperationContext*) {}
 
-void OplogBufferBlockingQueue::shutdown(OperationContext* txn) {
-    clear(txn);
+void OplogBufferBlockingQueue::shutdown(OperationContext* opCtx) {
+    clear(opCtx);
 }
 
 void OplogBufferBlockingQueue::pushEvenIfFull(OperationContext*, const Value& value) {
diff --git a/src/mongo/db/repl/oplog_buffer_blocking_queue.h b/src/mongo/db/repl/oplog_buffer_blocking_queue.h
index b0fa36a8157..68c74779b0e 100644
--- a/src/mongo/db/repl/oplog_buffer_blocking_queue.h
+++ b/src/mongo/db/repl/oplog_buffer_blocking_queue.h
@@ -41,23 +41,23 @@ class OplogBufferBlockingQueue final : public OplogBuffer {
 public:
     OplogBufferBlockingQueue();
 
-    void startup(OperationContext* txn) override;
-    void shutdown(OperationContext* txn) override;
-    void pushEvenIfFull(OperationContext* txn, const Value& value) override;
-    void push(OperationContext* txn, const Value& value) override;
-    void pushAllNonBlocking(OperationContext* txn,
+    void startup(OperationContext* opCtx) override;
+    void shutdown(OperationContext* opCtx) override;
+    void pushEvenIfFull(OperationContext* opCtx, const Value& value) override;
+    void push(OperationContext* opCtx, const Value& value) override;
+    void pushAllNonBlocking(OperationContext* opCtx,
                             Batch::const_iterator begin,
                             Batch::const_iterator end) override;
-    void waitForSpace(OperationContext* txn, std::size_t size) override;
+    void waitForSpace(OperationContext* opCtx, std::size_t size) override;
     bool isEmpty() const override;
     std::size_t getMaxSize() const override;
     std::size_t getSize() const override;
     std::size_t getCount() const override;
-    void clear(OperationContext* txn) override;
-    bool tryPop(OperationContext* txn, Value* value) override;
+    void clear(OperationContext* opCtx) override;
+    bool tryPop(OperationContext* opCtx, Value* value) override;
     bool waitForData(Seconds waitDuration) override;
-    bool peek(OperationContext* txn, Value* value) override;
-    boost::optional<Value> lastObjectPushed(OperationContext* txn) const override;
+    bool peek(OperationContext* opCtx, Value* value) override;
+    boost::optional<Value> lastObjectPushed(OperationContext* opCtx) const override;
 
 private:
     BlockingQueue<BSONObj> _queue;
diff --git a/src/mongo/db/repl/oplog_buffer_collection.cpp b/src/mongo/db/repl/oplog_buffer_collection.cpp
index 1c74963cc14..f738312a3eb 100644
--- a/src/mongo/db/repl/oplog_buffer_collection.cpp
+++ b/src/mongo/db/repl/oplog_buffer_collection.cpp
@@ -93,27 +93,27 @@ OplogBufferCollection::Options OplogBufferCollection::getOptions() const {
     return _options;
 }
 
-void OplogBufferCollection::startup(OperationContext* txn) {
-    clear(txn);
+void OplogBufferCollection::startup(OperationContext* opCtx) {
+    clear(opCtx);
 }
 
-void OplogBufferCollection::shutdown(OperationContext* txn) {
+void OplogBufferCollection::shutdown(OperationContext* opCtx) {
     stdx::lock_guard<stdx::mutex> lk(_mutex);
-    _dropCollection(txn);
+    _dropCollection(opCtx);
     _size = 0;
     _count = 0;
 }
 
-void OplogBufferCollection::pushEvenIfFull(OperationContext* txn, const Value& value) {
+void OplogBufferCollection::pushEvenIfFull(OperationContext* opCtx, const Value& value) {
     Batch valueBatch = {value};
-    pushAllNonBlocking(txn, valueBatch.begin(), valueBatch.end());
+    pushAllNonBlocking(opCtx, valueBatch.begin(), valueBatch.end());
 }
 
-void OplogBufferCollection::push(OperationContext* txn, const Value& value) {
-    pushEvenIfFull(txn, value);
+void OplogBufferCollection::push(OperationContext* opCtx, const Value& value) {
+    pushEvenIfFull(opCtx, value);
 }
 
-void OplogBufferCollection::pushAllNonBlocking(OperationContext* txn,
+void OplogBufferCollection::pushAllNonBlocking(OperationContext* opCtx,
                                                Batch::const_iterator begin,
                                                Batch::const_iterator end) {
     if (begin == end) {
@@ -132,7 +132,7 @@ void OplogBufferCollection::pushAllNonBlocking(OperationContext* txn,
         return doc;
     });
 
-    auto status = _storageInterface->insertDocuments(txn, _nss, docsToInsert);
+    auto status = _storageInterface->insertDocuments(opCtx, _nss, docsToInsert);
     fassertStatusOK(40161, status);
 
     _lastPushedTimestamp = ts;
@@ -144,7 +144,7 @@ void OplogBufferCollection::pushAllNonBlocking(OperationContext* txn,
     _cvNoLongerEmpty.notify_all();
 }
 
-void OplogBufferCollection::waitForSpace(OperationContext* txn, std::size_t size) {}
+void OplogBufferCollection::waitForSpace(OperationContext* opCtx, std::size_t size) {}
 
 bool OplogBufferCollection::isEmpty() const {
     stdx::lock_guard<stdx::mutex> lk(_mutex);
@@ -165,10 +165,10 @@ std::size_t OplogBufferCollection::getCount() const {
     return _count;
 }
 
-void OplogBufferCollection::clear(OperationContext* txn) {
+void OplogBufferCollection::clear(OperationContext* opCtx) {
     stdx::lock_guard<stdx::mutex> lk(_mutex);
-    _dropCollection(txn);
-    _createCollection(txn);
+    _dropCollection(opCtx);
+    _createCollection(opCtx);
     _size = 0;
     _count = 0;
     _sentinelCount = 0;
@@ -177,12 +177,12 @@ void OplogBufferCollection::clear(OperationContext* txn) {
     _peekCache = std::queue<BSONObj>();
 }
 
-bool OplogBufferCollection::tryPop(OperationContext* txn, Value* value) {
+bool OplogBufferCollection::tryPop(OperationContext* opCtx, Value* value) {
     stdx::lock_guard<stdx::mutex> lk(_mutex);
     if (_count == 0) {
         return false;
     }
-    return _pop_inlock(txn, value);
+    return _pop_inlock(opCtx, value);
 }
 
 bool OplogBufferCollection::waitForData(Seconds waitDuration) {
@@ -194,24 +194,24 @@ bool OplogBufferCollection::waitForData(Seconds waitDuration) {
     return _count != 0;
 }
 
-bool OplogBufferCollection::peek(OperationContext* txn, Value* value) {
+bool OplogBufferCollection::peek(OperationContext* opCtx, Value* value) {
     stdx::lock_guard<stdx::mutex> lk(_mutex);
     if (_count == 0) {
         return false;
     }
-    *value = _peek_inlock(txn, PeekMode::kExtractEmbeddedDocument);
+    *value = _peek_inlock(opCtx, PeekMode::kExtractEmbeddedDocument);
     return true;
 }
 
 boost::optional<OplogBuffer::Value> OplogBufferCollection::lastObjectPushed(
-    OperationContext* txn) const {
+    OperationContext* opCtx) const {
     stdx::lock_guard<stdx::mutex> lk(_mutex);
     if (_count == 0) {
         return boost::none;
     }
     const auto docs =
         fassertStatusOK(40348,
-                        _storageInterface->findDocuments(txn,
+                        _storageInterface->findDocuments(opCtx,
                                                          _nss,
                                                          kIdIdxName,
                                                          StorageInterface::ScanDirection::kBackward,
@@ -222,9 +222,9 @@ boost::optional<OplogBuffer::Value> OplogBufferCollection::lastObjectPushed(
     return extractEmbeddedOplogDocument(docs.front()).getOwned();
 }
 
-bool OplogBufferCollection::_pop_inlock(OperationContext* txn, Value* value) {
+bool OplogBufferCollection::_pop_inlock(OperationContext* opCtx, Value* value) {
     BSONObj docFromCollection =
-        _peek_inlock(txn, PeekMode::kReturnUnmodifiedDocumentFromCollection);
+        _peek_inlock(opCtx, PeekMode::kReturnUnmodifiedDocumentFromCollection);
     _lastPoppedKey = docFromCollection["_id"].wrap("");
     *value = extractEmbeddedOplogDocument(docFromCollection).getOwned();
 
@@ -239,7 +239,7 @@ bool OplogBufferCollection::_pop_inlock(OperationContext* txn, Value* value) {
     return true;
 }
 
-BSONObj OplogBufferCollection::_peek_inlock(OperationContext* txn, PeekMode peekMode) {
+BSONObj OplogBufferCollection::_peek_inlock(OperationContext* opCtx, PeekMode peekMode) {
     invariant(_count > 0);
 
     BSONObj startKey;
@@ -259,7 +259,7 @@ BSONObj OplogBufferCollection::_peek_inlock(OperationContext* txn, PeekMode peek
         std::size_t limit = isPeekCacheEnabled ? _options.peekCacheSize : 1U;
         const auto docs = fassertStatusOK(
             40163,
-            _storageInterface->findDocuments(txn,
+            _storageInterface->findDocuments(opCtx,
                                              _nss,
                                              kIdIdxName,
                                              StorageInterface::ScanDirection::kForward,
@@ -286,14 +286,14 @@ BSONObj OplogBufferCollection::_peek_inlock(OperationContext* txn, PeekMode peek
     MONGO_UNREACHABLE;
 }
 
-void OplogBufferCollection::_createCollection(OperationContext* txn) {
+void OplogBufferCollection::_createCollection(OperationContext* opCtx) {
     CollectionOptions options;
     options.temp = true;
-    fassert(40154, _storageInterface->createCollection(txn, _nss, options));
+    fassert(40154, _storageInterface->createCollection(opCtx, _nss, options));
 }
 
-void OplogBufferCollection::_dropCollection(OperationContext* txn) {
-    fassert(40155, _storageInterface->dropCollection(txn, _nss));
+void OplogBufferCollection::_dropCollection(OperationContext* opCtx) {
+    fassert(40155, _storageInterface->dropCollection(opCtx, _nss));
 }
 
 std::size_t OplogBufferCollection::getSentinelCount_forTest() const {
diff --git a/src/mongo/db/repl/oplog_buffer_collection.h b/src/mongo/db/repl/oplog_buffer_collection.h
index cb4cbcac8b8..1636b5bc7b8 100644
--- a/src/mongo/db/repl/oplog_buffer_collection.h
+++ b/src/mongo/db/repl/oplog_buffer_collection.h
@@ -109,27 +109,27 @@ public:
      */
     Options getOptions() const;
 
-    void startup(OperationContext* txn) override;
-    void shutdown(OperationContext* txn) override;
-    void pushEvenIfFull(OperationContext* txn, const Value& value) override;
-    void push(OperationContext* txn, const Value& value) override;
+    void startup(OperationContext* opCtx) override;
+    void shutdown(OperationContext* opCtx) override;
+    void pushEvenIfFull(OperationContext* opCtx, const Value& value) override;
+    void push(OperationContext* opCtx, const Value& value) override;
     /**
      * Pushing documents with 'pushAllNonBlocking' will not handle sentinel documents properly. If
      * pushing sentinel documents is required, use 'push' or 'pushEvenIfFull'.
      */
-    void pushAllNonBlocking(OperationContext* txn,
+    void pushAllNonBlocking(OperationContext* opCtx,
                             Batch::const_iterator begin,
                             Batch::const_iterator end) override;
-    void waitForSpace(OperationContext* txn, std::size_t size) override;
+    void waitForSpace(OperationContext* opCtx, std::size_t size) override;
     bool isEmpty() const override;
     std::size_t getMaxSize() const override;
     std::size_t getSize() const override;
     std::size_t getCount() const override;
-    void clear(OperationContext* txn) override;
-    bool tryPop(OperationContext* txn, Value* value) override;
+    void clear(OperationContext* opCtx) override;
+    bool tryPop(OperationContext* opCtx, Value* value) override;
     bool waitForData(Seconds waitDuration) override;
-    bool peek(OperationContext* txn, Value* value) override;
-    boost::optional<Value> lastObjectPushed(OperationContext* txn) const override;
+    bool peek(OperationContext* opCtx, Value* value) override;
+    boost::optional<Value> lastObjectPushed(OperationContext* opCtx) const override;
 
     // ---- Testing API ----
     std::size_t getSentinelCount_forTest() const;
@@ -141,19 +141,19 @@ private:
     /*
      * Creates a temporary collection with the _nss namespace.
      */
-    void _createCollection(OperationContext* txn);
+    void _createCollection(OperationContext* opCtx);
 
     /*
      * Drops the collection with the _nss namespace.
      */
-    void _dropCollection(OperationContext* txn);
+    void _dropCollection(OperationContext* opCtx);
 
     enum class PeekMode { kExtractEmbeddedDocument, kReturnUnmodifiedDocumentFromCollection };
     /**
      * Returns the oldest oplog entry in the buffer.
      * Assumes the buffer is not empty.
      */
-    BSONObj _peek_inlock(OperationContext* txn, PeekMode peekMode);
+    BSONObj _peek_inlock(OperationContext* opCtx, PeekMode peekMode);
 
     // Storage interface used to perform storage engine level functions on the collection.
     StorageInterface* _storageInterface;
@@ -161,7 +161,7 @@ private:
     /**
      * Pops an entry off the buffer in a lock.
      */
-    bool _pop_inlock(OperationContext* txn, Value* value);
+    bool _pop_inlock(OperationContext* opCtx, Value* value);
 
     // The namespace for the oplog buffer collection.
     const NamespaceString _nss;
diff --git a/src/mongo/db/repl/oplog_buffer_collection_test.cpp b/src/mongo/db/repl/oplog_buffer_collection_test.cpp
index ced9ab1f495..1ee2c3ccc8c 100644
--- a/src/mongo/db/repl/oplog_buffer_collection_test.cpp
+++ b/src/mongo/db/repl/oplog_buffer_collection_test.cpp
@@ -60,7 +60,7 @@ protected:
     ServiceContext::UniqueOperationContext makeOperationContext() const;
 
     StorageInterface* _storageInterface = nullptr;
-    ServiceContext::UniqueOperationContext _txn;
+    ServiceContext::UniqueOperationContext _opCtx;
 
 private:
     void setUp() override;
@@ -82,11 +82,11 @@ void OplogBufferCollectionTest::setUp() {
     _storageInterface = storageInterface.get();
     StorageInterface::set(service, std::move(storageInterface));
 
-    _txn = makeOperationContext();
+    _opCtx = makeOperationContext();
 }
 
 void OplogBufferCollectionTest::tearDown() {
-    _txn.reset();
+    _opCtx.reset();
     _storageInterface = nullptr;
     ServiceContextMongoDTest::tearDown();
 }
@@ -131,50 +131,50 @@ TEST_F(OplogBufferCollectionTest, GetNamespace) {
     ASSERT_EQUALS(nss, OplogBufferCollection(_storageInterface, nss).getNamespace());
 }
 
-void testStartupCreatesCollection(OperationContext* txn,
+void testStartupCreatesCollection(OperationContext* opCtx,
                                   StorageInterface* storageInterface,
                                   const NamespaceString& nss) {
     OplogBufferCollection oplogBuffer(storageInterface, nss);
 
     // Collection should not exist until startup() is called.
-    ASSERT_FALSE(AutoGetCollectionForRead(txn, nss).getCollection());
+    ASSERT_FALSE(AutoGetCollectionForRead(opCtx, nss).getCollection());
 
-    oplogBuffer.startup(txn);
-    ASSERT_TRUE(AutoGetCollectionForRead(txn, nss).getCollection());
+    oplogBuffer.startup(opCtx);
+    ASSERT_TRUE(AutoGetCollectionForRead(opCtx, nss).getCollection());
 }
 
 TEST_F(OplogBufferCollectionTest, StartupWithDefaultNamespaceCreatesCollection) {
     auto nss = OplogBufferCollection::getDefaultNamespace();
     ASSERT_FALSE(nss.isOplog());
-    testStartupCreatesCollection(_txn.get(), _storageInterface, nss);
+    testStartupCreatesCollection(_opCtx.get(), _storageInterface, nss);
 }
 
 TEST_F(OplogBufferCollectionTest, StartupWithUserProvidedNamespaceCreatesCollection) {
-    testStartupCreatesCollection(_txn.get(), _storageInterface, makeNamespace(_agent));
+    testStartupCreatesCollection(_opCtx.get(), _storageInterface, makeNamespace(_agent));
 }
 
 TEST_F(OplogBufferCollectionTest, StartupDropsExistingCollectionBeforeCreatingNewCollection) {
     auto nss = makeNamespace(_agent);
-    ASSERT_OK(_storageInterface->createCollection(_txn.get(), nss, CollectionOptions()));
+    ASSERT_OK(_storageInterface->createCollection(_opCtx.get(), nss, CollectionOptions()));
     OplogBufferCollection oplogBuffer(_storageInterface, nss);
-    oplogBuffer.startup(_txn.get());
-    ASSERT_TRUE(AutoGetCollectionForRead(_txn.get(), nss).getCollection());
+    oplogBuffer.startup(_opCtx.get());
+    ASSERT_TRUE(AutoGetCollectionForRead(_opCtx.get(), nss).getCollection());
 }
 
 DEATH_TEST_F(OplogBufferCollectionTest,
              StartupWithOplogNamespaceTriggersFatalAssertion,
              "Fatal assertion 40154 Location28838: cannot create a non-capped oplog collection") {
-    testStartupCreatesCollection(_txn.get(), _storageInterface, NamespaceString("local.oplog.Z"));
+    testStartupCreatesCollection(_opCtx.get(), _storageInterface, NamespaceString("local.oplog.Z"));
 }
 
 TEST_F(OplogBufferCollectionTest, ShutdownDropsCollection) {
     auto nss = makeNamespace(_agent);
     OplogBufferCollection oplogBuffer(_storageInterface, nss);
 
-    oplogBuffer.startup(_txn.get());
-    ASSERT_TRUE(AutoGetCollectionForRead(_txn.get(), nss).getCollection());
-    oplogBuffer.shutdown(_txn.get());
-    ASSERT_FALSE(AutoGetCollectionForRead(_txn.get(), nss).getCollection());
+    oplogBuffer.startup(_opCtx.get());
+    ASSERT_TRUE(AutoGetCollectionForRead(_opCtx.get(), nss).getCollection());
+    oplogBuffer.shutdown(_opCtx.get());
+    ASSERT_FALSE(AutoGetCollectionForRead(_opCtx.get(), nss).getCollection());
 }
 
 TEST_F(OplogBufferCollectionTest, extractEmbeddedOplogDocumentChangesIdToTimestamp) {
@@ -250,7 +250,7 @@ DEATH_TEST_F(OplogBufferCollectionTest,
 /**
  * Check collection contents. OplogInterface returns documents in reverse natural order.
  */
-void _assertDocumentsInCollectionEquals(OperationContext* txn,
+void _assertDocumentsInCollectionEquals(OperationContext* opCtx,
                                         const NamespaceString& nss,
                                         const std::vector<BSONObj>& docs) {
     std::vector<BSONObj> reversedTransformedDocs;
@@ -269,7 +269,7 @@ void _assertDocumentsInCollectionEquals(OperationContext* txn,
         ASSERT_GT(ts, previousTimestamp);
     }
     std::reverse(reversedTransformedDocs.begin(), reversedTransformedDocs.end());
-    OplogInterfaceLocal oplog(txn, nss.ns());
+    OplogInterfaceLocal oplog(opCtx, nss.ns());
     auto iter = oplog.makeIterator();
     for (const auto& doc : reversedTransformedDocs) {
         ASSERT_BSONOBJ_EQ(doc, unittest::assertGet(iter->next()).first);
@@ -281,13 +281,13 @@ TEST_F(OplogBufferCollectionTest, PushOneDocumentWithPushAllNonBlockingAddsDocum
     auto nss = makeNamespace(_agent);
     OplogBufferCollection oplogBuffer(_storageInterface, nss);
 
-    oplogBuffer.startup(_txn.get());
+    oplogBuffer.startup(_opCtx.get());
     const std::vector<BSONObj> oplog = {makeOplogEntry(1)};
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
-    oplogBuffer.pushAllNonBlocking(_txn.get(), oplog.begin(), oplog.end());
+    oplogBuffer.pushAllNonBlocking(_opCtx.get(), oplog.begin(), oplog.end());
     ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
 
-    _assertDocumentsInCollectionEquals(_txn.get(), nss, oplog);
+    _assertDocumentsInCollectionEquals(_opCtx.get(), nss, oplog);
 }
 
 TEST_F(OplogBufferCollectionTest,
@@ -295,7 +295,7 @@ TEST_F(OplogBufferCollectionTest,
     auto nss = makeNamespace(_agent);
     OplogBufferCollection oplogBuffer(_storageInterface, nss);
 
-    oplogBuffer.startup(_txn.get());
+    oplogBuffer.startup(_opCtx.get());
     const std::vector<BSONObj> emptyOplogEntries;
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
     oplogBuffer.pushAllNonBlocking(nullptr, emptyOplogEntries.begin(), emptyOplogEntries.end());
@@ -306,163 +306,163 @@ TEST_F(OplogBufferCollectionTest, PushOneDocumentWithPushAddsDocument) {
     auto nss = makeNamespace(_agent);
     OplogBufferCollection oplogBuffer(_storageInterface, nss);
 
-    oplogBuffer.startup(_txn.get());
+    oplogBuffer.startup(_opCtx.get());
     BSONObj oplog = makeOplogEntry(1);
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
-    oplogBuffer.push(_txn.get(), oplog);
+    oplogBuffer.push(_opCtx.get(), oplog);
     ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
 
-    _assertDocumentsInCollectionEquals(_txn.get(), nss, {oplog});
+    _assertDocumentsInCollectionEquals(_opCtx.get(), nss, {oplog});
 }
 
 TEST_F(OplogBufferCollectionTest, PushOneDocumentWithPushEvenIfFullAddsDocument) {
     auto nss = makeNamespace(_agent);
     OplogBufferCollection oplogBuffer(_storageInterface, nss);
 
-    oplogBuffer.startup(_txn.get());
+    oplogBuffer.startup(_opCtx.get());
     BSONObj oplog = makeOplogEntry(1);
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
-    oplogBuffer.pushEvenIfFull(_txn.get(), oplog);
+    oplogBuffer.pushEvenIfFull(_opCtx.get(), oplog);
     ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
 
     ASSERT_EQUALS(0UL, oplogBuffer.getSentinelCount_forTest());
 
-    _assertDocumentsInCollectionEquals(_txn.get(), nss, {oplog});
+    _assertDocumentsInCollectionEquals(_opCtx.get(), nss, {oplog});
 }
 
 TEST_F(OplogBufferCollectionTest, PeekDoesNotRemoveDocument) {
     auto nss = makeNamespace(_agent);
     OplogBufferCollection oplogBuffer(_storageInterface, nss);
 
-    oplogBuffer.startup(_txn.get());
+    oplogBuffer.startup(_opCtx.get());
     BSONObj oplog1 = makeOplogEntry(1);
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
-    oplogBuffer.push(_txn.get(), oplog1);
+    oplogBuffer.push(_opCtx.get(), oplog1);
     ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
 
     // _peekOneSide should provide correct bound inclusion to storage engine when collection has one
     // document.
     BSONObj doc;
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(doc, oplog1);
     ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
 
     BSONObj oplog2 = makeOplogEntry(2);
-    oplogBuffer.push(_txn.get(), oplog2);
+    oplogBuffer.push(_opCtx.get(), oplog2);
     ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
 
     // _peekOneSide should return same result after adding new oplog entry.
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(doc, oplog1);
     ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
 
-    _assertDocumentsInCollectionEquals(_txn.get(), nss, {oplog1, oplog2});
+    _assertDocumentsInCollectionEquals(_opCtx.get(), nss, {oplog1, oplog2});
 }
 
 TEST_F(OplogBufferCollectionTest, PeekWithNoDocumentsReturnsFalse) {
     auto nss = makeNamespace(_agent);
     OplogBufferCollection oplogBuffer(_storageInterface, nss);
 
-    oplogBuffer.startup(_txn.get());
+    oplogBuffer.startup(_opCtx.get());
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
 
     BSONObj doc;
-    ASSERT_FALSE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_FALSE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_TRUE(doc.isEmpty());
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
 
-    _assertDocumentsInCollectionEquals(_txn.get(), nss, {});
+    _assertDocumentsInCollectionEquals(_opCtx.get(), nss, {});
 }
 
 TEST_F(OplogBufferCollectionTest, PopDoesNotRemoveDocumentFromCollection) {
     auto nss = makeNamespace(_agent);
     OplogBufferCollection oplogBuffer(_storageInterface, nss);
 
-    oplogBuffer.startup(_txn.get());
+    oplogBuffer.startup(_opCtx.get());
     BSONObj oplog = makeOplogEntry(1);
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
-    oplogBuffer.push(_txn.get(), oplog);
+    oplogBuffer.push(_opCtx.get(), oplog);
     ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
 
     BSONObj doc;
-    ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(doc, oplog);
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
 
-    _assertDocumentsInCollectionEquals(_txn.get(), nss, {oplog});
+    _assertDocumentsInCollectionEquals(_opCtx.get(), nss, {oplog});
 }
 
 TEST_F(OplogBufferCollectionTest, PopWithNoDocumentsReturnsFalse) {
     auto nss = makeNamespace(_agent);
     OplogBufferCollection oplogBuffer(_storageInterface, nss);
 
-    oplogBuffer.startup(_txn.get());
+    oplogBuffer.startup(_opCtx.get());
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
 
     BSONObj doc;
-    ASSERT_FALSE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_FALSE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     ASSERT_TRUE(doc.isEmpty());
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
 
-    _assertDocumentsInCollectionEquals(_txn.get(), nss, {});
+    _assertDocumentsInCollectionEquals(_opCtx.get(), nss, {});
 }
 
 TEST_F(OplogBufferCollectionTest, PopAndPeekReturnDocumentsInOrder) {
     auto nss = makeNamespace(_agent);
     OplogBufferCollection oplogBuffer(_storageInterface, nss);
 
-    oplogBuffer.startup(_txn.get());
+    oplogBuffer.startup(_opCtx.get());
     const std::vector<BSONObj> oplog = {
         makeOplogEntry(1), makeOplogEntry(2), makeOplogEntry(3),
     };
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
-    oplogBuffer.pushAllNonBlocking(_txn.get(), oplog.begin(), oplog.end());
+    oplogBuffer.pushAllNonBlocking(_opCtx.get(), oplog.begin(), oplog.end());
     ASSERT_EQUALS(oplogBuffer.getCount(), 3UL);
 
-    _assertDocumentsInCollectionEquals(_txn.get(), nss, oplog);
+    _assertDocumentsInCollectionEquals(_opCtx.get(), nss, oplog);
 
     BSONObj doc;
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(doc, oplog[0]);
     ASSERT_EQUALS(oplogBuffer.getCount(), 3UL);
 
-    ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(doc, oplog[0]);
     ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
 
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(doc, oplog[1]);
     ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
 
-    ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(doc, oplog[1]);
     ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
 
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(doc, oplog[2]);
     ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
 
-    ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(doc, oplog[2]);
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
 
     // tryPop does not remove documents from collection.
-    _assertDocumentsInCollectionEquals(_txn.get(), nss, oplog);
+    _assertDocumentsInCollectionEquals(_opCtx.get(), nss, oplog);
 }
 
 TEST_F(OplogBufferCollectionTest, LastObjectPushedReturnsNewestOplogEntry) {
     auto nss = makeNamespace(_agent);
     OplogBufferCollection oplogBuffer(_storageInterface, nss);
 
-    oplogBuffer.startup(_txn.get());
+    oplogBuffer.startup(_opCtx.get());
     const std::vector<BSONObj> oplog = {
         makeOplogEntry(1), makeOplogEntry(2), makeOplogEntry(3),
     };
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
-    oplogBuffer.pushAllNonBlocking(_txn.get(), oplog.begin(), oplog.end());
+    oplogBuffer.pushAllNonBlocking(_opCtx.get(), oplog.begin(), oplog.end());
     ASSERT_EQUALS(oplogBuffer.getCount(), 3UL);
 
-    auto doc = oplogBuffer.lastObjectPushed(_txn.get());
+    auto doc = oplogBuffer.lastObjectPushed(_opCtx.get());
     ASSERT_BSONOBJ_EQ(*doc, oplog[2]);
     ASSERT_EQUALS(oplogBuffer.getCount(), 3UL);
 }
@@ -471,9 +471,9 @@ TEST_F(OplogBufferCollectionTest, LastObjectPushedReturnsNoneWithNoEntries) {
     auto nss = makeNamespace(_agent);
     OplogBufferCollection oplogBuffer(_storageInterface, nss);
 
-    oplogBuffer.startup(_txn.get());
+    oplogBuffer.startup(_opCtx.get());
 
-    auto doc = oplogBuffer.lastObjectPushed(_txn.get());
+    auto doc = oplogBuffer.lastObjectPushed(_opCtx.get());
     ASSERT_EQUALS(doc, boost::none);
 }
 
@@ -481,10 +481,10 @@ TEST_F(OplogBufferCollectionTest, IsEmptyReturnsTrueWhenEmptyAndFalseWhenNot) {
     auto nss = makeNamespace(_agent);
     OplogBufferCollection oplogBuffer(_storageInterface, nss);
 
-    oplogBuffer.startup(_txn.get());
+    oplogBuffer.startup(_opCtx.get());
     BSONObj oplog = makeOplogEntry(1);
     ASSERT_TRUE(oplogBuffer.isEmpty());
-    oplogBuffer.pushEvenIfFull(_txn.get(), oplog);
+    oplogBuffer.pushEvenIfFull(_opCtx.get(), oplog);
     ASSERT_FALSE(oplogBuffer.isEmpty());
 }
 
@@ -492,7 +492,7 @@ TEST_F(OplogBufferCollectionTest, ClearClearsCollection) {
     auto nss = makeNamespace(_agent);
     OplogBufferCollection oplogBuffer(_storageInterface, nss);
 
-    oplogBuffer.startup(_txn.get());
+    oplogBuffer.startup(_opCtx.get());
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
     ASSERT_EQUALS(oplogBuffer.getSize(), 0UL);
     ASSERT_EQUALS(0U, oplogBuffer.getSentinelCount_forTest());
@@ -500,27 +500,27 @@ TEST_F(OplogBufferCollectionTest, ClearClearsCollection) {
     ASSERT_EQUALS(Timestamp(), oplogBuffer.getLastPoppedTimestamp_forTest());
 
     BSONObj oplog = makeOplogEntry(1);
-    oplogBuffer.push(_txn.get(), oplog);
+    oplogBuffer.push(_opCtx.get(), oplog);
     ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
     ASSERT_EQUALS(oplogBuffer.getSize(), std::size_t(oplog.objsize()));
     ASSERT_EQUALS(0U, oplogBuffer.getSentinelCount_forTest());
     ASSERT_EQUALS(oplog["ts"].timestamp(), oplogBuffer.getLastPushedTimestamp_forTest());
     ASSERT_EQUALS(Timestamp(), oplogBuffer.getLastPoppedTimestamp_forTest());
 
-    _assertDocumentsInCollectionEquals(_txn.get(), nss, {oplog});
+    _assertDocumentsInCollectionEquals(_opCtx.get(), nss, {oplog});
 
     BSONObj sentinel;
-    oplogBuffer.push(_txn.get(), sentinel);
+    oplogBuffer.push(_opCtx.get(), sentinel);
     ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
     ASSERT_EQUALS(oplogBuffer.getSize(), std::size_t(oplog.objsize() + BSONObj().objsize()));
     ASSERT_EQUALS(1U, oplogBuffer.getSentinelCount_forTest());
     ASSERT_EQUALS(oplog["ts"].timestamp(), oplogBuffer.getLastPushedTimestamp_forTest());
     ASSERT_EQUALS(Timestamp(), oplogBuffer.getLastPoppedTimestamp_forTest());
 
-    _assertDocumentsInCollectionEquals(_txn.get(), nss, {oplog, sentinel});
+    _assertDocumentsInCollectionEquals(_opCtx.get(), nss, {oplog, sentinel});
 
     BSONObj oplog2 = makeOplogEntry(2);
-    oplogBuffer.push(_txn.get(), oplog2);
+    oplogBuffer.push(_opCtx.get(), oplog2);
     ASSERT_EQUALS(oplogBuffer.getCount(), 3UL);
     ASSERT_EQUALS(oplogBuffer.getSize(),
                   std::size_t(oplog.objsize() + BSONObj().objsize() + oplog2.objsize()));
@@ -528,10 +528,10 @@ TEST_F(OplogBufferCollectionTest, ClearClearsCollection) {
     ASSERT_EQUALS(oplog2["ts"].timestamp(), oplogBuffer.getLastPushedTimestamp_forTest());
     ASSERT_EQUALS(Timestamp(), oplogBuffer.getLastPoppedTimestamp_forTest());
 
-    _assertDocumentsInCollectionEquals(_txn.get(), nss, {oplog, sentinel, oplog2});
+    _assertDocumentsInCollectionEquals(_opCtx.get(), nss, {oplog, sentinel, oplog2});
 
     BSONObj poppedDoc;
-    ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &poppedDoc));
+    ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &poppedDoc));
     ASSERT_BSONOBJ_EQ(oplog, poppedDoc);
     ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
     ASSERT_EQUALS(oplogBuffer.getSize(), std::size_t(BSONObj().objsize() + oplog2.objsize()));
@@ -539,29 +539,29 @@ TEST_F(OplogBufferCollectionTest, ClearClearsCollection) {
     ASSERT_EQUALS(oplog2["ts"].timestamp(), oplogBuffer.getLastPushedTimestamp_forTest());
     ASSERT_EQUALS(oplog["ts"].timestamp(), oplogBuffer.getLastPoppedTimestamp_forTest());
 
-    _assertDocumentsInCollectionEquals(_txn.get(), nss, {oplog, sentinel, oplog2});
+    _assertDocumentsInCollectionEquals(_opCtx.get(), nss, {oplog, sentinel, oplog2});
 
-    oplogBuffer.clear(_txn.get());
-    ASSERT_TRUE(AutoGetCollectionForRead(_txn.get(), nss).getCollection());
+    oplogBuffer.clear(_opCtx.get());
+    ASSERT_TRUE(AutoGetCollectionForRead(_opCtx.get(), nss).getCollection());
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
     ASSERT_EQUALS(oplogBuffer.getSize(), 0UL);
     ASSERT_EQUALS(0U, oplogBuffer.getSentinelCount_forTest());
     ASSERT_EQUALS(Timestamp(), oplogBuffer.getLastPushedTimestamp_forTest());
     ASSERT_EQUALS(Timestamp(), oplogBuffer.getLastPoppedTimestamp_forTest());
 
-    _assertDocumentsInCollectionEquals(_txn.get(), nss, {});
+    _assertDocumentsInCollectionEquals(_opCtx.get(), nss, {});
 
     BSONObj doc;
-    ASSERT_FALSE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_FALSE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_TRUE(doc.isEmpty());
-    ASSERT_FALSE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_FALSE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     ASSERT_TRUE(doc.isEmpty());
 }
 
 TEST_F(OplogBufferCollectionTest, WaitForDataBlocksAndFindsDocument) {
     auto nss = makeNamespace(_agent);
     OplogBufferCollection oplogBuffer(_storageInterface, nss);
-    oplogBuffer.startup(_txn.get());
+    oplogBuffer.startup(_opCtx.get());
 
     unittest::Barrier barrier(2U);
     BSONObj oplog = makeOplogEntry(1);
@@ -578,11 +578,11 @@ TEST_F(OplogBufferCollectionTest, WaitForDataBlocksAndFindsDocument) {
 
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
     barrier.countDownAndWait();
-    oplogBuffer.push(_txn.get(), oplog);
+    oplogBuffer.push(_opCtx.get(), oplog);
     peekingThread.join();
     ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
     ASSERT_TRUE(success);
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(doc, oplog);
     ASSERT_EQUALS(count, 1UL);
 }
@@ -590,7 +590,7 @@ TEST_F(OplogBufferCollectionTest, WaitForDataBlocksAndFindsDocument) {
 TEST_F(OplogBufferCollectionTest, TwoWaitForDataInvocationsBlockAndFindSameDocument) {
     auto nss = makeNamespace(_agent);
     OplogBufferCollection oplogBuffer(_storageInterface, nss);
-    oplogBuffer.startup(_txn.get());
+    oplogBuffer.startup(_opCtx.get());
 
     unittest::Barrier barrier(3U);
     BSONObj oplog = makeOplogEntry(1);
@@ -616,13 +616,13 @@ TEST_F(OplogBufferCollectionTest, TwoWaitForDataInvocationsBlockAndFindSameDocum
 
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
     barrier.countDownAndWait();
-    oplogBuffer.push(_txn.get(), oplog);
+    oplogBuffer.push(_opCtx.get(), oplog);
     peekingThread1.join();
     peekingThread2.join();
     ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
     ASSERT_TRUE(success1);
     BSONObj doc;
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(doc, oplog);
     ASSERT_EQUALS(count1, 1UL);
     ASSERT_TRUE(success2);
@@ -632,7 +632,7 @@ TEST_F(OplogBufferCollectionTest, TwoWaitForDataInvocationsBlockAndFindSameDocum
 TEST_F(OplogBufferCollectionTest, WaitForDataBlocksAndTimesOutWhenItDoesNotFindDocument) {
     auto nss = makeNamespace(_agent);
     OplogBufferCollection oplogBuffer(_storageInterface, nss);
-    oplogBuffer.startup(_txn.get());
+    oplogBuffer.startup(_opCtx.get());
 
     BSONObj doc;
     bool success = false;
@@ -648,95 +648,95 @@ TEST_F(OplogBufferCollectionTest, WaitForDataBlocksAndTimesOutWhenItDoesNotFindD
     peekingThread.join();
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
     ASSERT_FALSE(success);
-    ASSERT_FALSE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_FALSE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_TRUE(doc.isEmpty());
     ASSERT_EQUALS(count, 0UL);
 }
 
 void _testPushSentinelsProperly(
-    OperationContext* txn,
+    OperationContext* opCtx,
     const NamespaceString& nss,
     StorageInterface* storageInterface,
-    stdx::function<void(OperationContext* txn,
+    stdx::function<void(OperationContext* opCtx,
                         OplogBufferCollection* oplogBuffer,
                         const std::vector<BSONObj>& oplog)> pushDocsFn) {
     OplogBufferCollection oplogBuffer(storageInterface, nss);
-    oplogBuffer.startup(txn);
+    oplogBuffer.startup(opCtx);
     const std::vector<BSONObj> oplog = {
         BSONObj(), makeOplogEntry(1), BSONObj(), BSONObj(), makeOplogEntry(2), BSONObj(),
     };
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
-    pushDocsFn(txn, &oplogBuffer, oplog);
+    pushDocsFn(opCtx, &oplogBuffer, oplog);
     ASSERT_EQUALS(oplogBuffer.getCount(), 6UL);
-    _assertDocumentsInCollectionEquals(txn, nss, oplog);
+    _assertDocumentsInCollectionEquals(opCtx, nss, oplog);
 }
 
 TEST_F(OplogBufferCollectionTest, PushPushesOnSentinelsProperly) {
     auto nss = makeNamespace(_agent);
-    _testPushSentinelsProperly(_txn.get(),
+    _testPushSentinelsProperly(_opCtx.get(),
                                nss,
                                _storageInterface,
-                               [](OperationContext* txn,
+                               [](OperationContext* opCtx,
                                   OplogBufferCollection* oplogBuffer,
                                   const std::vector<BSONObj>& oplog) {
-                                   oplogBuffer->push(txn, oplog[0]);
+                                   oplogBuffer->push(opCtx, oplog[0]);
                                    ASSERT_EQUALS(1U, oplogBuffer->getSentinelCount_forTest());
 
-                                   oplogBuffer->push(txn, oplog[1]);
+                                   oplogBuffer->push(opCtx, oplog[1]);
                                    ASSERT_EQUALS(0U, oplogBuffer->getSentinelCount_forTest());
 
-                                   oplogBuffer->push(txn, oplog[2]);
+                                   oplogBuffer->push(opCtx, oplog[2]);
                                    ASSERT_EQUALS(1U, oplogBuffer->getSentinelCount_forTest());
 
-                                   oplogBuffer->push(txn, oplog[3]);
+                                   oplogBuffer->push(opCtx, oplog[3]);
                                    ASSERT_EQUALS(2U, oplogBuffer->getSentinelCount_forTest());
 
-                                   oplogBuffer->push(txn, oplog[4]);
+                                   oplogBuffer->push(opCtx, oplog[4]);
                                    ASSERT_EQUALS(0U, oplogBuffer->getSentinelCount_forTest());
 
-                                   oplogBuffer->push(txn, oplog[5]);
+                                   oplogBuffer->push(opCtx, oplog[5]);
                                    ASSERT_EQUALS(1U, oplogBuffer->getSentinelCount_forTest());
                                });
 }
 
 TEST_F(OplogBufferCollectionTest, PushEvenIfFullPushesOnSentinelsProperly) {
     auto nss = makeNamespace(_agent);
-    _testPushSentinelsProperly(_txn.get(),
+    _testPushSentinelsProperly(_opCtx.get(),
                                nss,
                                _storageInterface,
-                               [](OperationContext* txn,
+                               [](OperationContext* opCtx,
                                   OplogBufferCollection* oplogBuffer,
                                   const std::vector<BSONObj>& oplog) {
-                                   oplogBuffer->pushEvenIfFull(txn, oplog[0]);
+                                   oplogBuffer->pushEvenIfFull(opCtx, oplog[0]);
                                    ASSERT_EQUALS(1U, oplogBuffer->getSentinelCount_forTest());
 
-                                   oplogBuffer->pushEvenIfFull(txn, oplog[1]);
+                                   oplogBuffer->pushEvenIfFull(opCtx, oplog[1]);
                                    ASSERT_EQUALS(0U, oplogBuffer->getSentinelCount_forTest());
 
-                                   oplogBuffer->pushEvenIfFull(txn, oplog[2]);
+                                   oplogBuffer->pushEvenIfFull(opCtx, oplog[2]);
                                    ASSERT_EQUALS(1U, oplogBuffer->getSentinelCount_forTest());
 
-                                   oplogBuffer->pushEvenIfFull(txn, oplog[3]);
+                                   oplogBuffer->pushEvenIfFull(opCtx, oplog[3]);
                                    ASSERT_EQUALS(2U, oplogBuffer->getSentinelCount_forTest());
 
-                                   oplogBuffer->pushEvenIfFull(txn, oplog[4]);
+                                   oplogBuffer->pushEvenIfFull(opCtx, oplog[4]);
                                    ASSERT_EQUALS(0U, oplogBuffer->getSentinelCount_forTest());
 
-                                   oplogBuffer->pushEvenIfFull(txn, oplog[5]);
+                                   oplogBuffer->pushEvenIfFull(opCtx, oplog[5]);
                                    ASSERT_EQUALS(1U, oplogBuffer->getSentinelCount_forTest());
                                });
 }
 
 TEST_F(OplogBufferCollectionTest, PushAllNonBlockingPushesOnSentinelsProperly) {
     auto nss = makeNamespace(_agent);
-    _testPushSentinelsProperly(_txn.get(),
+    _testPushSentinelsProperly(_opCtx.get(),
                                nss,
                                _storageInterface,
-                               [](OperationContext* txn,
+                               [](OperationContext* opCtx,
                                   OplogBufferCollection* oplogBuffer,
                                   const std::vector<BSONObj>& oplog) {
                                    oplogBuffer->pushAllNonBlocking(
-                                       txn, oplog.cbegin(), oplog.cend());
+                                       opCtx, oplog.cbegin(), oplog.cend());
                                    ASSERT_EQUALS(1U, oplogBuffer->getSentinelCount_forTest());
                                });
 }
@@ -748,207 +748,207 @@ DEATH_TEST_F(
     auto nss = makeNamespace(_agent);
     OplogBufferCollection oplogBuffer(_storageInterface, nss);
 
-    oplogBuffer.startup(_txn.get());
+    oplogBuffer.startup(_opCtx.get());
     const std::vector<BSONObj> oplog = {
         makeOplogEntry(2), makeOplogEntry(1),
     };
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
-    oplogBuffer.pushAllNonBlocking(_txn.get(), oplog.begin(), oplog.end());
+    oplogBuffer.pushAllNonBlocking(_opCtx.get(), oplog.begin(), oplog.end());
 }
 
 TEST_F(OplogBufferCollectionTest, SentinelInMiddleIsReturnedInOrder) {
     auto nss = makeNamespace(_agent);
     OplogBufferCollection oplogBuffer(_storageInterface, nss);
 
-    oplogBuffer.startup(_txn.get());
+    oplogBuffer.startup(_opCtx.get());
     const std::vector<BSONObj> oplog = {
         makeOplogEntry(1), makeOplogEntry(2), BSONObj(), makeOplogEntry(3),
     };
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
-    oplogBuffer.pushEvenIfFull(_txn.get(), oplog[0]);
-    oplogBuffer.pushEvenIfFull(_txn.get(), oplog[1]);
-    oplogBuffer.pushEvenIfFull(_txn.get(), oplog[2]);
-    oplogBuffer.pushEvenIfFull(_txn.get(), oplog[3]);
+    oplogBuffer.pushEvenIfFull(_opCtx.get(), oplog[0]);
+    oplogBuffer.pushEvenIfFull(_opCtx.get(), oplog[1]);
+    oplogBuffer.pushEvenIfFull(_opCtx.get(), oplog[2]);
+    oplogBuffer.pushEvenIfFull(_opCtx.get(), oplog[3]);
     ASSERT_EQUALS(oplogBuffer.getCount(), 4UL);
 
-    _assertDocumentsInCollectionEquals(_txn.get(), nss, oplog);
+    _assertDocumentsInCollectionEquals(_opCtx.get(), nss, oplog);
 
     BSONObj doc;
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(doc, oplog[0]);
     ASSERT_EQUALS(oplogBuffer.getCount(), 4UL);
 
-    ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(doc, oplog[0]);
     ASSERT_EQUALS(oplogBuffer.getCount(), 3UL);
 
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(doc, oplog[1]);
     ASSERT_EQUALS(oplogBuffer.getCount(), 3UL);
 
-    ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(doc, oplog[1]);
     ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
 
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_TRUE(doc.isEmpty());
     ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
 
-    ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     ASSERT_TRUE(doc.isEmpty());
     ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
 
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(doc, oplog[3]);
     ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
 
-    ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(doc, oplog[3]);
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
 
     // tryPop does not remove documents from collection.
-    _assertDocumentsInCollectionEquals(_txn.get(), nss, oplog);
+    _assertDocumentsInCollectionEquals(_opCtx.get(), nss, oplog);
 }
 
 TEST_F(OplogBufferCollectionTest, SentinelAtBeginningIsReturnedAtBeginning) {
     auto nss = makeNamespace(_agent);
     OplogBufferCollection oplogBuffer(_storageInterface, nss);
 
-    oplogBuffer.startup(_txn.get());
+    oplogBuffer.startup(_opCtx.get());
     const std::vector<BSONObj> oplog = {BSONObj(), makeOplogEntry(1)};
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
-    oplogBuffer.pushEvenIfFull(_txn.get(), oplog[0]);
-    oplogBuffer.pushEvenIfFull(_txn.get(), oplog[1]);
+    oplogBuffer.pushEvenIfFull(_opCtx.get(), oplog[0]);
+    oplogBuffer.pushEvenIfFull(_opCtx.get(), oplog[1]);
     ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
 
-    _assertDocumentsInCollectionEquals(_txn.get(), nss, oplog);
+    _assertDocumentsInCollectionEquals(_opCtx.get(), nss, oplog);
 
     BSONObj doc;
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_TRUE(doc.isEmpty());
     ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
 
-    ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     ASSERT_TRUE(doc.isEmpty());
     ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
 
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(doc, oplog[1]);
     ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
 
-    ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(doc, oplog[1]);
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
 
     // tryPop does not remove documents from collection.
-    _assertDocumentsInCollectionEquals(_txn.get(), nss, oplog);
+    _assertDocumentsInCollectionEquals(_opCtx.get(), nss, oplog);
 }
 
 TEST_F(OplogBufferCollectionTest, SentinelAtEndIsReturnedAtEnd) {
     auto nss = makeNamespace(_agent);
     OplogBufferCollection oplogBuffer(_storageInterface, nss);
 
-    oplogBuffer.startup(_txn.get());
+    oplogBuffer.startup(_opCtx.get());
     const std::vector<BSONObj> oplog = {makeOplogEntry(1), BSONObj()};
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
-    oplogBuffer.pushEvenIfFull(_txn.get(), oplog[0]);
-    oplogBuffer.pushEvenIfFull(_txn.get(), oplog[1]);
+    oplogBuffer.pushEvenIfFull(_opCtx.get(), oplog[0]);
+    oplogBuffer.pushEvenIfFull(_opCtx.get(), oplog[1]);
     ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
 
-    _assertDocumentsInCollectionEquals(_txn.get(), nss, oplog);
+    _assertDocumentsInCollectionEquals(_opCtx.get(), nss, oplog);
 
     BSONObj doc;
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(doc, oplog[0]);
     ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
 
-    ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(doc, oplog[0]);
     ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
 
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_TRUE(doc.isEmpty());
     ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
 
-    ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     ASSERT_TRUE(doc.isEmpty());
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
 
     // tryPop does not remove documents from collection.
-    _assertDocumentsInCollectionEquals(_txn.get(), nss, oplog);
+    _assertDocumentsInCollectionEquals(_opCtx.get(), nss, oplog);
 }
 
 TEST_F(OplogBufferCollectionTest, MultipleSentinelsAreReturnedInOrder) {
     auto nss = makeNamespace(_agent);
     OplogBufferCollection oplogBuffer(_storageInterface, nss);
 
-    oplogBuffer.startup(_txn.get());
+    oplogBuffer.startup(_opCtx.get());
     const std::vector<BSONObj> oplog = {
         BSONObj(), makeOplogEntry(1), BSONObj(), BSONObj(), makeOplogEntry(2), BSONObj(),
     };
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
-    oplogBuffer.pushAllNonBlocking(_txn.get(), oplog.cbegin(), oplog.cend());
+    oplogBuffer.pushAllNonBlocking(_opCtx.get(), oplog.cbegin(), oplog.cend());
     ASSERT_EQUALS(oplogBuffer.getCount(), 6UL);
 
-    _assertDocumentsInCollectionEquals(_txn.get(), nss, oplog);
+    _assertDocumentsInCollectionEquals(_opCtx.get(), nss, oplog);
 
     BSONObj doc;
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_TRUE(doc.isEmpty());
     ASSERT_EQUALS(oplogBuffer.getCount(), 6UL);
 
-    ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     ASSERT_TRUE(doc.isEmpty());
     ASSERT_EQUALS(oplogBuffer.getCount(), 5UL);
 
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(doc, oplog[1]);
     ASSERT_EQUALS(oplogBuffer.getCount(), 5UL);
 
-    ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(doc, oplog[1]);
     ASSERT_EQUALS(oplogBuffer.getCount(), 4UL);
 
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_TRUE(doc.isEmpty());
     ASSERT_EQUALS(oplogBuffer.getCount(), 4UL);
 
-    ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     ASSERT_TRUE(doc.isEmpty());
     ASSERT_EQUALS(oplogBuffer.getCount(), 3UL);
 
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_TRUE(doc.isEmpty());
     ASSERT_EQUALS(oplogBuffer.getCount(), 3UL);
 
-    ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     ASSERT_TRUE(doc.isEmpty());
     ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
 
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(doc, oplog[4]);
     ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
 
-    ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(doc, oplog[4]);
     ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
 
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_TRUE(doc.isEmpty());
     ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
 
-    ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     ASSERT_TRUE(doc.isEmpty());
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
 
     // tryPop does not remove documents from collection.
-    _assertDocumentsInCollectionEquals(_txn.get(), nss, oplog);
+    _assertDocumentsInCollectionEquals(_opCtx.get(), nss, oplog);
 }
 
 TEST_F(OplogBufferCollectionTest, WaitForDataBlocksAndFindsSentinel) {
     auto nss = makeNamespace(_agent);
     OplogBufferCollection oplogBuffer(_storageInterface, nss);
-    oplogBuffer.startup(_txn.get());
+    oplogBuffer.startup(_opCtx.get());
 
     unittest::Barrier barrier(2U);
     BSONObj oplog;
@@ -965,11 +965,11 @@ TEST_F(OplogBufferCollectionTest, WaitForDataBlocksAndFindsSentinel) {
 
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
     barrier.countDownAndWait();
-    oplogBuffer.pushEvenIfFull(_txn.get(), oplog);
+    oplogBuffer.pushEvenIfFull(_opCtx.get(), oplog);
     peekingThread.join();
     ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
     ASSERT_TRUE(success);
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_TRUE(doc.isEmpty());
     ASSERT_EQUALS(count, 1UL);
 }
@@ -977,7 +977,7 @@ TEST_F(OplogBufferCollectionTest, WaitForDataBlocksAndFindsSentinel) {
 TEST_F(OplogBufferCollectionTest, TwoWaitForDataInvocationsBlockAndFindSameSentinel) {
     auto nss = makeNamespace(_agent);
     OplogBufferCollection oplogBuffer(_storageInterface, nss);
-    oplogBuffer.startup(_txn.get());
+    oplogBuffer.startup(_opCtx.get());
 
     unittest::Barrier barrier(3U);
     BSONObj oplog;
@@ -1003,13 +1003,13 @@ TEST_F(OplogBufferCollectionTest, TwoWaitForDataInvocationsBlockAndFindSameSenti
 
     ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
     barrier.countDownAndWait();
-    oplogBuffer.pushEvenIfFull(_txn.get(), oplog);
+    oplogBuffer.pushEvenIfFull(_opCtx.get(), oplog);
     peekingThread1.join();
     peekingThread2.join();
     ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
     ASSERT_TRUE(success1);
     BSONObj doc;
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_TRUE(doc.isEmpty());
     ASSERT_EQUALS(count1, 1UL);
     ASSERT_TRUE(success2);
@@ -1041,74 +1041,74 @@ TEST_F(OplogBufferCollectionTest, PeekFillsCacheWithDocumentsFromCollection) {
     std::size_t peekCacheSize = 3U;
     OplogBufferCollection oplogBuffer(_storageInterface, nss, _makeOptions(3));
     ASSERT_EQUALS(peekCacheSize, oplogBuffer.getOptions().peekCacheSize);
-    oplogBuffer.startup(_txn.get());
+    oplogBuffer.startup(_opCtx.get());
 
     std::vector<BSONObj> oplog;
     for (int i = 0; i < 5; ++i) {
         oplog.push_back(makeOplogEntry(i + 1));
     };
-    oplogBuffer.pushAllNonBlocking(_txn.get(), oplog.cbegin(), oplog.cend());
-    _assertDocumentsInCollectionEquals(_txn.get(), nss, oplog);
+    oplogBuffer.pushAllNonBlocking(_opCtx.get(), oplog.cbegin(), oplog.cend());
+    _assertDocumentsInCollectionEquals(_opCtx.get(), nss, oplog);
 
     // Before any peek operations, peek cache should be empty.
     _assertDocumentsEqualCache({}, oplogBuffer.getPeekCache_forTest());
 
     // First peek operation should trigger a read of 'peekCacheSize' documents from the collection.
     BSONObj doc;
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(oplog[0], doc);
     _assertDocumentsEqualCache({oplog[0], oplog[1], oplog[2]}, oplogBuffer.getPeekCache_forTest());
 
     // Repeated peek operation should not modify the cache.
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(oplog[0], doc);
     _assertDocumentsEqualCache({oplog[0], oplog[1], oplog[2]}, oplogBuffer.getPeekCache_forTest());
 
     // Pop operation should remove the first element in the cache
-    ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(oplog[0], doc);
     _assertDocumentsEqualCache({oplog[1], oplog[2]}, oplogBuffer.getPeekCache_forTest());
 
     // Next peek operation should not modify the cache.
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(oplog[1], doc);
     _assertDocumentsEqualCache({oplog[1], oplog[2]}, oplogBuffer.getPeekCache_forTest());
 
     // Pop the rest of the items in the cache.
-    ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(oplog[1], doc);
     _assertDocumentsEqualCache({oplog[2]}, oplogBuffer.getPeekCache_forTest());
 
-    ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(oplog[2], doc);
     _assertDocumentsEqualCache({}, oplogBuffer.getPeekCache_forTest());
 
     // Next peek operation should replenish the cache.
     // Cache size will be less than the configured 'peekCacheSize' because
     // there will not be enough documents left unread in the collection.
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(oplog[3], doc);
     _assertDocumentsEqualCache({oplog[3], oplog[4]}, oplogBuffer.getPeekCache_forTest());
 
     // Pop the remaining documents from the buffer.
-    ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(oplog[3], doc);
     _assertDocumentsEqualCache({oplog[4]}, oplogBuffer.getPeekCache_forTest());
 
     // Verify state of cache between pops using peek.
-    ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(oplog[4], doc);
     _assertDocumentsEqualCache({oplog[4]}, oplogBuffer.getPeekCache_forTest());
 
-    ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     ASSERT_BSONOBJ_EQ(oplog[4], doc);
     _assertDocumentsEqualCache({}, oplogBuffer.getPeekCache_forTest());
 
     // Nothing left in the collection.
-    ASSERT_FALSE(oplogBuffer.peek(_txn.get(), &doc));
+    ASSERT_FALSE(oplogBuffer.peek(_opCtx.get(), &doc));
     _assertDocumentsEqualCache({}, oplogBuffer.getPeekCache_forTest());
 
-    ASSERT_FALSE(oplogBuffer.tryPop(_txn.get(), &doc));
+    ASSERT_FALSE(oplogBuffer.tryPop(_opCtx.get(), &doc));
     _assertDocumentsEqualCache({}, oplogBuffer.getPeekCache_forTest());
 }
 
diff --git a/src/mongo/db/repl/oplog_buffer_proxy.cpp b/src/mongo/db/repl/oplog_buffer_proxy.cpp
index e2080a94f19..675bb4d6186 100644
--- a/src/mongo/db/repl/oplog_buffer_proxy.cpp
+++ b/src/mongo/db/repl/oplog_buffer_proxy.cpp
@@ -44,33 +44,33 @@ OplogBuffer* OplogBufferProxy::getTarget() const {
     return _target.get();
 }
 
-void OplogBufferProxy::startup(OperationContext* txn) {
-    _target->startup(txn);
+void OplogBufferProxy::startup(OperationContext* opCtx) {
+    _target->startup(opCtx);
 }
 
-void OplogBufferProxy::shutdown(OperationContext* txn) {
+void OplogBufferProxy::shutdown(OperationContext* opCtx) {
     {
         stdx::lock_guard<stdx::mutex> backLock(_lastPushedMutex);
         stdx::lock_guard<stdx::mutex> frontLock(_lastPeekedMutex);
         _lastPushed.reset();
         _lastPeeked.reset();
     }
-    _target->shutdown(txn);
+    _target->shutdown(opCtx);
 }
 
-void OplogBufferProxy::pushEvenIfFull(OperationContext* txn, const Value& value) {
+void OplogBufferProxy::pushEvenIfFull(OperationContext* opCtx, const Value& value) {
     stdx::lock_guard<stdx::mutex> lk(_lastPushedMutex);
     _lastPushed = value;
-    _target->pushEvenIfFull(txn, value);
+    _target->pushEvenIfFull(opCtx, value);
 }
 
-void OplogBufferProxy::push(OperationContext* txn, const Value& value) {
+void OplogBufferProxy::push(OperationContext* opCtx, const Value& value) {
     stdx::lock_guard<stdx::mutex> lk(_lastPushedMutex);
     _lastPushed = value;
-    _target->push(txn, value);
+    _target->push(opCtx, value);
 }
 
-void OplogBufferProxy::pushAllNonBlocking(OperationContext* txn,
+void OplogBufferProxy::pushAllNonBlocking(OperationContext* opCtx,
                                           Batch::const_iterator begin,
                                           Batch::const_iterator end) {
     if (begin == end) {
@@ -78,11 +78,11 @@ void OplogBufferProxy::pushAllNonBlocking(OperationContext* txn,
     }
     stdx::lock_guard<stdx::mutex> lk(_lastPushedMutex);
     _lastPushed = *(end - 1);
-    _target->pushAllNonBlocking(txn, begin, end);
+    _target->pushAllNonBlocking(opCtx, begin, end);
 }
 
-void OplogBufferProxy::waitForSpace(OperationContext* txn, std::size_t size) {
-    _target->waitForSpace(txn, size);
+void OplogBufferProxy::waitForSpace(OperationContext* opCtx, std::size_t size) {
+    _target->waitForSpace(opCtx, size);
 }
 
 bool OplogBufferProxy::isEmpty() const {
@@ -101,18 +101,18 @@ std::size_t OplogBufferProxy::getCount() const {
     return _target->getCount();
 }
 
-void OplogBufferProxy::clear(OperationContext* txn) {
+void OplogBufferProxy::clear(OperationContext* opCtx) {
     stdx::lock_guard<stdx::mutex> backLock(_lastPushedMutex);
     stdx::lock_guard<stdx::mutex> frontLock(_lastPeekedMutex);
     _lastPushed.reset();
     _lastPeeked.reset();
-    _target->clear(txn);
+    _target->clear(opCtx);
 }
 
-bool OplogBufferProxy::tryPop(OperationContext* txn, Value* value) {
+bool OplogBufferProxy::tryPop(OperationContext* opCtx, Value* value) {
     stdx::lock_guard<stdx::mutex> backLock(_lastPushedMutex);
     stdx::lock_guard<stdx::mutex> frontLock(_lastPeekedMutex);
-    if (!_target->tryPop(txn, value)) {
+    if (!_target->tryPop(opCtx, value)) {
         return false;
     }
     _lastPeeked.reset();
@@ -133,13 +133,13 @@ bool OplogBufferProxy::waitForData(Seconds waitDuration) {
     return _target->waitForData(waitDuration);
 }
 
-bool OplogBufferProxy::peek(OperationContext* txn, Value* value) {
+bool OplogBufferProxy::peek(OperationContext* opCtx, Value* value) {
     stdx::lock_guard<stdx::mutex> lk(_lastPeekedMutex);
     if (_lastPeeked) {
         *value = *_lastPeeked;
         return true;
     }
-    if (_target->peek(txn, value)) {
+    if (_target->peek(opCtx, value)) {
         _lastPeeked = *value;
         return true;
     }
@@ -147,7 +147,7 @@ bool OplogBufferProxy::peek(OperationContext* txn, Value* value) {
 }
 
 boost::optional<OplogBuffer::Value> OplogBufferProxy::lastObjectPushed(
-    OperationContext* txn) const {
+    OperationContext* opCtx) const {
     stdx::lock_guard<stdx::mutex> lk(_lastPushedMutex);
     if (!_lastPushed) {
         return boost::none;
diff --git a/src/mongo/db/repl/oplog_buffer_proxy.h b/src/mongo/db/repl/oplog_buffer_proxy.h
index 2624a9bb68f..ae9be1340ff 100644
--- a/src/mongo/db/repl/oplog_buffer_proxy.h
+++ b/src/mongo/db/repl/oplog_buffer_proxy.h
@@ -55,23 +55,23 @@ public:
      */
     OplogBuffer* getTarget() const;
 
-    void startup(OperationContext* txn) override;
-    void shutdown(OperationContext* txn) override;
-    void pushEvenIfFull(OperationContext* txn, const Value& value) override;
-    void push(OperationContext* txn, const Value& value) override;
-    void pushAllNonBlocking(OperationContext* txn,
+    void startup(OperationContext* opCtx) override;
+    void shutdown(OperationContext* opCtx) override;
+    void pushEvenIfFull(OperationContext* opCtx, const Value& value) override;
+    void push(OperationContext* opCtx, const Value& value) override;
+    void pushAllNonBlocking(OperationContext* opCtx,
                             Batch::const_iterator begin,
                             Batch::const_iterator end) override;
-    void waitForSpace(OperationContext* txn, std::size_t size) override;
+    void waitForSpace(OperationContext* opCtx, std::size_t size) override;
     bool isEmpty() const override;
     std::size_t getMaxSize() const override;
     std::size_t getSize() const override;
     std::size_t getCount() const override;
-    void clear(OperationContext* txn) override;
-    bool tryPop(OperationContext* txn, Value* value) override;
+    void clear(OperationContext* opCtx) override;
+    bool tryPop(OperationContext* opCtx, Value* value) override;
     bool waitForData(Seconds waitDuration) override;
-    bool peek(OperationContext* txn, Value* value) override;
-    boost::optional<Value> lastObjectPushed(OperationContext* txn) const override;
+    bool peek(OperationContext* opCtx, Value* value) override;
+    boost::optional<Value> lastObjectPushed(OperationContext* opCtx) const override;
 
     // ---- Testing API ----
     boost::optional<Value> getLastPeeked_forTest() const;
diff --git a/src/mongo/db/repl/oplog_buffer_proxy_test.cpp b/src/mongo/db/repl/oplog_buffer_proxy_test.cpp
index a59a66f0979..a372eea8c85 100644
--- a/src/mongo/db/repl/oplog_buffer_proxy_test.cpp
+++ b/src/mongo/db/repl/oplog_buffer_proxy_test.cpp
@@ -57,17 +57,17 @@ public:
     void shutdown(OperationContext*) override {
         shutdownCalled = true;
     }
-    void pushEvenIfFull(OperationContext* txn, const Value& value) override {
-        push(txn, value);
+    void pushEvenIfFull(OperationContext* opCtx, const Value& value) override {
+        push(opCtx, value);
     }
     void push(OperationContext*, const Value& value) override {
         values.push_back(value);
     }
-    void pushAllNonBlocking(OperationContext* txn,
+    void pushAllNonBlocking(OperationContext* opCtx,
                             Batch::const_iterator begin,
                             Batch::const_iterator end) override {
         for (auto i = begin; i != end; ++i) {
-            push(txn, *i);
+            push(opCtx, *i);
         }
     }
     void waitForSpace(OperationContext*, std::size_t) override {
@@ -92,9 +92,9 @@ public:
     void clear(OperationContext*) override {
         values.clear();
     }
-    bool tryPop(OperationContext* txn, Value* value) override {
+    bool tryPop(OperationContext* opCtx, Value* value) override {
         tryPopCalled = true;
-        if (!peek(txn, value)) {
+        if (!peek(opCtx, value)) {
             return false;
         }
         values.pop_front();
@@ -140,7 +140,7 @@ private:
 protected:
     OplogBufferMock* _mock = nullptr;
     std::unique_ptr<OplogBufferProxy> _proxy;
-    OperationContext* _txn = nullptr;  // Not dereferenced.
+    OperationContext* _opCtx = nullptr;  // Not dereferenced.
 };
 
 void OplogBufferProxyTest::setUp() {
@@ -165,29 +165,29 @@ TEST_F(OplogBufferProxyTest, GetTarget) {
 }
 
 TEST_F(OplogBufferProxyTest, Startup) {
-    _proxy->startup(_txn);
+    _proxy->startup(_opCtx);
     ASSERT_TRUE(_mock->startupCalled);
 }
 
 TEST_F(OplogBufferProxyTest, ShutdownResetsCachedValues) {
     auto pushValue = BSON("x" << 1);
-    _proxy->push(_txn, pushValue);
+    _proxy->push(_opCtx, pushValue);
     OplogBuffer::Value peekValue;
-    ASSERT_TRUE(_proxy->peek(_txn, &peekValue));
+    ASSERT_TRUE(_proxy->peek(_opCtx, &peekValue));
     ASSERT_BSONOBJ_EQ(pushValue, peekValue);
 
-    ASSERT_NOT_EQUALS(boost::none, _proxy->lastObjectPushed(_txn));
+    ASSERT_NOT_EQUALS(boost::none, _proxy->lastObjectPushed(_opCtx));
     ASSERT_NOT_EQUALS(boost::none, _proxy->getLastPeeked_forTest());
 
-    _proxy->shutdown(_txn);
+    _proxy->shutdown(_opCtx);
     ASSERT_TRUE(_mock->shutdownCalled);
 
-    ASSERT_EQUALS(boost::none, _proxy->lastObjectPushed(_txn));
+    ASSERT_EQUALS(boost::none, _proxy->lastObjectPushed(_opCtx));
     ASSERT_EQUALS(boost::none, _proxy->getLastPeeked_forTest());
 }
 
 TEST_F(OplogBufferProxyTest, WaitForSpace) {
-    _proxy->waitForSpace(_txn, 100U);
+    _proxy->waitForSpace(_opCtx, 100U);
     ASSERT_TRUE(_mock->waitForSpaceCalled);
 }
 
@@ -199,7 +199,7 @@ TEST_F(OplogBufferProxyTest, MaxSize) {
 TEST_F(OplogBufferProxyTest, EmptySizeAndCount) {
     ASSERT_TRUE(_proxy->isEmpty());
     OplogBuffer::Batch values = {BSON("x" << 1), BSON("x" << 2)};
-    _proxy->pushAllNonBlocking(_txn, values.cbegin(), values.cend());
+    _proxy->pushAllNonBlocking(_opCtx, values.cbegin(), values.cend());
     ASSERT_FALSE(_proxy->isEmpty());
     ASSERT_EQUALS(values.size(), _mock->getCount());
     ASSERT_EQUALS(_mock->getCount(), _proxy->getCount());
@@ -209,79 +209,79 @@ TEST_F(OplogBufferProxyTest, EmptySizeAndCount) {
 
 TEST_F(OplogBufferProxyTest, ClearResetsCachedValues) {
     OplogBuffer::Batch values = {BSON("x" << 1), BSON("x" << 2)};
-    _proxy->pushAllNonBlocking(_txn, values.cbegin(), values.cend());
+    _proxy->pushAllNonBlocking(_opCtx, values.cbegin(), values.cend());
     ASSERT_FALSE(_mock->isEmpty());
-    auto lastObjPushed = _proxy->lastObjectPushed(_txn);
+    auto lastObjPushed = _proxy->lastObjectPushed(_opCtx);
     ASSERT_NOT_EQUALS(boost::none, lastObjPushed);
     ASSERT_BSONOBJ_EQ(values.back(), *lastObjPushed);
     ASSERT_FALSE(_mock->lastObjectPushedCalled);
 
     OplogBuffer::Value peekValue;
-    ASSERT_TRUE(_proxy->peek(_txn, &peekValue));
+    ASSERT_TRUE(_proxy->peek(_opCtx, &peekValue));
     ASSERT_NOT_EQUALS(boost::none, _proxy->getLastPeeked_forTest());
 
-    _proxy->clear(_txn);
+    _proxy->clear(_opCtx);
     ASSERT_TRUE(_mock->isEmpty());
-    ASSERT_EQUALS(boost::none, _proxy->lastObjectPushed(_txn));
+    ASSERT_EQUALS(boost::none, _proxy->lastObjectPushed(_opCtx));
     ASSERT_EQUALS(boost::none, _proxy->getLastPeeked_forTest());
 }
 
 void _testPushFunctionUpdatesCachedLastObjectPushed(
-    OperationContext* txn,
+    OperationContext* opCtx,
     OplogBuffer* proxy,
     OplogBufferMock* mock,
     stdx::function<std::size_t(
-        OperationContext* txn, OplogBuffer* proxy, const OplogBuffer::Value& value)> pushFn) {
-    ASSERT_EQUALS(proxy->lastObjectPushed(txn), boost::none);
+        OperationContext* opCtx, OplogBuffer* proxy, const OplogBuffer::Value& value)> pushFn) {
+    ASSERT_EQUALS(proxy->lastObjectPushed(opCtx), boost::none);
     ASSERT_FALSE(mock->lastObjectPushedCalled);
 
     auto val = BSON("x" << 1);
-    auto numPushed = pushFn(txn, proxy, val);
+    auto numPushed = pushFn(opCtx, proxy, val);
     ASSERT_EQUALS(numPushed, mock->values.size());
     ASSERT_BSONOBJ_EQ(val, mock->values.back());
 
-    auto lastObjPushed = proxy->lastObjectPushed(txn);
+    auto lastObjPushed = proxy->lastObjectPushed(opCtx);
     ASSERT_NOT_EQUALS(boost::none, lastObjPushed);
     ASSERT_BSONOBJ_EQ(val, *lastObjPushed);
     ASSERT_FALSE(mock->lastObjectPushedCalled);
 }
 
 TEST_F(OplogBufferProxyTest, PushEvenIfFullUpdatesCachedLastObjectPushed) {
-    auto pushFn = [](OperationContext* txn, OplogBuffer* proxy, const OplogBuffer::Value& value) {
-        proxy->pushEvenIfFull(txn, value);
+    auto pushFn = [](OperationContext* opCtx, OplogBuffer* proxy, const OplogBuffer::Value& value) {
+        proxy->pushEvenIfFull(opCtx, value);
         return 1U;
     };
-    _testPushFunctionUpdatesCachedLastObjectPushed(_txn, _proxy.get(), _mock, pushFn);
+    _testPushFunctionUpdatesCachedLastObjectPushed(_opCtx, _proxy.get(), _mock, pushFn);
 }
 
 TEST_F(OplogBufferProxyTest, PushUpdatesCachedLastObjectPushed) {
-    auto pushFn = [](OperationContext* txn, OplogBuffer* proxy, const OplogBuffer::Value& value) {
-        proxy->push(txn, value);
+    auto pushFn = [](OperationContext* opCtx, OplogBuffer* proxy, const OplogBuffer::Value& value) {
+        proxy->push(opCtx, value);
         return 1U;
     };
-    _testPushFunctionUpdatesCachedLastObjectPushed(_txn, _proxy.get(), _mock, pushFn);
+    _testPushFunctionUpdatesCachedLastObjectPushed(_opCtx, _proxy.get(), _mock, pushFn);
 }
 
 TEST_F(OplogBufferProxyTest, PushAllNonBlockingUpdatesCachedLastObjectPushed) {
-    auto pushFn = [](OperationContext* txn, OplogBuffer* proxy, const OplogBuffer::Value& value) {
+    auto pushFn = [](OperationContext* opCtx, OplogBuffer* proxy, const OplogBuffer::Value& value) {
         OplogBuffer::Batch values = {BSON("x" << 2), value};
-        proxy->pushAllNonBlocking(txn, values.cbegin(), values.cend());
+        proxy->pushAllNonBlocking(opCtx, values.cbegin(), values.cend());
         return values.size();
     };
-    _testPushFunctionUpdatesCachedLastObjectPushed(_txn, _proxy.get(), _mock, pushFn);
+    _testPushFunctionUpdatesCachedLastObjectPushed(_opCtx, _proxy.get(), _mock, pushFn);
 }
 
 TEST_F(OplogBufferProxyTest, PushAllNonBlockingDoesNotUpdateCachedLastObjectPushedOnEmptyBatch) {
     OplogBuffer::Batch values;
-    _proxy->pushAllNonBlocking(_txn, values.cbegin(), values.cend());
+    _proxy->pushAllNonBlocking(_opCtx, values.cbegin(), values.cend());
     ASSERT_EQUALS(values.size(), _mock->values.size());
 
-    ASSERT_EQUALS(boost::none, _proxy->lastObjectPushed(_txn));
+    ASSERT_EQUALS(boost::none, _proxy->lastObjectPushed(_opCtx));
     ASSERT_FALSE(_mock->lastObjectPushedCalled);
 }
 
 TEST_F(OplogBufferProxyTest, WaitForDataReturnsTrueImmediatelyIfLastObjectPushedIsCached) {
-    _proxy->pushEvenIfFull(_txn, BSON("x" << 1));
+    _proxy->pushEvenIfFull(_opCtx, BSON("x" << 1));
     ASSERT_TRUE(_proxy->waitForData(Seconds(10)));
     ASSERT_FALSE(_mock->waitForDataCalled);
 }
@@ -293,15 +293,15 @@ TEST_F(OplogBufferProxyTest, WaitForDataForwardsCallToTargetIfLastObjectPushedIs
 
 TEST_F(OplogBufferProxyTest, TryPopResetsLastPushedObjectIfBufferIsEmpty) {
     auto pushValue = BSON("x" << 1);
-    _proxy->push(_txn, BSON("x" << 1));
-    auto lastPushed = _proxy->lastObjectPushed(_txn);
-    ASSERT_NOT_EQUALS(boost::none, _proxy->lastObjectPushed(_txn));
+    _proxy->push(_opCtx, BSON("x" << 1));
+    auto lastPushed = _proxy->lastObjectPushed(_opCtx);
+    ASSERT_NOT_EQUALS(boost::none, _proxy->lastObjectPushed(_opCtx));
     ASSERT_BSONOBJ_EQ(pushValue, *lastPushed);
 
     OplogBuffer::Value poppedValue;
-    ASSERT_TRUE(_proxy->tryPop(_txn, &poppedValue));
+    ASSERT_TRUE(_proxy->tryPop(_opCtx, &poppedValue));
     ASSERT_BSONOBJ_EQ(pushValue, poppedValue);
-    ASSERT_EQUALS(boost::none, _proxy->lastObjectPushed(_txn));
+    ASSERT_EQUALS(boost::none, _proxy->lastObjectPushed(_opCtx));
 
     // waitForData should forward call to underlying buffer.
     ASSERT_FALSE(_proxy->waitForData(Seconds(10)));
@@ -311,41 +311,41 @@ TEST_F(OplogBufferProxyTest, TryPopResetsLastPushedObjectIfBufferIsEmpty) {
 TEST_F(OplogBufferProxyTest, PeekCachesFrontOfBuffer) {
     OplogBuffer::Value peekValue;
     ASSERT_FALSE(_mock->peekCalled);
-    ASSERT_FALSE(_proxy->peek(_txn, &peekValue));
+    ASSERT_FALSE(_proxy->peek(_opCtx, &peekValue));
     ASSERT_TRUE(_mock->peekCalled);
     ASSERT_TRUE(peekValue.isEmpty());
     _mock->peekCalled = false;
 
     OplogBuffer::Batch values = {BSON("x" << 1), BSON("x" << 2)};
-    _proxy->pushAllNonBlocking(_txn, values.cbegin(), values.cend());
+    _proxy->pushAllNonBlocking(_opCtx, values.cbegin(), values.cend());
     ASSERT_EQUALS(values.size(), _mock->values.size());
 
-    ASSERT_TRUE(_proxy->peek(_txn, &peekValue));
+    ASSERT_TRUE(_proxy->peek(_opCtx, &peekValue));
     ASSERT_TRUE(_mock->peekCalled);
     ASSERT_BSONOBJ_EQ(values.front(), peekValue);
     _mock->peekCalled = false;
     peekValue = OplogBuffer::Value();
 
-    ASSERT_TRUE(_proxy->peek(_txn, &peekValue));
+    ASSERT_TRUE(_proxy->peek(_opCtx, &peekValue));
     ASSERT_FALSE(_mock->peekCalled);
     ASSERT_BSONOBJ_EQ(values.front(), peekValue);
 }
 
 TEST_F(OplogBufferProxyTest, TryPopClearsCachedFrontValue) {
     OplogBuffer::Batch values = {BSON("x" << 1), BSON("x" << 2)};
-    _proxy->pushAllNonBlocking(_txn, values.cbegin(), values.cend());
+    _proxy->pushAllNonBlocking(_opCtx, values.cbegin(), values.cend());
     ASSERT_EQUALS(values.size(), _mock->values.size());
 
     // Peek and pop first value {x: 1}.
     OplogBuffer::Value peekValue;
-    ASSERT_TRUE(_proxy->peek(_txn, &peekValue));
+    ASSERT_TRUE(_proxy->peek(_opCtx, &peekValue));
     ASSERT_TRUE(_mock->peekCalled);
     ASSERT_BSONOBJ_EQ(values.front(), peekValue);
     _mock->peekCalled = false;
     peekValue = OplogBuffer::Value();
 
     OplogBuffer::Value poppedValue;
-    ASSERT_TRUE(_proxy->tryPop(_txn, &poppedValue));
+    ASSERT_TRUE(_proxy->tryPop(_opCtx, &poppedValue));
     ASSERT_TRUE(_mock->tryPopCalled);
     ASSERT_BSONOBJ_EQ(values.front(), poppedValue);
     ASSERT_EQUALS(boost::none, _proxy->getLastPeeked_forTest());
@@ -353,14 +353,14 @@ TEST_F(OplogBufferProxyTest, TryPopClearsCachedFrontValue) {
     poppedValue = OplogBuffer::Value();
 
     // Peek and pop second value {x: 2}.
-    ASSERT_TRUE(_proxy->peek(_txn, &peekValue));
+    ASSERT_TRUE(_proxy->peek(_opCtx, &peekValue));
     ASSERT_TRUE(_mock->peekCalled);
     ASSERT_BSONOBJ_EQ(values.back(), peekValue);
     ASSERT_NOT_EQUALS(boost::none, _proxy->getLastPeeked_forTest());
     _mock->peekCalled = false;
     peekValue = OplogBuffer::Value();
 
-    ASSERT_TRUE(_proxy->tryPop(_txn, &poppedValue));
+    ASSERT_TRUE(_proxy->tryPop(_opCtx, &poppedValue));
     ASSERT_TRUE(_mock->tryPopCalled);
     ASSERT_BSONOBJ_EQ(values.back(), poppedValue);
     ASSERT_EQUALS(boost::none, _proxy->getLastPeeked_forTest());
@@ -368,12 +368,12 @@ TEST_F(OplogBufferProxyTest, TryPopClearsCachedFrontValue) {
     poppedValue = OplogBuffer::Value();
 
     // Peek and pop empty buffer.
-    ASSERT_FALSE(_proxy->peek(_txn, &peekValue));
+    ASSERT_FALSE(_proxy->peek(_opCtx, &peekValue));
     ASSERT_TRUE(_mock->peekCalled);
     ASSERT_TRUE(peekValue.isEmpty());
     ASSERT_EQUALS(boost::none, _proxy->getLastPeeked_forTest());
 
-    ASSERT_FALSE(_proxy->tryPop(_txn, &poppedValue));
+    ASSERT_FALSE(_proxy->tryPop(_opCtx, &poppedValue));
     ASSERT_TRUE(_mock->tryPopCalled);
     ASSERT_TRUE(poppedValue.isEmpty());
     ASSERT_EQUALS(boost::none, _proxy->getLastPeeked_forTest());
diff --git a/src/mongo/db/repl/oplog_interface_local.cpp b/src/mongo/db/repl/oplog_interface_local.cpp
index 03b93892885..a68fd8db0d6 100644
--- a/src/mongo/db/repl/oplog_interface_local.cpp
+++ b/src/mongo/db/repl/oplog_interface_local.cpp
@@ -43,7 +43,7 @@ namespace {
 
 class OplogIteratorLocal : public OplogInterface::Iterator {
 public:
-    OplogIteratorLocal(OperationContext* txn, const std::string& collectionName);
+    OplogIteratorLocal(OperationContext* opCtx, const std::string& collectionName);
 
     StatusWith<Value> next() override;
 
@@ -55,12 +55,12 @@ private:
     std::unique_ptr<PlanExecutor> _exec;
 };
 
-OplogIteratorLocal::OplogIteratorLocal(OperationContext* txn, const std::string& collectionName)
-    : _transaction(txn, MODE_IS),
-      _dbLock(txn->lockState(), nsToDatabase(collectionName), MODE_IS),
-      _collectionLock(txn->lockState(), collectionName, MODE_S),
-      _ctx(txn, collectionName),
-      _exec(InternalPlanner::collectionScan(txn,
+OplogIteratorLocal::OplogIteratorLocal(OperationContext* opCtx, const std::string& collectionName)
+    : _transaction(opCtx, MODE_IS),
+      _dbLock(opCtx->lockState(), nsToDatabase(collectionName), MODE_IS),
+      _collectionLock(opCtx->lockState(), collectionName, MODE_S),
+      _ctx(opCtx, collectionName),
+      _exec(InternalPlanner::collectionScan(opCtx,
                                             collectionName,
                                             _ctx.db()->getCollection(collectionName),
                                             PlanExecutor::YIELD_MANUAL,
@@ -84,20 +84,21 @@ StatusWith<OplogInterface::Iterator::Value> OplogIteratorLocal::next() {
 
 }  // namespace
 
-OplogInterfaceLocal::OplogInterfaceLocal(OperationContext* txn, const std::string& collectionName)
-    : _txn(txn), _collectionName(collectionName) {
-    invariant(txn);
+OplogInterfaceLocal::OplogInterfaceLocal(OperationContext* opCtx, const std::string& collectionName)
+    : _opCtx(opCtx), _collectionName(collectionName) {
+    invariant(opCtx);
     invariant(!collectionName.empty());
 }
 
 std::string OplogInterfaceLocal::toString() const {
     return str::stream() << "LocalOplogInterface: "
                             "operation context: "
-                         << _txn->getOpID() << "; collection: " << _collectionName;
+                         << _opCtx->getOpID() << "; collection: " << _collectionName;
 }
 
 std::unique_ptr<OplogInterface::Iterator> OplogInterfaceLocal::makeIterator() const {
-    return std::unique_ptr<OplogInterface::Iterator>(new OplogIteratorLocal(_txn, _collectionName));
+    return std::unique_ptr<OplogInterface::Iterator>(
+        new OplogIteratorLocal(_opCtx, _collectionName));
 }
 
 }  // namespace repl
diff --git a/src/mongo/db/repl/oplog_interface_local.h b/src/mongo/db/repl/oplog_interface_local.h
index 32c9adc4377..577dbe8d7fa 100644
--- a/src/mongo/db/repl/oplog_interface_local.h
+++ b/src/mongo/db/repl/oplog_interface_local.h
@@ -42,12 +42,12 @@ namespace repl {
 
 class OplogInterfaceLocal : public OplogInterface {
 public:
-    OplogInterfaceLocal(OperationContext* txn, const std::string& collectionName);
+    OplogInterfaceLocal(OperationContext* opCtx, const std::string& collectionName);
     std::string toString() const override;
     std::unique_ptr<OplogInterface::Iterator> makeIterator() const override;
 
 private:
-    OperationContext* _txn;
+    OperationContext* _opCtx;
     std::string _collectionName;
 };
 
diff --git a/src/mongo/db/repl/oplogreader.cpp b/src/mongo/db/repl/oplogreader.cpp
index 92bc6648b8b..665554c25b2 100644
--- a/src/mongo/db/repl/oplogreader.cpp
+++ b/src/mongo/db/repl/oplogreader.cpp
@@ -152,7 +152,7 @@ Status OplogReader::_compareRequiredOpTimeWithQueryResponse(const OpTime& requir
     return Status::OK();
 }
 
-void OplogReader::connectToSyncSource(OperationContext* txn,
+void OplogReader::connectToSyncSource(OperationContext* opCtx,
                                       const OpTime& lastOpTimeFetched,
                                       const OpTime& requiredOpTime,
                                       ReplicationCoordinator* replCoord) {
diff --git a/src/mongo/db/repl/oplogreader.h b/src/mongo/db/repl/oplogreader.h
index 1434125697a..641315b748f 100644
--- a/src/mongo/db/repl/oplogreader.h
+++ b/src/mongo/db/repl/oplogreader.h
@@ -155,7 +155,7 @@ public:
      * sync source blacklist.
      * This function may throw DB exceptions.
      */
-    void connectToSyncSource(OperationContext* txn,
+    void connectToSyncSource(OperationContext* opCtx,
                              const OpTime& lastOpTimeFetched,
                              const OpTime& requiredOpTime,
                              ReplicationCoordinator* replCoord);
diff --git a/src/mongo/db/repl/repl_client_info.cpp b/src/mongo/db/repl/repl_client_info.cpp
index 3e98a0cb9d3..8064f8c5fc0 100644
--- a/src/mongo/db/repl/repl_client_info.cpp
+++ b/src/mongo/db/repl/repl_client_info.cpp
@@ -48,9 +48,10 @@ void ReplClientInfo::setLastOp(const OpTime& ot) {
     _lastOp = ot;
 }
 
-void ReplClientInfo::setLastOpToSystemLastOpTime(OperationContext* txn) {
-    ReplicationCoordinator* replCoord = repl::ReplicationCoordinator::get(txn->getServiceContext());
-    if (replCoord->isReplEnabled() && txn->writesAreReplicated()) {
+void ReplClientInfo::setLastOpToSystemLastOpTime(OperationContext* opCtx) {
+    ReplicationCoordinator* replCoord =
+        repl::ReplicationCoordinator::get(opCtx->getServiceContext());
+    if (replCoord->isReplEnabled() && opCtx->writesAreReplicated()) {
         setLastOp(replCoord->getMyLastAppliedOpTime());
     }
 }
diff --git a/src/mongo/db/repl/repl_client_info.h b/src/mongo/db/repl/repl_client_info.h
index 3c81953d65f..3c3910cf78d 100644
--- a/src/mongo/db/repl/repl_client_info.h
+++ b/src/mongo/db/repl/repl_client_info.h
@@ -76,7 +76,7 @@ public:
      * This is necessary when doing no-op writes, as we need to set the client's lastOp to a proper
      * value for write concern wait to work.
      */
-    void setLastOpToSystemLastOpTime(OperationContext* txn);
+    void setLastOpToSystemLastOpTime(OperationContext* opCtx);
 
 private:
     static const long long kUninitializedTerm = -1;
diff --git a/src/mongo/db/repl/repl_set_commands.cpp b/src/mongo/db/repl/repl_set_commands.cpp
index c2793e42764..f3a0cd748e2 100644
--- a/src/mongo/db/repl/repl_set_commands.cpp
+++ b/src/mongo/db/repl/repl_set_commands.cpp
@@ -93,7 +93,7 @@ public:
         return Status::OK();
     }
     CmdReplSetTest() : ReplSetCommand("replSetTest") {}
-    virtual bool run(OperationContext* txn,
+    virtual bool run(OperationContext* opCtx,
                      const string&,
                      BSONObj& cmdObj,
                      int,
@@ -165,7 +165,7 @@ MONGO_INITIALIZER(RegisterReplSetTestCmd)(InitializerContext* context) {
 class CmdReplSetGetRBID : public ReplSetCommand {
 public:
     CmdReplSetGetRBID() : ReplSetCommand("replSetGetRBID") {}
-    virtual bool run(OperationContext* txn,
+    virtual bool run(OperationContext* opCtx,
                      const string&,
                      BSONObj& cmdObj,
                      int,
@@ -188,14 +188,14 @@ public:
         help << "\nhttp://dochub.mongodb.org/core/replicasetcommands";
     }
     CmdReplSetGetStatus() : ReplSetCommand("replSetGetStatus", true) {}
-    virtual bool run(OperationContext* txn,
+    virtual bool run(OperationContext* opCtx,
                      const string&,
                      BSONObj& cmdObj,
                      int,
                      string& errmsg,
                      BSONObjBuilder& result) {
         if (cmdObj["forShell"].trueValue())
-            LastError::get(txn->getClient()).disable();
+            LastError::get(opCtx->getClient()).disable();
 
         Status status = getGlobalReplicationCoordinator()->checkReplEnabledForCommand(&result);
         if (!status.isOK())
@@ -230,7 +230,7 @@ public:
         help << "\nhttp://dochub.mongodb.org/core/replicasetcommands";
     }
     CmdReplSetGetConfig() : ReplSetCommand("replSetGetConfig", true) {}
-    virtual bool run(OperationContext* txn,
+    virtual bool run(OperationContext* opCtx,
                      const string&,
                      BSONObj& cmdObj,
                      int,
@@ -330,7 +330,7 @@ public:
         h << "Initiate/christen a replica set.";
         h << "\nhttp://dochub.mongodb.org/core/replicasetcommands";
     }
-    virtual bool run(OperationContext* txn,
+    virtual bool run(OperationContext* opCtx,
                      const string&,
                      BSONObj& cmdObj,
                      int,
@@ -342,7 +342,7 @@ public:
         }
 
         std::string replSetString =
-            ReplicationCoordinator::get(txn)->getSettings().getReplSetString();
+            ReplicationCoordinator::get(opCtx)->getSettings().getReplSetString();
         if (replSetString.empty()) {
             return appendCommandStatus(result,
                                        Status(ErrorCodes::NoReplicationEnabled,
@@ -356,7 +356,7 @@ public:
             result.append("info2", noConfigMessage);
             log() << "initiate : " << noConfigMessage;
 
-            ReplicationCoordinatorExternalStateImpl externalState(StorageInterface::get(txn));
+            ReplicationCoordinatorExternalStateImpl externalState(StorageInterface::get(opCtx));
             std::string name;
             std::vector<HostAndPort> seeds;
             parseReplSetSeedList(&externalState, replSetString, &name, &seeds);  // may throw...
@@ -386,7 +386,7 @@ public:
         }
 
         Status status =
-            getGlobalReplicationCoordinator()->processReplSetInitiate(txn, configObj, &result);
+            getGlobalReplicationCoordinator()->processReplSetInitiate(opCtx, configObj, &result);
         return appendCommandStatus(result, status);
     }
 
@@ -404,7 +404,7 @@ public:
         help << "\nhttp://dochub.mongodb.org/core/replicasetcommands";
     }
     CmdReplSetReconfig() : ReplSetCommand("replSetReconfig") {}
-    virtual bool run(OperationContext* txn,
+    virtual bool run(OperationContext* opCtx,
                      const string&,
                      BSONObj& cmdObj,
                      int,
@@ -424,15 +424,15 @@ public:
         parsedArgs.newConfigObj = cmdObj["replSetReconfig"].Obj();
         parsedArgs.force = cmdObj.hasField("force") && cmdObj["force"].trueValue();
         status =
-            getGlobalReplicationCoordinator()->processReplSetReconfig(txn, parsedArgs, &result);
+            getGlobalReplicationCoordinator()->processReplSetReconfig(opCtx, parsedArgs, &result);
 
-        ScopedTransaction scopedXact(txn, MODE_X);
-        Lock::GlobalWrite globalWrite(txn->lockState());
+        ScopedTransaction scopedXact(opCtx, MODE_X);
+        Lock::GlobalWrite globalWrite(opCtx->lockState());
 
-        WriteUnitOfWork wuow(txn);
+        WriteUnitOfWork wuow(opCtx);
         if (status.isOK() && !parsedArgs.force) {
             getGlobalServiceContext()->getOpObserver()->onOpMessage(
-                txn,
+                opCtx,
                 BSON("msg"
                      << "Reconfig set"
                      << "version"
@@ -462,7 +462,7 @@ public:
         help << "\nhttp://dochub.mongodb.org/core/replicasetcommands";
     }
     CmdReplSetFreeze() : ReplSetCommand("replSetFreeze") {}
-    virtual bool run(OperationContext* txn,
+    virtual bool run(OperationContext* opCtx,
                      const string&,
                      BSONObj& cmdObj,
                      int,
@@ -494,7 +494,7 @@ public:
         help << "http://dochub.mongodb.org/core/replicasetcommands";
     }
     CmdReplSetStepDown() : ReplSetCommand("replSetStepDown") {}
-    virtual bool run(OperationContext* txn,
+    virtual bool run(OperationContext* opCtx,
                      const string&,
                      BSONObj& cmdObj,
                      int,
@@ -543,7 +543,7 @@ public:
         log() << "Attempting to step down in response to replSetStepDown command";
 
         status = getGlobalReplicationCoordinator()->stepDown(
-            txn, force, Seconds(secondaryCatchUpPeriodSecs), Seconds(stepDownForSecs));
+            opCtx, force, Seconds(secondaryCatchUpPeriodSecs), Seconds(stepDownForSecs));
         return appendCommandStatus(result, status);
     }
 
@@ -560,7 +560,7 @@ public:
         help << "Enable or disable maintenance mode.";
     }
     CmdReplSetMaintenance() : ReplSetCommand("replSetMaintenance") {}
-    virtual bool run(OperationContext* txn,
+    virtual bool run(OperationContext* opCtx,
                      const string&,
                      BSONObj& cmdObj,
                      int,
@@ -589,7 +589,7 @@ public:
                 "in-progress initial sync.";
     }
     CmdReplSetSyncFrom() : ReplSetCommand("replSetSyncFrom") {}
-    virtual bool run(OperationContext* txn,
+    virtual bool run(OperationContext* opCtx,
                      const string&,
                      BSONObj& cmdObj,
                      int,
@@ -606,7 +606,7 @@ public:
 
         return appendCommandStatus(result,
                                    getGlobalReplicationCoordinator()->processReplSetSyncFrom(
-                                       txn, targetHostAndPort, &result));
+                                       opCtx, targetHostAndPort, &result));
     }
 
 private:
@@ -618,13 +618,13 @@ private:
 class CmdReplSetUpdatePosition : public ReplSetCommand {
 public:
     CmdReplSetUpdatePosition() : ReplSetCommand("replSetUpdatePosition") {}
-    virtual bool run(OperationContext* txn,
+    virtual bool run(OperationContext* opCtx,
                      const string&,
                      BSONObj& cmdObj,
                      int,
                      string& errmsg,
                      BSONObjBuilder& result) {
-        auto replCoord = repl::ReplicationCoordinator::get(txn->getClient()->getServiceContext());
+        auto replCoord = repl::ReplicationCoordinator::get(opCtx->getClient()->getServiceContext());
 
         Status status = replCoord->checkReplEnabledForCommand(&result);
         if (!status.isOK())
@@ -684,7 +684,7 @@ namespace {
  * The "local" database does NOT count except for "rs.oplog" collection.
  * Used to set the hasData field on replset heartbeat command response.
  */
-bool replHasDatabases(OperationContext* txn) {
+bool replHasDatabases(OperationContext* opCtx) {
     std::vector<string> names;
     StorageEngine* storageEngine = getGlobalServiceContext()->getGlobalStorageEngine();
     storageEngine->listDatabases(&names);
@@ -697,7 +697,7 @@ bool replHasDatabases(OperationContext* txn) {
 
         // we have a local database.  return true if oplog isn't empty
         BSONObj o;
-        if (Helpers::getSingleton(txn, repl::rsOplogName.c_str(), o)) {
+        if (Helpers::getSingleton(opCtx, repl::rsOplogName.c_str(), o)) {
             return true;
         }
     }
@@ -718,7 +718,7 @@ MONGO_FP_DECLARE(rsDelayHeartbeatResponse);
 class CmdReplSetHeartbeat : public ReplSetCommand {
 public:
     CmdReplSetHeartbeat() : ReplSetCommand("replSetHeartbeat") {}
-    virtual bool run(OperationContext* txn,
+    virtual bool run(OperationContext* opCtx,
                      const string&,
                      BSONObj& cmdObj,
                      int,
@@ -740,7 +740,7 @@ public:
         /* we want to keep heartbeat connections open when relinquishing primary.
            tag them here. */
         transport::Session::TagMask originalTag = 0;
-        auto session = txn->getClient()->session();
+        auto session = opCtx->getClient()->session();
         if (session) {
             originalTag = session->getTags();
             session->replaceTags(originalTag | transport::Session::kKeepOpen);
@@ -777,7 +777,7 @@ public:
 
         // ugh.
         if (args.getCheckEmpty()) {
-            result.append("hasData", replHasDatabases(txn));
+            result.append("hasData", replHasDatabases(opCtx));
         }
 
         ReplSetHeartbeatResponse response;
@@ -795,7 +795,7 @@ class CmdReplSetFresh : public ReplSetCommand {
 public:
     CmdReplSetFresh() : ReplSetCommand("replSetFresh") {}
 
-    virtual bool run(OperationContext* txn,
+    virtual bool run(OperationContext* opCtx,
                      const string&,
                      BSONObj& cmdObj,
                      int,
@@ -828,7 +828,7 @@ public:
     CmdReplSetElect() : ReplSetCommand("replSetElect") {}
 
 private:
-    virtual bool run(OperationContext* txn,
+    virtual bool run(OperationContext* opCtx,
                      const string&,
                      BSONObj& cmdObj,
                      int,
@@ -862,7 +862,7 @@ class CmdReplSetStepUp : public ReplSetCommand {
 public:
     CmdReplSetStepUp() : ReplSetCommand("replSetStepUp") {}
 
-    virtual bool run(OperationContext* txn,
+    virtual bool run(OperationContext* opCtx,
                      const string&,
                      BSONObj& cmdObj,
                      int,
diff --git a/src/mongo/db/repl/repl_set_request_votes.cpp b/src/mongo/db/repl/repl_set_request_votes.cpp
index 02eb5311cb3..5577952807d 100644
--- a/src/mongo/db/repl/repl_set_request_votes.cpp
+++ b/src/mongo/db/repl/repl_set_request_votes.cpp
@@ -47,7 +47,7 @@ public:
     CmdReplSetRequestVotes() : ReplSetCommand("replSetRequestVotes") {}
 
 private:
-    bool run(OperationContext* txn,
+    bool run(OperationContext* opCtx,
              const std::string&,
              BSONObj& cmdObj,
              int,
@@ -67,7 +67,7 @@ private:
         // We want to keep request vote connection open when relinquishing primary.
         // Tag it here.
         transport::Session::TagMask originalTag = 0;
-        auto session = txn->getClient()->session();
+        auto session = opCtx->getClient()->session();
         if (session) {
             originalTag = session->getTags();
             session->replaceTags(originalTag | transport::Session::kKeepOpen);
@@ -82,7 +82,7 @@ private:
 
         ReplSetRequestVotesResponse response;
         status = getGlobalReplicationCoordinator()->processReplSetRequestVotes(
-            txn, parsedArgs, &response);
+            opCtx, parsedArgs, &response);
         response.addToBSON(&result);
         return appendCommandStatus(result, status);
     }
diff --git a/src/mongo/db/repl/repl_set_web_handler.cpp b/src/mongo/db/repl/repl_set_web_handler.cpp
index 3f67cd9a45c..404dc659ae7 100644
--- a/src/mongo/db/repl/repl_set_web_handler.cpp
+++ b/src/mongo/db/repl/repl_set_web_handler.cpp
@@ -51,7 +51,7 @@ public:
         return str::startsWith(url, "/_replSet");
     }
 
-    virtual void handle(OperationContext* txn,
+    virtual void handle(OperationContext* opCtx,
                         const char* rq,
                         const std::string& url,
                         BSONObj params,
@@ -59,12 +59,12 @@ public:
                         int& responseCode,
                         std::vector<std::string>& headers,
                         const SockAddr& from) {
-        responseMsg = _replSet(txn);
+        responseMsg = _replSet(opCtx);
         responseCode = 200;
     }
 
     /* /_replSet show replica set status in html format */
-    std::string _replSet(OperationContext* txn) {
+    std::string _replSet(OperationContext* opCtx) {
         std::stringstream s;
         s << start("Replica Set Status " + prettyHostName());
         s << p(a("/", "back", "Home") + " | " +
diff --git a/src/mongo/db/repl/replication_coordinator.h b/src/mongo/db/repl/replication_coordinator.h
index 1d3dda6f5b6..d5557213bb4 100644
--- a/src/mongo/db/repl/replication_coordinator.h
+++ b/src/mongo/db/repl/replication_coordinator.h
@@ -123,14 +123,14 @@ public:
      * components of the replication system to start up whatever threads and do whatever
      * initialization they need.
      */
-    virtual void startup(OperationContext* txn) = 0;
+    virtual void startup(OperationContext* opCtx) = 0;
 
     /**
      * Does whatever cleanup is required to stop replication, including instructing the other
      * components of the replication system to shut down and stop any threads they are using,
      * blocking until all replication-related shutdown tasks are complete.
      */
-    virtual void shutdown(OperationContext* txn) = 0;
+    virtual void shutdown(OperationContext* opCtx) = 0;
 
     /**
      * Returns a pointer to the ReplicationExecutor.
@@ -194,7 +194,7 @@ public:
      * writeConcern.wTimeout of -1 indicates return immediately after checking. Return codes:
      * ErrorCodes::WriteConcernFailed if the writeConcern.wTimeout is reached before
      *     the data has been sufficiently replicated
-     * ErrorCodes::ExceededTimeLimit if the txn->getMaxTimeMicrosRemaining is reached before
+     * ErrorCodes::ExceededTimeLimit if the opCtx->getMaxTimeMicrosRemaining is reached before
      *     the data has been sufficiently replicated
      * ErrorCodes::NotMaster if the node is not Primary/Master
      * ErrorCodes::UnknownReplWriteConcern if the writeConcern.wMode contains a write concern
@@ -202,16 +202,16 @@ public:
      * ErrorCodes::ShutdownInProgress if we are mid-shutdown
      * ErrorCodes::Interrupted if the operation was killed with killop()
      */
-    virtual StatusAndDuration awaitReplication(OperationContext* txn,
+    virtual StatusAndDuration awaitReplication(OperationContext* opCtx,
                                                const OpTime& opTime,
                                                const WriteConcernOptions& writeConcern) = 0;
 
     /**
      * Like awaitReplication(), above, but waits for the replication of the last operation
-     * performed on the client associated with "txn".
+     * performed on the client associated with "opCtx".
      */
     virtual StatusAndDuration awaitReplicationOfLastOpForClient(
-        OperationContext* txn, const WriteConcernOptions& writeConcern) = 0;
+        OperationContext* opCtx, const WriteConcernOptions& writeConcern) = 0;
 
     /**
      * Causes this node to relinquish being primary for at least 'stepdownTime'.  If 'force' is
@@ -222,7 +222,7 @@ public:
      * ErrorCodes::SecondaryAheadOfPrimary if we are primary but there is another node that
      * seems to be ahead of us in replication, and Status::OK otherwise.
      */
-    virtual Status stepDown(OperationContext* txn,
+    virtual Status stepDown(OperationContext* opCtx,
                             bool force,
                             const Milliseconds& waitTime,
                             const Milliseconds& stepdownTime) = 0;
@@ -245,14 +245,14 @@ public:
      * NOTE: This function can only be meaningfully called while the caller holds the global
      * lock in some mode other than MODE_NONE.
      */
-    virtual bool canAcceptWritesForDatabase(OperationContext* txn, StringData dbName) = 0;
+    virtual bool canAcceptWritesForDatabase(OperationContext* opCtx, StringData dbName) = 0;
 
     /**
      * Version which does not check for the global lock.  Do not use in new code.
      * Without the global lock held, the return value may be inaccurate by the time
      * the function returns.
      */
-    virtual bool canAcceptWritesForDatabase_UNSAFE(OperationContext* txn, StringData dbName) = 0;
+    virtual bool canAcceptWritesForDatabase_UNSAFE(OperationContext* opCtx, StringData dbName) = 0;
 
     /**
      * Returns true if it is valid for this node to accept writes on the given namespace.
@@ -260,14 +260,14 @@ public:
      * The result of this function should be consistent with canAcceptWritesForDatabase()
      * for the database the namespace refers to, with additional checks on the collection.
      */
-    virtual bool canAcceptWritesFor(OperationContext* txn, const NamespaceString& ns) = 0;
+    virtual bool canAcceptWritesFor(OperationContext* opCtx, const NamespaceString& ns) = 0;
 
     /**
      * Version which does not check for the global lock.  Do not use in new code.
      * Without the global lock held, the return value may be inaccurate by the time
      * the function returns.
      */
-    virtual bool canAcceptWritesFor_UNSAFE(OperationContext* txn, const NamespaceString& ns) = 0;
+    virtual bool canAcceptWritesFor_UNSAFE(OperationContext* opCtx, const NamespaceString& ns) = 0;
 
     /**
      * Checks if the current replica set configuration can satisfy the given write concern.
@@ -284,7 +284,7 @@ public:
      * Returns Status::OK() if it is valid for this node to serve reads on the given collection
      * and an errorcode indicating why the node cannot if it cannot.
      */
-    virtual Status checkCanServeReadsFor(OperationContext* txn,
+    virtual Status checkCanServeReadsFor(OperationContext* opCtx,
                                          const NamespaceString& ns,
                                          bool slaveOk) = 0;
 
@@ -293,7 +293,7 @@ public:
      * Without the global lock held, the return value may be inaccurate by the time
      * the function returns.
      */
-    virtual Status checkCanServeReadsFor_UNSAFE(OperationContext* txn,
+    virtual Status checkCanServeReadsFor_UNSAFE(OperationContext* opCtx,
                                                 const NamespaceString& ns,
                                                 bool slaveOk) = 0;
 
@@ -303,7 +303,8 @@ public:
      * The namespace "ns" is passed in because the "local" database is usually writable
      * and we need to enforce the constraints for it.
      */
-    virtual bool shouldRelaxIndexConstraints(OperationContext* txn, const NamespaceString& ns) = 0;
+    virtual bool shouldRelaxIndexConstraints(OperationContext* opCtx,
+                                             const NamespaceString& ns) = 0;
 
     /**
      * Updates our internal tracking of the last OpTime applied for the given slave
@@ -378,7 +379,7 @@ public:
      *
      * Returns whether the wait was successful.
      */
-    virtual Status waitUntilOpTimeForRead(OperationContext* txn,
+    virtual Status waitUntilOpTimeForRead(OperationContext* opCtx,
                                           const ReadConcernArgs& settings) = 0;
 
     /**
@@ -486,7 +487,7 @@ public:
      * steps down and steps up so quickly that the applier signals drain complete in the wrong
      * term.
      */
-    virtual void signalDrainComplete(OperationContext* txn, long long termWhenBufferIsEmpty) = 0;
+    virtual void signalDrainComplete(OperationContext* opCtx, long long termWhenBufferIsEmpty) = 0;
 
     /**
      * Waits duration of 'timeout' for applier to finish draining its buffer of operations.
@@ -527,7 +528,7 @@ public:
     /**
      * Does an initial sync of data, after dropping existing data.
      */
-    virtual Status resyncData(OperationContext* txn, bool waitUntilCompleted) = 0;
+    virtual Status resyncData(OperationContext* opCtx, bool waitUntilCompleted) = 0;
 
     /**
      * Handles an incoming isMaster command for a replica set node.  Should not be
@@ -592,7 +593,7 @@ public:
      * returns Status::OK if the sync target could be set and an ErrorCode indicating why it
      * couldn't otherwise.
      */
-    virtual Status processReplSetSyncFrom(OperationContext* txn,
+    virtual Status processReplSetSyncFrom(OperationContext* opCtx,
                                           const HostAndPort& target,
                                           BSONObjBuilder* resultObj) = 0;
 
@@ -625,7 +626,7 @@ public:
      * Handles an incoming replSetReconfig command. Adds BSON to 'resultObj';
      * returns a Status with either OK or an error message.
      */
-    virtual Status processReplSetReconfig(OperationContext* txn,
+    virtual Status processReplSetReconfig(OperationContext* opCtx,
                                           const ReplSetReconfigArgs& args,
                                           BSONObjBuilder* resultObj) = 0;
 
@@ -634,7 +635,7 @@ public:
      * configuration to use.
      * Adds BSON to 'resultObj'; returns a Status with either OK or an error message.
      */
-    virtual Status processReplSetInitiate(OperationContext* txn,
+    virtual Status processReplSetInitiate(OperationContext* opCtx,
                                           const BSONObj& configObj,
                                           BSONObjBuilder* resultObj) = 0;
 
@@ -710,7 +711,7 @@ public:
      *
      * Returns ErrorCodes::IllegalOperation if we're not running with master/slave replication.
      */
-    virtual Status processHandshake(OperationContext* txn, const HandshakeArgs& handshake) = 0;
+    virtual Status processHandshake(OperationContext* opCtx, const HandshakeArgs& handshake) = 0;
 
     /**
      * Returns a bool indicating whether or not this node builds indexes.
@@ -749,7 +750,7 @@ public:
      * Loads the optime from the last op in the oplog into the coordinator's lastAppliedOpTime and
      * lastDurableOpTime values.
      */
-    virtual void resetLastOpTimesFromOplog(OperationContext* txn) = 0;
+    virtual void resetLastOpTimesFromOplog(OperationContext* opCtx) = 0;
 
     /**
      * Returns the OpTime of the latest replica set-committed op known to this server.
@@ -762,7 +763,7 @@ public:
     * Handles an incoming replSetRequestVotes command.
     * Adds BSON to 'resultObj'; returns a Status with either OK or an error message.
     */
-    virtual Status processReplSetRequestVotes(OperationContext* txn,
+    virtual Status processReplSetRequestVotes(OperationContext* opCtx,
                                               const ReplSetRequestVotesArgs& args,
                                               ReplSetRequestVotesResponse* response) = 0;
 
@@ -803,7 +804,7 @@ public:
      * the rest of the work, because the term is still the same).
      * Returns StaleTerm if the supplied term was higher than the current term.
      */
-    virtual Status updateTerm(OperationContext* txn, long long term) = 0;
+    virtual Status updateTerm(OperationContext* opCtx, long long term) = 0;
 
     /**
      * Reserves a unique SnapshotName.
@@ -819,7 +820,7 @@ public:
      * A null OperationContext can be used in cases where the snapshot to wait for should not be
      * adjusted.
      */
-    virtual SnapshotName reserveSnapshotName(OperationContext* txn) = 0;
+    virtual SnapshotName reserveSnapshotName(OperationContext* opCtx) = 0;
 
     /**
      * Signals the SnapshotThread, if running, to take a forced snapshot even if the global
@@ -833,16 +834,16 @@ public:
      * Creates a new snapshot in the storage engine and registers it for use in the replication
      * coordinator.
      */
-    virtual void createSnapshot(OperationContext* txn,
+    virtual void createSnapshot(OperationContext* opCtx,
                                 OpTime timeOfSnapshot,
                                 SnapshotName name) = 0;
 
     /**
      * Blocks until either the current committed snapshot is at least as high as 'untilSnapshot',
      * or we are interrupted for any reason, including shutdown or maxTimeMs expiration.
-     * 'txn' is used to checkForInterrupt and enforce maxTimeMS.
+     * 'opCtx' is used to checkForInterrupt and enforce maxTimeMS.
      */
-    virtual void waitUntilSnapshotCommitted(OperationContext* txn,
+    virtual void waitUntilSnapshotCommitted(OperationContext* opCtx,
                                             const SnapshotName& untilSnapshot) = 0;
 
     /**
diff --git a/src/mongo/db/repl/replication_coordinator_external_state.h b/src/mongo/db/repl/replication_coordinator_external_state.h
index 66283518bfe..05f07b8aada 100644
--- a/src/mongo/db/repl/replication_coordinator_external_state.h
+++ b/src/mongo/db/repl/replication_coordinator_external_state.h
@@ -60,7 +60,7 @@ class ReplSettings;
 class ReplicationCoordinator;
 class ReplicationExecutor;
 
-using OnInitialSyncFinishedFn = stdx::function<void(OperationContext* txn)>;
+using OnInitialSyncFinishedFn = stdx::function<void(OperationContext* opCtx)>;
 using StartInitialSyncFn = stdx::function<void(OnInitialSyncFinishedFn callback)>;
 using StartSteadyReplicationFn = stdx::function<void()>;
 /**
@@ -94,33 +94,33 @@ public:
     /**
      * Returns true if an incomplete initial sync is detected.
      */
-    virtual bool isInitialSyncFlagSet(OperationContext* txn) = 0;
+    virtual bool isInitialSyncFlagSet(OperationContext* opCtx) = 0;
 
     /**
      * Starts steady state sync for replica set member -- legacy impl not in DataReplicator.
      *
      * NOTE: Use either this or the Master/Slave version, but not both.
      */
-    virtual void startSteadyStateReplication(OperationContext* txn,
+    virtual void startSteadyStateReplication(OperationContext* opCtx,
                                              ReplicationCoordinator* replCoord) = 0;
 
-    virtual void runOnInitialSyncThread(stdx::function<void(OperationContext* txn)> run) = 0;
+    virtual void runOnInitialSyncThread(stdx::function<void(OperationContext* opCtx)> run) = 0;
 
     /**
      * Stops the data replication threads = bgsync, applier, reporter.
      */
-    virtual void stopDataReplication(OperationContext* txn) = 0;
+    virtual void stopDataReplication(OperationContext* opCtx) = 0;
 
     /**
      * Starts the Master/Slave threads and sets up logOp
      */
-    virtual void startMasterSlave(OperationContext* txn) = 0;
+    virtual void startMasterSlave(OperationContext* opCtx) = 0;
 
     /**
      * Performs any necessary external state specific shutdown tasks, such as cleaning up
      * the threads it started.
      */
-    virtual void shutdown(OperationContext* txn) = 0;
+    virtual void shutdown(OperationContext* opCtx) = 0;
 
     /**
      * Returns task executor for scheduling tasks to be run asynchronously.
@@ -136,12 +136,12 @@ public:
      * Runs the repair database command on the "local" db, if the storage engine is MMapV1.
      * Note: Used after initial sync to compact the database files.
      */
-    virtual Status runRepairOnLocalDB(OperationContext* txn) = 0;
+    virtual Status runRepairOnLocalDB(OperationContext* opCtx) = 0;
 
     /**
      * Creates the oplog, writes the first entry and stores the replica set config document.
      */
-    virtual Status initializeReplSetStorage(OperationContext* txn, const BSONObj& config) = 0;
+    virtual Status initializeReplSetStorage(OperationContext* opCtx, const BSONObj& config) = 0;
 
     /**
      * Called when a node on way to becoming a primary is ready to leave drain mode. It is called
@@ -149,7 +149,7 @@ public:
      *
      * Throws on errors.
      */
-    virtual void onDrainComplete(OperationContext* txn) = 0;
+    virtual void onDrainComplete(OperationContext* opCtx) = 0;
 
     /**
      * Called as part of the process of transitioning to primary and run with the global X lock and
@@ -163,7 +163,7 @@ public:
      *
      * Throws on errors.
      */
-    virtual OpTime onTransitionToPrimary(OperationContext* txn, bool isV1ElectionProtocol) = 0;
+    virtual OpTime onTransitionToPrimary(OperationContext* opCtx, bool isV1ElectionProtocol) = 0;
 
     /**
      * Simple wrapper around SyncSourceFeedback::forwardSlaveProgress.  Signals to the
@@ -188,22 +188,23 @@ public:
     /**
      * Gets the replica set config document from local storage, or returns an error.
      */
-    virtual StatusWith<BSONObj> loadLocalConfigDocument(OperationContext* txn) = 0;
+    virtual StatusWith<BSONObj> loadLocalConfigDocument(OperationContext* opCtx) = 0;
 
     /**
      * Stores the replica set config document in local storage, or returns an error.
      */
-    virtual Status storeLocalConfigDocument(OperationContext* txn, const BSONObj& config) = 0;
+    virtual Status storeLocalConfigDocument(OperationContext* opCtx, const BSONObj& config) = 0;
 
     /**
      * Gets the replica set lastVote document from local storage, or returns an error.
      */
-    virtual StatusWith<LastVote> loadLocalLastVoteDocument(OperationContext* txn) = 0;
+    virtual StatusWith<LastVote> loadLocalLastVoteDocument(OperationContext* opCtx) = 0;
 
     /**
      * Stores the replica set lastVote document in local storage, or returns an error.
      */
-    virtual Status storeLocalLastVoteDocument(OperationContext* txn, const LastVote& lastVote) = 0;
+    virtual Status storeLocalLastVoteDocument(OperationContext* opCtx,
+                                              const LastVote& lastVote) = 0;
 
     /**
      * Sets the global opTime to be 'newTime'.
@@ -214,20 +215,20 @@ public:
      * Gets the last optime of an operation performed on this host, from stable
      * storage.
      */
-    virtual StatusWith<OpTime> loadLastOpTime(OperationContext* txn) = 0;
+    virtual StatusWith<OpTime> loadLastOpTime(OperationContext* opCtx) = 0;
 
     /**
      * Cleaning up the oplog, by potentially truncating:
      * If we are recovering from a failed batch then minvalid.start though minvalid.end need
      * to be removed from the oplog before we can start applying operations.
      */
-    virtual void cleanUpLastApplyBatch(OperationContext* txn) = 0;
+    virtual void cleanUpLastApplyBatch(OperationContext* opCtx) = 0;
 
     /**
      * Returns the HostAndPort of the remote client connected to us that initiated the operation
-     * represented by "txn".
+     * represented by "opCtx".
      */
-    virtual HostAndPort getClientHostAndPort(const OperationContext* txn) = 0;
+    virtual HostAndPort getClientHostAndPort(const OperationContext* opCtx) = 0;
 
     /**
      * Closes all connections in the given TransportLayer except those marked with the
@@ -240,7 +241,7 @@ public:
      * Kills all operations that have a Client that is associated with an incoming user
      * connection.  Used during stepdown.
      */
-    virtual void killAllUserOperations(OperationContext* txn) = 0;
+    virtual void killAllUserOperations(OperationContext* opCtx) = 0;
 
     /**
      * Resets any active sharding metadata on this server and stops any sharding-related threads
@@ -279,7 +280,7 @@ public:
     /**
      * Creates a new snapshot.
      */
-    virtual void createSnapshot(OperationContext* txn, SnapshotName name) = 0;
+    virtual void createSnapshot(OperationContext* opCtx, SnapshotName name) = 0;
 
     /**
      * Signals the SnapshotThread, if running, to take a forced snapshot even if the global
@@ -305,13 +306,13 @@ public:
     /**
      * Returns true if the current storage engine supports read committed.
      */
-    virtual bool isReadCommittedSupportedByStorageEngine(OperationContext* txn) const = 0;
+    virtual bool isReadCommittedSupportedByStorageEngine(OperationContext* opCtx) const = 0;
 
     /**
      * Applies the operations described in the oplog entries contained in "ops" using the
      * "applyOperation" function.
      */
-    virtual StatusWith<OpTime> multiApply(OperationContext* txn,
+    virtual StatusWith<OpTime> multiApply(OperationContext* opCtx,
                                           MultiApplier::Operations ops,
                                           MultiApplier::ApplyOperationFn applyOperation) = 0;
 
@@ -333,13 +334,13 @@ public:
      * This function creates an oplog buffer of the type specified at server startup.
      */
     virtual std::unique_ptr<OplogBuffer> makeInitialSyncOplogBuffer(
-        OperationContext* txn) const = 0;
+        OperationContext* opCtx) const = 0;
 
     /**
      * Creates an oplog buffer suitable for steady state replication.
      */
     virtual std::unique_ptr<OplogBuffer> makeSteadyStateOplogBuffer(
-        OperationContext* txn) const = 0;
+        OperationContext* opCtx) const = 0;
 
     /**
      * Returns true if the user specified to use the data replicator for initial sync.
diff --git a/src/mongo/db/repl/replication_coordinator_external_state_impl.cpp b/src/mongo/db/repl/replication_coordinator_external_state_impl.cpp
index 70c74cc8942..36d8a84fd06 100644
--- a/src/mongo/db/repl/replication_coordinator_external_state_impl.cpp
+++ b/src/mongo/db/repl/replication_coordinator_external_state_impl.cpp
@@ -195,46 +195,46 @@ ReplicationCoordinatorExternalStateImpl::ReplicationCoordinatorExternalStateImpl
 }
 ReplicationCoordinatorExternalStateImpl::~ReplicationCoordinatorExternalStateImpl() {}
 
-bool ReplicationCoordinatorExternalStateImpl::isInitialSyncFlagSet(OperationContext* txn) {
-    return _storageInterface->getInitialSyncFlag(txn);
+bool ReplicationCoordinatorExternalStateImpl::isInitialSyncFlagSet(OperationContext* opCtx) {
+    return _storageInterface->getInitialSyncFlag(opCtx);
 }
 
 void ReplicationCoordinatorExternalStateImpl::startInitialSync(OnInitialSyncFinishedFn finished) {
-    _initialSyncRunner.schedule([finished, this](OperationContext* txn, const Status& status) {
+    _initialSyncRunner.schedule([finished, this](OperationContext* opCtx, const Status& status) {
         if (status == ErrorCodes::CallbackCanceled) {
             return TaskRunner::NextAction::kDisposeOperationContext;
         }
         // Do initial sync.
-        syncDoInitialSync(txn, this);
-        finished(txn);
+        syncDoInitialSync(opCtx, this);
+        finished(opCtx);
         return TaskRunner::NextAction::kDisposeOperationContext;
     });
 }
 
 void ReplicationCoordinatorExternalStateImpl::runOnInitialSyncThread(
-    stdx::function<void(OperationContext* txn)> run) {
+    stdx::function<void(OperationContext* opCtx)> run) {
     _initialSyncRunner.cancel();
     _initialSyncRunner.join();
-    _initialSyncRunner.schedule([run, this](OperationContext* txn, const Status& status) {
+    _initialSyncRunner.schedule([run, this](OperationContext* opCtx, const Status& status) {
         if (status == ErrorCodes::CallbackCanceled) {
             return TaskRunner::NextAction::kDisposeOperationContext;
         }
-        invariant(txn);
-        invariant(txn->getClient());
-        run(txn);
+        invariant(opCtx);
+        invariant(opCtx->getClient());
+        run(opCtx);
         return TaskRunner::NextAction::kDisposeOperationContext;
     });
 }
 
 void ReplicationCoordinatorExternalStateImpl::startSteadyStateReplication(
-    OperationContext* txn, ReplicationCoordinator* replCoord) {
+    OperationContext* opCtx, ReplicationCoordinator* replCoord) {
 
     LockGuard lk(_threadMutex);
     invariant(replCoord);
     invariant(!_bgSync);
     log() << "Starting replication fetcher thread";
-    _bgSync = stdx::make_unique<BackgroundSync>(this, makeSteadyStateOplogBuffer(txn));
-    _bgSync->startup(txn);
+    _bgSync = stdx::make_unique<BackgroundSync>(this, makeSteadyStateOplogBuffer(opCtx));
+    _bgSync->startup(opCtx);
 
     log() << "Starting replication applier thread";
     invariant(!_applierThread);
@@ -246,12 +246,12 @@ void ReplicationCoordinatorExternalStateImpl::startSteadyStateReplication(
         &SyncSourceFeedback::run, &_syncSourceFeedback, _taskExecutor.get(), _bgSync.get())));
 }
 
-void ReplicationCoordinatorExternalStateImpl::stopDataReplication(OperationContext* txn) {
+void ReplicationCoordinatorExternalStateImpl::stopDataReplication(OperationContext* opCtx) {
     UniqueLock lk(_threadMutex);
-    _stopDataReplication_inlock(txn, &lk);
+    _stopDataReplication_inlock(opCtx, &lk);
 }
 
-void ReplicationCoordinatorExternalStateImpl::_stopDataReplication_inlock(OperationContext* txn,
+void ReplicationCoordinatorExternalStateImpl::_stopDataReplication_inlock(OperationContext* opCtx,
                                                                           UniqueLock* lock) {
     // Make sue no other _stopDataReplication calls are in progress.
     _dataReplicationStopped.wait(*lock, [this]() { return !_stoppingDataReplication; });
@@ -270,7 +270,7 @@ void ReplicationCoordinatorExternalStateImpl::_stopDataReplication_inlock(Operat
 
     if (oldBgSync) {
         log() << "Stopping replication fetcher thread";
-        oldBgSync->shutdown(txn);
+        oldBgSync->shutdown(opCtx);
     }
 
     if (oldApplier) {
@@ -279,7 +279,7 @@ void ReplicationCoordinatorExternalStateImpl::_stopDataReplication_inlock(Operat
     }
 
     if (oldBgSync) {
-        oldBgSync->join(txn);
+        oldBgSync->join(opCtx);
     }
 
     _initialSyncRunner.cancel();
@@ -320,25 +320,25 @@ void ReplicationCoordinatorExternalStateImpl::startThreads(const ReplSettings& s
     _startedThreads = true;
 }
 
-void ReplicationCoordinatorExternalStateImpl::startMasterSlave(OperationContext* txn) {
-    repl::startMasterSlave(txn);
+void ReplicationCoordinatorExternalStateImpl::startMasterSlave(OperationContext* opCtx) {
+    repl::startMasterSlave(opCtx);
 }
 
-void ReplicationCoordinatorExternalStateImpl::shutdown(OperationContext* txn) {
+void ReplicationCoordinatorExternalStateImpl::shutdown(OperationContext* opCtx) {
     UniqueLock lk(_threadMutex);
     if (_startedThreads) {
-        _stopDataReplication_inlock(txn, &lk);
+        _stopDataReplication_inlock(opCtx, &lk);
 
         if (_snapshotThread) {
             log() << "Stopping replication snapshot thread";
             _snapshotThread->shutdown();
         }
 
-        if (_storageInterface->getOplogDeleteFromPoint(txn).isNull() &&
-            loadLastOpTime(txn) == _storageInterface->getAppliedThrough(txn)) {
+        if (_storageInterface->getOplogDeleteFromPoint(opCtx).isNull() &&
+            loadLastOpTime(opCtx) == _storageInterface->getAppliedThrough(opCtx)) {
             // Clear the appliedThrough marker to indicate we are consistent with the top of the
             // oplog.
-            _storageInterface->setAppliedThrough(txn, {});
+            _storageInterface->setAppliedThrough(opCtx, {});
         }
 
         if (_noopWriter) {
@@ -361,95 +361,95 @@ OldThreadPool* ReplicationCoordinatorExternalStateImpl::getDbWorkThreadPool() co
     return _writerPool.get();
 }
 
-Status ReplicationCoordinatorExternalStateImpl::runRepairOnLocalDB(OperationContext* txn) {
+Status ReplicationCoordinatorExternalStateImpl::runRepairOnLocalDB(OperationContext* opCtx) {
     try {
-        ScopedTransaction scopedXact(txn, MODE_X);
-        Lock::GlobalWrite globalWrite(txn->lockState());
+        ScopedTransaction scopedXact(opCtx, MODE_X);
+        Lock::GlobalWrite globalWrite(opCtx->lockState());
         StorageEngine* engine = getGlobalServiceContext()->getGlobalStorageEngine();
 
         if (!engine->isMmapV1()) {
             return Status::OK();
         }
 
-        txn->setReplicatedWrites(false);
-        Status status = repairDatabase(txn, engine, localDbName, false, false);
+        opCtx->setReplicatedWrites(false);
+        Status status = repairDatabase(opCtx, engine, localDbName, false, false);
 
         // Open database before returning
-        dbHolder().openDb(txn, localDbName);
+        dbHolder().openDb(opCtx, localDbName);
     } catch (const DBException& ex) {
         return ex.toStatus();
     }
     return Status::OK();
 }
 
-Status ReplicationCoordinatorExternalStateImpl::initializeReplSetStorage(OperationContext* txn,
+Status ReplicationCoordinatorExternalStateImpl::initializeReplSetStorage(OperationContext* opCtx,
                                                                          const BSONObj& config) {
     try {
-        createOplog(txn);
+        createOplog(opCtx);
 
         MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
-            ScopedTransaction scopedXact(txn, MODE_X);
-            Lock::GlobalWrite globalWrite(txn->lockState());
+            ScopedTransaction scopedXact(opCtx, MODE_X);
+            Lock::GlobalWrite globalWrite(opCtx->lockState());
 
-            WriteUnitOfWork wuow(txn);
-            Helpers::putSingleton(txn, configCollectionName, config);
+            WriteUnitOfWork wuow(opCtx);
+            Helpers::putSingleton(opCtx, configCollectionName, config);
             const auto msgObj = BSON("msg"
                                      << "initiating set");
-            getGlobalServiceContext()->getOpObserver()->onOpMessage(txn, msgObj);
+            getGlobalServiceContext()->getOpObserver()->onOpMessage(opCtx, msgObj);
             wuow.commit();
         }
-        MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "initiate oplog entry", "local.oplog.rs");
+        MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "initiate oplog entry", "local.oplog.rs");
 
         // This initializes the minvalid document with a null "ts" because older versions (<=3.2)
         // get angry if the minValid document is present but doesn't have a "ts" field.
         // Consider removing this once we no longer need to support downgrading to 3.2.
-        _storageInterface->setMinValidToAtLeast(txn, {});
+        _storageInterface->setMinValidToAtLeast(opCtx, {});
 
-        FeatureCompatibilityVersion::setIfCleanStartup(txn, _storageInterface);
+        FeatureCompatibilityVersion::setIfCleanStartup(opCtx, _storageInterface);
     } catch (const DBException& ex) {
         return ex.toStatus();
     }
     return Status::OK();
 }
 
-void ReplicationCoordinatorExternalStateImpl::onDrainComplete(OperationContext* txn) {
-    invariant(!txn->lockState()->isLocked());
+void ReplicationCoordinatorExternalStateImpl::onDrainComplete(OperationContext* opCtx) {
+    invariant(!opCtx->lockState()->isLocked());
 
     // If this is a config server node becoming a primary, ensure the balancer is ready to start.
     if (serverGlobalParams.clusterRole == ClusterRole::ConfigServer) {
         // We must ensure the balancer has stopped because it may still be in the process of
         // stopping if this node was previously primary.
-        Balancer::get(txn)->waitForBalancerToStop();
+        Balancer::get(opCtx)->waitForBalancerToStop();
     }
 }
 
-OpTime ReplicationCoordinatorExternalStateImpl::onTransitionToPrimary(OperationContext* txn,
+OpTime ReplicationCoordinatorExternalStateImpl::onTransitionToPrimary(OperationContext* opCtx,
                                                                       bool isV1ElectionProtocol) {
-    invariant(txn->lockState()->isW());
+    invariant(opCtx->lockState()->isW());
 
     // Clear the appliedThrough marker so on startup we'll use the top of the oplog. This must be
     // done before we add anything to our oplog.
-    invariant(_storageInterface->getOplogDeleteFromPoint(txn).isNull());
-    _storageInterface->setAppliedThrough(txn, {});
+    invariant(_storageInterface->getOplogDeleteFromPoint(opCtx).isNull());
+    _storageInterface->setAppliedThrough(opCtx, {});
 
     if (isV1ElectionProtocol) {
         MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
-            ScopedTransaction scopedXact(txn, MODE_X);
+            ScopedTransaction scopedXact(opCtx, MODE_X);
 
-            WriteUnitOfWork wuow(txn);
-            txn->getClient()->getServiceContext()->getOpObserver()->onOpMessage(
-                txn,
+            WriteUnitOfWork wuow(opCtx);
+            opCtx->getClient()->getServiceContext()->getOpObserver()->onOpMessage(
+                opCtx,
                 BSON("msg"
                      << "new primary"));
             wuow.commit();
         }
         MONGO_WRITE_CONFLICT_RETRY_LOOP_END(
-            txn, "logging transition to primary to oplog", "local.oplog.rs");
+            opCtx, "logging transition to primary to oplog", "local.oplog.rs");
     }
-    const auto opTimeToReturn = fassertStatusOK(28665, loadLastOpTime(txn));
+    const auto opTimeToReturn = fassertStatusOK(28665, loadLastOpTime(opCtx));
 
-    _shardingOnTransitionToPrimaryHook(txn);
-    _dropAllTempCollections(txn);
+    _shardingOnTransitionToPrimaryHook(opCtx);
+    _dropAllTempCollections(opCtx);
 
     serverGlobalParams.featureCompatibility.validateFeaturesAsMaster.store(true);
 
@@ -460,28 +460,28 @@ void ReplicationCoordinatorExternalStateImpl::forwardSlaveProgress() {
     _syncSourceFeedback.forwardSlaveProgress();
 }
 
-OID ReplicationCoordinatorExternalStateImpl::ensureMe(OperationContext* txn) {
+OID ReplicationCoordinatorExternalStateImpl::ensureMe(OperationContext* opCtx) {
     std::string myname = getHostName();
     OID myRID;
     {
-        ScopedTransaction transaction(txn, MODE_IX);
-        Lock::DBLock lock(txn->lockState(), meDatabaseName, MODE_X);
+        ScopedTransaction transaction(opCtx, MODE_IX);
+        Lock::DBLock lock(opCtx->lockState(), meDatabaseName, MODE_X);
 
         BSONObj me;
         // local.me is an identifier for a server for getLastError w:2+
         // TODO: handle WriteConflictExceptions below
-        if (!Helpers::getSingleton(txn, meCollectionName, me) || !me.hasField("host") ||
+        if (!Helpers::getSingleton(opCtx, meCollectionName, me) || !me.hasField("host") ||
             me["host"].String() != myname) {
             myRID = OID::gen();
 
             // clean out local.me
-            Helpers::emptyCollection(txn, meCollectionName);
+            Helpers::emptyCollection(opCtx, meCollectionName);
 
             // repopulate
             BSONObjBuilder b;
             b.append("_id", myRID);
             b.append("host", myname);
-            Helpers::putSingleton(txn, meCollectionName, b.done());
+            Helpers::putSingleton(opCtx, meCollectionName, b.done());
         } else {
             myRID = me["_id"].OID();
         }
@@ -490,11 +490,11 @@ OID ReplicationCoordinatorExternalStateImpl::ensureMe(OperationContext* txn) {
 }
 
 StatusWith<BSONObj> ReplicationCoordinatorExternalStateImpl::loadLocalConfigDocument(
-    OperationContext* txn) {
+    OperationContext* opCtx) {
     try {
         MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
             BSONObj config;
-            if (!Helpers::getSingleton(txn, configCollectionName, config)) {
+            if (!Helpers::getSingleton(opCtx, configCollectionName, config)) {
                 return StatusWith<BSONObj>(
                     ErrorCodes::NoMatchingDocument,
                     str::stream() << "Did not find replica set configuration document in "
@@ -502,33 +502,33 @@ StatusWith<BSONObj> ReplicationCoordinatorExternalStateImpl::loadLocalConfigDocu
             }
             return StatusWith<BSONObj>(config);
         }
-        MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "load replica set config", configCollectionName);
+        MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "load replica set config", configCollectionName);
     } catch (const DBException& ex) {
         return StatusWith<BSONObj>(ex.toStatus());
     }
 }
 
-Status ReplicationCoordinatorExternalStateImpl::storeLocalConfigDocument(OperationContext* txn,
+Status ReplicationCoordinatorExternalStateImpl::storeLocalConfigDocument(OperationContext* opCtx,
                                                                          const BSONObj& config) {
     try {
         MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
-            ScopedTransaction transaction(txn, MODE_IX);
-            Lock::DBLock dbWriteLock(txn->lockState(), configDatabaseName, MODE_X);
-            Helpers::putSingleton(txn, configCollectionName, config);
+            ScopedTransaction transaction(opCtx, MODE_IX);
+            Lock::DBLock dbWriteLock(opCtx->lockState(), configDatabaseName, MODE_X);
+            Helpers::putSingleton(opCtx, configCollectionName, config);
             return Status::OK();
         }
-        MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "save replica set config", configCollectionName);
+        MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "save replica set config", configCollectionName);
     } catch (const DBException& ex) {
         return ex.toStatus();
     }
 }
 
 StatusWith<LastVote> ReplicationCoordinatorExternalStateImpl::loadLocalLastVoteDocument(
-    OperationContext* txn) {
+    OperationContext* opCtx) {
     try {
         MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
             BSONObj lastVoteObj;
-            if (!Helpers::getSingleton(txn, lastVoteCollectionName, lastVoteObj)) {
+            if (!Helpers::getSingleton(opCtx, lastVoteCollectionName, lastVoteObj)) {
                 return StatusWith<LastVote>(ErrorCodes::NoMatchingDocument,
                                             str::stream()
                                                 << "Did not find replica set lastVote document in "
@@ -537,41 +537,41 @@ StatusWith<LastVote> ReplicationCoordinatorExternalStateImpl::loadLocalLastVoteD
             return LastVote::readFromLastVote(lastVoteObj);
         }
         MONGO_WRITE_CONFLICT_RETRY_LOOP_END(
-            txn, "load replica set lastVote", lastVoteCollectionName);
+            opCtx, "load replica set lastVote", lastVoteCollectionName);
     } catch (const DBException& ex) {
         return StatusWith<LastVote>(ex.toStatus());
     }
 }
 
 Status ReplicationCoordinatorExternalStateImpl::storeLocalLastVoteDocument(
-    OperationContext* txn, const LastVote& lastVote) {
+    OperationContext* opCtx, const LastVote& lastVote) {
     BSONObj lastVoteObj = lastVote.toBSON();
     try {
         MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
-            ScopedTransaction transaction(txn, MODE_IX);
-            Lock::DBLock dbWriteLock(txn->lockState(), lastVoteDatabaseName, MODE_X);
+            ScopedTransaction transaction(opCtx, MODE_IX);
+            Lock::DBLock dbWriteLock(opCtx->lockState(), lastVoteDatabaseName, MODE_X);
 
             // If there is no last vote document, we want to store one. Otherwise, we only want to
             // replace it if the new last vote document would have a higher term. We both check
             // the term of the current last vote document and insert the new document under the
             // DBLock to synchronize the two operations.
             BSONObj result;
-            bool exists = Helpers::getSingleton(txn, lastVoteCollectionName, result);
+            bool exists = Helpers::getSingleton(opCtx, lastVoteCollectionName, result);
             if (!exists) {
-                Helpers::putSingleton(txn, lastVoteCollectionName, lastVoteObj);
+                Helpers::putSingleton(opCtx, lastVoteCollectionName, lastVoteObj);
             } else {
                 StatusWith<LastVote> oldLastVoteDoc = LastVote::readFromLastVote(result);
                 if (!oldLastVoteDoc.isOK()) {
                     return oldLastVoteDoc.getStatus();
                 }
                 if (lastVote.getTerm() > oldLastVoteDoc.getValue().getTerm()) {
-                    Helpers::putSingleton(txn, lastVoteCollectionName, lastVoteObj);
+                    Helpers::putSingleton(opCtx, lastVoteCollectionName, lastVoteObj);
                 }
             }
         }
         MONGO_WRITE_CONFLICT_RETRY_LOOP_END(
-            txn, "save replica set lastVote", lastVoteCollectionName);
-        txn->recoveryUnit()->waitUntilDurable();
+            opCtx, "save replica set lastVote", lastVoteCollectionName);
+        opCtx->recoveryUnit()->waitUntilDurable();
         return Status::OK();
     } catch (const DBException& ex) {
         return ex.toStatus();
@@ -583,18 +583,18 @@ void ReplicationCoordinatorExternalStateImpl::setGlobalTimestamp(ServiceContext*
     setNewTimestamp(ctx, newTime);
 }
 
-void ReplicationCoordinatorExternalStateImpl::cleanUpLastApplyBatch(OperationContext* txn) {
-    if (_storageInterface->getInitialSyncFlag(txn)) {
+void ReplicationCoordinatorExternalStateImpl::cleanUpLastApplyBatch(OperationContext* opCtx) {
+    if (_storageInterface->getInitialSyncFlag(opCtx)) {
         return;  // Initial Sync will take over so no cleanup is needed.
     }
 
     // This initializes the minvalid document with a null "ts" because older versions (<=3.2)
     // get angry if the minValid document is present but doesn't have a "ts" field.
     // Consider removing this once we no longer need to support downgrading to 3.2.
-    _storageInterface->setMinValidToAtLeast(txn, {});
+    _storageInterface->setMinValidToAtLeast(opCtx, {});
 
-    const auto deleteFromPoint = _storageInterface->getOplogDeleteFromPoint(txn);
-    const auto appliedThrough = _storageInterface->getAppliedThrough(txn);
+    const auto deleteFromPoint = _storageInterface->getOplogDeleteFromPoint(opCtx);
+    const auto appliedThrough = _storageInterface->getAppliedThrough(opCtx);
 
     const bool needToDeleteEndOfOplog = !deleteFromPoint.isNull() &&
         // This version should never have a non-null deleteFromPoint with a null appliedThrough.
@@ -609,9 +609,9 @@ void ReplicationCoordinatorExternalStateImpl::cleanUpLastApplyBatch(OperationCon
         !(appliedThrough.getTimestamp() >= deleteFromPoint);
     if (needToDeleteEndOfOplog) {
         log() << "Removing unapplied entries starting at: " << deleteFromPoint;
-        truncateOplogTo(txn, deleteFromPoint);
+        truncateOplogTo(opCtx, deleteFromPoint);
     }
-    _storageInterface->setOplogDeleteFromPoint(txn, {});  // clear the deleteFromPoint
+    _storageInterface->setOplogDeleteFromPoint(opCtx, {});  // clear the deleteFromPoint
 
     if (appliedThrough.isNull()) {
         // No follow-up work to do.
@@ -620,7 +620,7 @@ void ReplicationCoordinatorExternalStateImpl::cleanUpLastApplyBatch(OperationCon
 
     // Check if we have any unapplied ops in our oplog. It is important that this is done after
     // deleting the ragged end of the oplog.
-    const auto topOfOplog = fassertStatusOK(40290, loadLastOpTime(txn));
+    const auto topOfOplog = fassertStatusOK(40290, loadLastOpTime(opCtx));
     if (appliedThrough == topOfOplog) {
         return;  // We've applied all the valid oplog we have.
     } else if (appliedThrough > topOfOplog) {
@@ -632,7 +632,7 @@ void ReplicationCoordinatorExternalStateImpl::cleanUpLastApplyBatch(OperationCon
     log() << "Replaying stored operations from " << appliedThrough << " (exclusive) to "
           << topOfOplog << " (inclusive).";
 
-    DBDirectClient db(txn);
+    DBDirectClient db(opCtx);
     auto cursor = db.query(rsOplogName,
                            QUERY("ts" << BSON("$gte" << appliedThrough.getTimestamp())),
                            /*batchSize*/ 0,
@@ -658,28 +658,29 @@ void ReplicationCoordinatorExternalStateImpl::cleanUpLastApplyBatch(OperationCon
     }
 
     // Apply remaining ops one at at time, but don't log them because they are already logged.
-    const bool wereWritesReplicated = txn->writesAreReplicated();
-    ON_BLOCK_EXIT([&] { txn->setReplicatedWrites(wereWritesReplicated); });
-    txn->setReplicatedWrites(false);
+    const bool wereWritesReplicated = opCtx->writesAreReplicated();
+    ON_BLOCK_EXIT([&] { opCtx->setReplicatedWrites(wereWritesReplicated); });
+    opCtx->setReplicatedWrites(false);
 
     while (cursor->more()) {
         auto entry = cursor->nextSafe();
-        fassertStatusOK(40294, SyncTail::syncApply(txn, entry, true));
+        fassertStatusOK(40294, SyncTail::syncApply(opCtx, entry, true));
         _storageInterface->setAppliedThrough(
-            txn, fassertStatusOK(40295, OpTime::parseFromOplogEntry(entry)));
+            opCtx, fassertStatusOK(40295, OpTime::parseFromOplogEntry(entry)));
     }
 }
 
-StatusWith<OpTime> ReplicationCoordinatorExternalStateImpl::loadLastOpTime(OperationContext* txn) {
+StatusWith<OpTime> ReplicationCoordinatorExternalStateImpl::loadLastOpTime(
+    OperationContext* opCtx) {
     // TODO: handle WriteConflictExceptions below
     try {
         // If we are doing an initial sync do not read from the oplog.
-        if (_storageInterface->getInitialSyncFlag(txn)) {
+        if (_storageInterface->getInitialSyncFlag(opCtx)) {
             return {ErrorCodes::InitialSyncFailure, "In the middle of an initial sync."};
         }
 
         BSONObj oplogEntry;
-        if (!Helpers::getLast(txn, rsOplogName.c_str(), oplogEntry)) {
+        if (!Helpers::getLast(opCtx, rsOplogName.c_str(), oplogEntry)) {
             return StatusWith<OpTime>(ErrorCodes::NoMatchingDocument,
                                       str::stream() << "Did not find any entries in "
                                                     << rsOplogName);
@@ -711,17 +712,17 @@ bool ReplicationCoordinatorExternalStateImpl::isSelf(const HostAndPort& host, Se
 }
 
 HostAndPort ReplicationCoordinatorExternalStateImpl::getClientHostAndPort(
-    const OperationContext* txn) {
-    return HostAndPort(txn->getClient()->clientAddress(true));
+    const OperationContext* opCtx) {
+    return HostAndPort(opCtx->getClient()->clientAddress(true));
 }
 
 void ReplicationCoordinatorExternalStateImpl::closeConnections() {
     getGlobalServiceContext()->getTransportLayer()->endAllSessions(transport::Session::kKeepOpen);
 }
 
-void ReplicationCoordinatorExternalStateImpl::killAllUserOperations(OperationContext* txn) {
-    ServiceContext* environment = txn->getServiceContext();
-    environment->killAllUserOperations(txn, ErrorCodes::InterruptedDueToReplStateChange);
+void ReplicationCoordinatorExternalStateImpl::killAllUserOperations(OperationContext* opCtx) {
+    ServiceContext* environment = opCtx->getServiceContext();
+    environment->killAllUserOperations(opCtx, ErrorCodes::InterruptedDueToReplStateChange);
 }
 
 void ReplicationCoordinatorExternalStateImpl::shardingOnStepDownHook() {
@@ -733,8 +734,8 @@ void ReplicationCoordinatorExternalStateImpl::shardingOnStepDownHook() {
 }
 
 void ReplicationCoordinatorExternalStateImpl::_shardingOnTransitionToPrimaryHook(
-    OperationContext* txn) {
-    auto status = ShardingStateRecovery::recover(txn);
+    OperationContext* opCtx) {
+    auto status = ShardingStateRecovery::recover(opCtx);
 
     if (ErrorCodes::isShutdownError(status.code())) {
         // Note: callers of this method don't expect exceptions, so throw only unexpected fatal
@@ -745,7 +746,7 @@ void ReplicationCoordinatorExternalStateImpl::_shardingOnTransitionToPrimaryHook
     fassertStatusOK(40107, status);
 
     if (serverGlobalParams.clusterRole == ClusterRole::ConfigServer) {
-        status = Grid::get(txn)->catalogManager()->initializeConfigDatabaseIfNeeded(txn);
+        status = Grid::get(opCtx)->catalogManager()->initializeConfigDatabaseIfNeeded(opCtx);
         if (!status.isOK() && status != ErrorCodes::AlreadyInitialized) {
             if (ErrorCodes::isShutdownError(status.code())) {
                 // Don't fassert if we're mid-shutdown, let the shutdown happen gracefully.
@@ -768,8 +769,8 @@ void ReplicationCoordinatorExternalStateImpl::_shardingOnTransitionToPrimaryHook
             // Since we *just* wrote the cluster ID to the config.version document (via
             // ShardingCatalogManager::initializeConfigDatabaseIfNeeded), this should always
             // succeed.
-            status = ClusterIdentityLoader::get(txn)->loadClusterId(
-                txn, repl::ReadConcernLevel::kLocalReadConcern);
+            status = ClusterIdentityLoader::get(opCtx)->loadClusterId(
+                opCtx, repl::ReadConcernLevel::kLocalReadConcern);
 
             if (ErrorCodes::isShutdownError(status.code())) {
                 // Don't fassert if we're mid-shutdown, let the shutdown happen gracefully.
@@ -780,20 +781,20 @@ void ReplicationCoordinatorExternalStateImpl::_shardingOnTransitionToPrimaryHook
         }
 
         // Free any leftover locks from previous instantiations.
-        auto distLockManager = Grid::get(txn)->catalogClient(txn)->getDistLockManager();
-        distLockManager->unlockAll(txn, distLockManager->getProcessID());
+        auto distLockManager = Grid::get(opCtx)->catalogClient(opCtx)->getDistLockManager();
+        distLockManager->unlockAll(opCtx, distLockManager->getProcessID());
 
         // If this is a config server node becoming a primary, start the balancer
-        Balancer::get(txn)->initiateBalancer(txn);
+        Balancer::get(opCtx)->initiateBalancer(opCtx);
 
         // Generate and upsert random 20 byte key for the LogicalClock's TimeProofService.
         // TODO: SERVER-27768
 
-    } else if (ShardingState::get(txn)->enabled()) {
+    } else if (ShardingState::get(opCtx)->enabled()) {
         const auto configsvrConnStr =
-            Grid::get(txn)->shardRegistry()->getConfigShard()->getConnString();
-        auto status = ShardingState::get(txn)->updateShardIdentityConfigString(
-            txn, configsvrConnStr.toString());
+            Grid::get(opCtx)->shardRegistry()->getConfigShard()->getConnString();
+        auto status = ShardingState::get(opCtx)->updateShardIdentityConfigString(
+            opCtx, configsvrConnStr.toString());
         if (!status.isOK()) {
             warning() << "error encountered while trying to update config connection string to "
                       << configsvrConnStr << causedBy(status);
@@ -802,7 +803,7 @@ void ReplicationCoordinatorExternalStateImpl::_shardingOnTransitionToPrimaryHook
 
     // There is a slight chance that some stale metadata might have been loaded before the latest
     // optime has been recovered, so throw out everything that we have up to now
-    ShardingState::get(txn)->markCollectionsNotShardedAtStepdown();
+    ShardingState::get(opCtx)->markCollectionsNotShardedAtStepdown();
 }
 
 void ReplicationCoordinatorExternalStateImpl::signalApplierToChooseNewSyncSource() {
@@ -826,7 +827,7 @@ void ReplicationCoordinatorExternalStateImpl::startProducerIfStopped() {
     }
 }
 
-void ReplicationCoordinatorExternalStateImpl::_dropAllTempCollections(OperationContext* txn) {
+void ReplicationCoordinatorExternalStateImpl::_dropAllTempCollections(OperationContext* opCtx) {
     std::vector<std::string> dbNames;
     StorageEngine* storageEngine = getGlobalServiceContext()->getGlobalStorageEngine();
     storageEngine->listDatabases(&dbNames);
@@ -837,12 +838,12 @@ void ReplicationCoordinatorExternalStateImpl::_dropAllTempCollections(OperationC
         if (*it == "local")
             continue;
         LOG(2) << "Removing temporary collections from " << *it;
-        Database* db = dbHolder().get(txn, *it);
+        Database* db = dbHolder().get(opCtx, *it);
         // Since we must be holding the global lock during this function, if listDatabases
         // returned this dbname, we should be able to get a reference to it - it can't have
         // been dropped.
         invariant(db);
-        db->clearTmpCollections(txn);
+        db->clearTmpCollections(opCtx);
     }
 }
 
@@ -857,11 +858,11 @@ void ReplicationCoordinatorExternalStateImpl::updateCommittedSnapshot(SnapshotNa
     manager->setCommittedSnapshot(newCommitPoint);
 }
 
-void ReplicationCoordinatorExternalStateImpl::createSnapshot(OperationContext* txn,
+void ReplicationCoordinatorExternalStateImpl::createSnapshot(OperationContext* opCtx,
                                                              SnapshotName name) {
     auto manager = getGlobalServiceContext()->getGlobalStorageEngine()->getSnapshotManager();
     invariant(manager);  // This should never be called if there is no SnapshotManager.
-    manager->createSnapshot(txn, name);
+    manager->createSnapshot(opCtx, name);
 }
 
 void ReplicationCoordinatorExternalStateImpl::forceSnapshotCreation() {
@@ -882,18 +883,18 @@ double ReplicationCoordinatorExternalStateImpl::getElectionTimeoutOffsetLimitFra
 }
 
 bool ReplicationCoordinatorExternalStateImpl::isReadCommittedSupportedByStorageEngine(
-    OperationContext* txn) const {
-    auto storageEngine = txn->getServiceContext()->getGlobalStorageEngine();
+    OperationContext* opCtx) const {
+    auto storageEngine = opCtx->getServiceContext()->getGlobalStorageEngine();
     // This should never be called if the storage engine has not been initialized.
     invariant(storageEngine);
     return storageEngine->getSnapshotManager();
 }
 
 StatusWith<OpTime> ReplicationCoordinatorExternalStateImpl::multiApply(
-    OperationContext* txn,
+    OperationContext* opCtx,
     MultiApplier::Operations ops,
     MultiApplier::ApplyOperationFn applyOperation) {
-    return repl::multiApply(txn, _writerPool.get(), std::move(ops), applyOperation);
+    return repl::multiApply(opCtx, _writerPool.get(), std::move(ops), applyOperation);
 }
 
 Status ReplicationCoordinatorExternalStateImpl::multiSyncApply(MultiApplier::OperationPtrs* ops) {
@@ -915,20 +916,20 @@ Status ReplicationCoordinatorExternalStateImpl::multiInitialSyncApply(
 }
 
 std::unique_ptr<OplogBuffer> ReplicationCoordinatorExternalStateImpl::makeInitialSyncOplogBuffer(
-    OperationContext* txn) const {
+    OperationContext* opCtx) const {
     if (initialSyncOplogBuffer == kCollectionOplogBufferName) {
         invariant(initialSyncOplogBufferPeekCacheSize >= 0);
         OplogBufferCollection::Options options;
         options.peekCacheSize = std::size_t(initialSyncOplogBufferPeekCacheSize);
         return stdx::make_unique<OplogBufferProxy>(
-            stdx::make_unique<OplogBufferCollection>(StorageInterface::get(txn), options));
+            stdx::make_unique<OplogBufferCollection>(StorageInterface::get(opCtx), options));
     } else {
         return stdx::make_unique<OplogBufferBlockingQueue>();
     }
 }
 
 std::unique_ptr<OplogBuffer> ReplicationCoordinatorExternalStateImpl::makeSteadyStateOplogBuffer(
-    OperationContext* txn) const {
+    OperationContext* opCtx) const {
     return stdx::make_unique<OplogBufferBlockingQueue>();
 }
 
diff --git a/src/mongo/db/repl/replication_coordinator_external_state_impl.h b/src/mongo/db/repl/replication_coordinator_external_state_impl.h
index b0d9487eaaf..16c5adf0be6 100644
--- a/src/mongo/db/repl/replication_coordinator_external_state_impl.h
+++ b/src/mongo/db/repl/replication_coordinator_external_state_impl.h
@@ -64,47 +64,47 @@ public:
     virtual ~ReplicationCoordinatorExternalStateImpl();
     virtual void startThreads(const ReplSettings& settings) override;
     virtual void startInitialSync(OnInitialSyncFinishedFn finished) override;
-    virtual void startSteadyStateReplication(OperationContext* txn,
+    virtual void startSteadyStateReplication(OperationContext* opCtx,
                                              ReplicationCoordinator* replCoord) override;
-    virtual void stopDataReplication(OperationContext* txn) override;
-    virtual void runOnInitialSyncThread(stdx::function<void(OperationContext* txn)> run) override;
+    virtual void stopDataReplication(OperationContext* opCtx) override;
+    virtual void runOnInitialSyncThread(stdx::function<void(OperationContext* opCtx)> run) override;
 
-    virtual bool isInitialSyncFlagSet(OperationContext* txn) override;
+    virtual bool isInitialSyncFlagSet(OperationContext* opCtx) override;
 
-    virtual void startMasterSlave(OperationContext* txn);
-    virtual void shutdown(OperationContext* txn);
+    virtual void startMasterSlave(OperationContext* opCtx);
+    virtual void shutdown(OperationContext* opCtx);
     virtual executor::TaskExecutor* getTaskExecutor() const override;
     virtual OldThreadPool* getDbWorkThreadPool() const override;
-    virtual Status runRepairOnLocalDB(OperationContext* txn) override;
-    virtual Status initializeReplSetStorage(OperationContext* txn, const BSONObj& config);
-    void onDrainComplete(OperationContext* txn) override;
-    OpTime onTransitionToPrimary(OperationContext* txn, bool isV1ElectionProtocol) override;
+    virtual Status runRepairOnLocalDB(OperationContext* opCtx) override;
+    virtual Status initializeReplSetStorage(OperationContext* opCtx, const BSONObj& config);
+    void onDrainComplete(OperationContext* opCtx) override;
+    OpTime onTransitionToPrimary(OperationContext* opCtx, bool isV1ElectionProtocol) override;
     virtual void forwardSlaveProgress();
-    virtual OID ensureMe(OperationContext* txn);
+    virtual OID ensureMe(OperationContext* opCtx);
     virtual bool isSelf(const HostAndPort& host, ServiceContext* service);
-    virtual StatusWith<BSONObj> loadLocalConfigDocument(OperationContext* txn);
-    virtual Status storeLocalConfigDocument(OperationContext* txn, const BSONObj& config);
-    virtual StatusWith<LastVote> loadLocalLastVoteDocument(OperationContext* txn);
-    virtual Status storeLocalLastVoteDocument(OperationContext* txn, const LastVote& lastVote);
+    virtual StatusWith<BSONObj> loadLocalConfigDocument(OperationContext* opCtx);
+    virtual Status storeLocalConfigDocument(OperationContext* opCtx, const BSONObj& config);
+    virtual StatusWith<LastVote> loadLocalLastVoteDocument(OperationContext* opCtx);
+    virtual Status storeLocalLastVoteDocument(OperationContext* opCtx, const LastVote& lastVote);
     virtual void setGlobalTimestamp(ServiceContext* service, const Timestamp& newTime);
-    virtual StatusWith<OpTime> loadLastOpTime(OperationContext* txn);
-    virtual void cleanUpLastApplyBatch(OperationContext* txn);
-    virtual HostAndPort getClientHostAndPort(const OperationContext* txn);
+    virtual StatusWith<OpTime> loadLastOpTime(OperationContext* opCtx);
+    virtual void cleanUpLastApplyBatch(OperationContext* opCtx);
+    virtual HostAndPort getClientHostAndPort(const OperationContext* opCtx);
     virtual void closeConnections();
-    virtual void killAllUserOperations(OperationContext* txn);
+    virtual void killAllUserOperations(OperationContext* opCtx);
     virtual void shardingOnStepDownHook();
     virtual void signalApplierToChooseNewSyncSource();
     virtual void stopProducer();
     virtual void startProducerIfStopped();
     void dropAllSnapshots() final;
     void updateCommittedSnapshot(SnapshotName newCommitPoint) final;
-    void createSnapshot(OperationContext* txn, SnapshotName name) final;
+    void createSnapshot(OperationContext* opCtx, SnapshotName name) final;
     void forceSnapshotCreation() final;
     virtual bool snapshotsEnabled() const;
     virtual void notifyOplogMetadataWaiters();
     virtual double getElectionTimeoutOffsetLimitFraction() const;
-    virtual bool isReadCommittedSupportedByStorageEngine(OperationContext* txn) const;
-    virtual StatusWith<OpTime> multiApply(OperationContext* txn,
+    virtual bool isReadCommittedSupportedByStorageEngine(OperationContext* opCtx) const;
+    virtual StatusWith<OpTime> multiApply(OperationContext* opCtx,
                                           MultiApplier::Operations ops,
                                           MultiApplier::ApplyOperationFn applyOperation) override;
     virtual Status multiSyncApply(MultiApplier::OperationPtrs* ops) override;
@@ -112,9 +112,9 @@ public:
                                          const HostAndPort& source,
                                          AtomicUInt32* fetchCount) override;
     virtual std::unique_ptr<OplogBuffer> makeInitialSyncOplogBuffer(
-        OperationContext* txn) const override;
+        OperationContext* opCtx) const override;
     virtual std::unique_ptr<OplogBuffer> makeSteadyStateOplogBuffer(
-        OperationContext* txn) const override;
+        OperationContext* opCtx) const override;
     virtual bool shouldUseDataReplicatorInitialSync() const override;
     virtual std::size_t getOplogFetcherMaxFetcherRestarts() const override;
 
@@ -130,7 +130,7 @@ private:
     /**
      * Stops data replication and returns with 'lock' locked.
      */
-    void _stopDataReplication_inlock(OperationContext* txn, UniqueLock* lock);
+    void _stopDataReplication_inlock(OperationContext* opCtx, UniqueLock* lock);
 
     /**
      * Called when the instance transitions to primary in order to notify a potentially sharded host
@@ -138,15 +138,15 @@ private:
      *
      * Throws on errors.
      */
-    void _shardingOnTransitionToPrimaryHook(OperationContext* txn);
+    void _shardingOnTransitionToPrimaryHook(OperationContext* opCtx);
 
     /**
     * Drops all temporary collections on all databases except "local".
     *
     * The implementation may assume that the caller has acquired the global exclusive lock
-    * for "txn".
+    * for "opCtx".
     */
-    void _dropAllTempCollections(OperationContext* txn);
+    void _dropAllTempCollections(OperationContext* opCtx);
 
     // Guards starting threads and setting _startedThreads
     stdx::mutex _threadMutex;
diff --git a/src/mongo/db/repl/replication_coordinator_external_state_mock.cpp b/src/mongo/db/repl/replication_coordinator_external_state_mock.cpp
index 274806326a6..87e0e8c6af6 100644
--- a/src/mongo/db/repl/replication_coordinator_external_state_mock.cpp
+++ b/src/mongo/db/repl/replication_coordinator_external_state_mock.cpp
@@ -61,7 +61,7 @@ ReplicationCoordinatorExternalStateMock::ReplicationCoordinatorExternalStateMock
 ReplicationCoordinatorExternalStateMock::~ReplicationCoordinatorExternalStateMock() {}
 
 void ReplicationCoordinatorExternalStateMock::runOnInitialSyncThread(
-    stdx::function<void(OperationContext* txn)> run) {
+    stdx::function<void(OperationContext* opCtx)> run) {
     log() << "not running initial sync during test.";
 }
 
@@ -83,13 +83,13 @@ void ReplicationCoordinatorExternalStateMock::stopDataReplication(OperationConte
 
 void ReplicationCoordinatorExternalStateMock::startMasterSlave(OperationContext*) {}
 
-Status ReplicationCoordinatorExternalStateMock::runRepairOnLocalDB(OperationContext* txn) {
+Status ReplicationCoordinatorExternalStateMock::runRepairOnLocalDB(OperationContext* opCtx) {
     return Status::OK();
 }
 
-Status ReplicationCoordinatorExternalStateMock::initializeReplSetStorage(OperationContext* txn,
+Status ReplicationCoordinatorExternalStateMock::initializeReplSetStorage(OperationContext* opCtx,
                                                                          const BSONObj& config) {
-    return storeLocalConfigDocument(txn, config);
+    return storeLocalConfigDocument(opCtx, config);
 }
 
 void ReplicationCoordinatorExternalStateMock::shutdown(OperationContext*) {}
@@ -118,7 +118,7 @@ void ReplicationCoordinatorExternalStateMock::addSelf(const HostAndPort& host) {
 }
 
 HostAndPort ReplicationCoordinatorExternalStateMock::getClientHostAndPort(
-    const OperationContext* txn) {
+    const OperationContext* opCtx) {
     return _clientHostAndPort;
 }
 
@@ -128,11 +128,11 @@ void ReplicationCoordinatorExternalStateMock::setClientHostAndPort(
 }
 
 StatusWith<BSONObj> ReplicationCoordinatorExternalStateMock::loadLocalConfigDocument(
-    OperationContext* txn) {
+    OperationContext* opCtx) {
     return _localRsConfigDocument;
 }
 
-Status ReplicationCoordinatorExternalStateMock::storeLocalConfigDocument(OperationContext* txn,
+Status ReplicationCoordinatorExternalStateMock::storeLocalConfigDocument(OperationContext* opCtx,
                                                                          const BSONObj& config) {
     {
         stdx::unique_lock<stdx::mutex> lock(_shouldHangConfigMutex);
@@ -153,12 +153,12 @@ void ReplicationCoordinatorExternalStateMock::setLocalConfigDocument(
 }
 
 StatusWith<LastVote> ReplicationCoordinatorExternalStateMock::loadLocalLastVoteDocument(
-    OperationContext* txn) {
+    OperationContext* opCtx) {
     return _localRsLastVoteDocument;
 }
 
 Status ReplicationCoordinatorExternalStateMock::storeLocalLastVoteDocument(
-    OperationContext* txn, const LastVote& lastVote) {
+    OperationContext* opCtx, const LastVote& lastVote) {
     {
         stdx::unique_lock<stdx::mutex> lock(_shouldHangLastVoteMutex);
         while (_storeLocalLastVoteDocumentShouldHang) {
@@ -180,9 +180,10 @@ void ReplicationCoordinatorExternalStateMock::setLocalLastVoteDocument(
 void ReplicationCoordinatorExternalStateMock::setGlobalTimestamp(ServiceContext* service,
                                                                  const Timestamp& newTime) {}
 
-void ReplicationCoordinatorExternalStateMock::cleanUpLastApplyBatch(OperationContext* txn) {}
+void ReplicationCoordinatorExternalStateMock::cleanUpLastApplyBatch(OperationContext* opCtx) {}
 
-StatusWith<OpTime> ReplicationCoordinatorExternalStateMock::loadLastOpTime(OperationContext* txn) {
+StatusWith<OpTime> ReplicationCoordinatorExternalStateMock::loadLastOpTime(
+    OperationContext* opCtx) {
     return _lastOpTime;
 }
 
@@ -222,7 +223,7 @@ void ReplicationCoordinatorExternalStateMock::closeConnections() {
     _connectionsClosed = true;
 }
 
-void ReplicationCoordinatorExternalStateMock::killAllUserOperations(OperationContext* txn) {}
+void ReplicationCoordinatorExternalStateMock::killAllUserOperations(OperationContext* opCtx) {}
 
 void ReplicationCoordinatorExternalStateMock::shardingOnStepDownHook() {}
 
@@ -237,7 +238,7 @@ void ReplicationCoordinatorExternalStateMock::dropAllSnapshots() {}
 void ReplicationCoordinatorExternalStateMock::updateCommittedSnapshot(SnapshotName newCommitPoint) {
 }
 
-void ReplicationCoordinatorExternalStateMock::createSnapshot(OperationContext* txn,
+void ReplicationCoordinatorExternalStateMock::createSnapshot(OperationContext* opCtx,
                                                              SnapshotName name) {}
 
 void ReplicationCoordinatorExternalStateMock::forceSnapshotCreation() {}
@@ -257,7 +258,7 @@ double ReplicationCoordinatorExternalStateMock::getElectionTimeoutOffsetLimitFra
 }
 
 bool ReplicationCoordinatorExternalStateMock::isReadCommittedSupportedByStorageEngine(
-    OperationContext* txn) const {
+    OperationContext* opCtx) const {
     return _isReadCommittedSupported;
 }
 
@@ -276,12 +277,12 @@ Status ReplicationCoordinatorExternalStateMock::multiInitialSyncApply(
 }
 
 std::unique_ptr<OplogBuffer> ReplicationCoordinatorExternalStateMock::makeInitialSyncOplogBuffer(
-    OperationContext* txn) const {
+    OperationContext* opCtx) const {
     return stdx::make_unique<OplogBufferBlockingQueue>();
 }
 
 std::unique_ptr<OplogBuffer> ReplicationCoordinatorExternalStateMock::makeSteadyStateOplogBuffer(
-    OperationContext* txn) const {
+    OperationContext* opCtx) const {
     return stdx::make_unique<OplogBufferBlockingQueue>();
 }
 
@@ -297,9 +298,9 @@ void ReplicationCoordinatorExternalStateMock::setIsReadCommittedEnabled(bool val
     _isReadCommittedSupported = val;
 }
 
-void ReplicationCoordinatorExternalStateMock::onDrainComplete(OperationContext* txn) {}
+void ReplicationCoordinatorExternalStateMock::onDrainComplete(OperationContext* opCtx) {}
 
-OpTime ReplicationCoordinatorExternalStateMock::onTransitionToPrimary(OperationContext* txn,
+OpTime ReplicationCoordinatorExternalStateMock::onTransitionToPrimary(OperationContext* opCtx,
                                                                       bool isV1ElectionProtocol) {
     if (isV1ElectionProtocol) {
         _lastOpTime = OpTime(Timestamp(1, 0), 1);
diff --git a/src/mongo/db/repl/replication_coordinator_external_state_mock.h b/src/mongo/db/repl/replication_coordinator_external_state_mock.h
index 1b575ede697..c33044a2510 100644
--- a/src/mongo/db/repl/replication_coordinator_external_state_mock.h
+++ b/src/mongo/db/repl/replication_coordinator_external_state_mock.h
@@ -58,46 +58,46 @@ public:
     virtual ~ReplicationCoordinatorExternalStateMock();
     virtual void startThreads(const ReplSettings& settings) override;
     virtual void startInitialSync(OnInitialSyncFinishedFn finished) override;
-    virtual void startSteadyStateReplication(OperationContext* txn,
+    virtual void startSteadyStateReplication(OperationContext* opCtx,
                                              ReplicationCoordinator* replCoord) override;
-    virtual void stopDataReplication(OperationContext* txn) override;
-    virtual void runOnInitialSyncThread(stdx::function<void(OperationContext* txn)> run) override;
-    virtual bool isInitialSyncFlagSet(OperationContext* txn) override;
+    virtual void stopDataReplication(OperationContext* opCtx) override;
+    virtual void runOnInitialSyncThread(stdx::function<void(OperationContext* opCtx)> run) override;
+    virtual bool isInitialSyncFlagSet(OperationContext* opCtx) override;
 
     virtual void startMasterSlave(OperationContext*);
-    virtual void shutdown(OperationContext* txn);
+    virtual void shutdown(OperationContext* opCtx);
     virtual executor::TaskExecutor* getTaskExecutor() const override;
     virtual OldThreadPool* getDbWorkThreadPool() const override;
-    virtual Status runRepairOnLocalDB(OperationContext* txn) override;
-    virtual Status initializeReplSetStorage(OperationContext* txn, const BSONObj& config);
-    void onDrainComplete(OperationContext* txn) override;
-    OpTime onTransitionToPrimary(OperationContext* txn, bool isV1ElectionProtocol) override;
+    virtual Status runRepairOnLocalDB(OperationContext* opCtx) override;
+    virtual Status initializeReplSetStorage(OperationContext* opCtx, const BSONObj& config);
+    void onDrainComplete(OperationContext* opCtx) override;
+    OpTime onTransitionToPrimary(OperationContext* opCtx, bool isV1ElectionProtocol) override;
     virtual void forwardSlaveProgress();
     virtual OID ensureMe(OperationContext*);
     virtual bool isSelf(const HostAndPort& host, ServiceContext* service);
-    virtual HostAndPort getClientHostAndPort(const OperationContext* txn);
-    virtual StatusWith<BSONObj> loadLocalConfigDocument(OperationContext* txn);
-    virtual Status storeLocalConfigDocument(OperationContext* txn, const BSONObj& config);
-    virtual StatusWith<LastVote> loadLocalLastVoteDocument(OperationContext* txn);
-    virtual Status storeLocalLastVoteDocument(OperationContext* txn, const LastVote& lastVote);
+    virtual HostAndPort getClientHostAndPort(const OperationContext* opCtx);
+    virtual StatusWith<BSONObj> loadLocalConfigDocument(OperationContext* opCtx);
+    virtual Status storeLocalConfigDocument(OperationContext* opCtx, const BSONObj& config);
+    virtual StatusWith<LastVote> loadLocalLastVoteDocument(OperationContext* opCtx);
+    virtual Status storeLocalLastVoteDocument(OperationContext* opCtx, const LastVote& lastVote);
     virtual void setGlobalTimestamp(ServiceContext* service, const Timestamp& newTime);
-    virtual StatusWith<OpTime> loadLastOpTime(OperationContext* txn);
-    virtual void cleanUpLastApplyBatch(OperationContext* txn);
+    virtual StatusWith<OpTime> loadLastOpTime(OperationContext* opCtx);
+    virtual void cleanUpLastApplyBatch(OperationContext* opCtx);
     virtual void closeConnections();
-    virtual void killAllUserOperations(OperationContext* txn);
+    virtual void killAllUserOperations(OperationContext* opCtx);
     virtual void shardingOnStepDownHook();
     virtual void signalApplierToChooseNewSyncSource();
     virtual void stopProducer();
     virtual void startProducerIfStopped();
     virtual void dropAllSnapshots();
     virtual void updateCommittedSnapshot(SnapshotName newCommitPoint);
-    virtual void createSnapshot(OperationContext* txn, SnapshotName name);
+    virtual void createSnapshot(OperationContext* opCtx, SnapshotName name);
     virtual void forceSnapshotCreation();
     virtual bool snapshotsEnabled() const;
     virtual void notifyOplogMetadataWaiters();
     virtual double getElectionTimeoutOffsetLimitFraction() const;
-    virtual bool isReadCommittedSupportedByStorageEngine(OperationContext* txn) const;
-    virtual StatusWith<OpTime> multiApply(OperationContext* txn,
+    virtual bool isReadCommittedSupportedByStorageEngine(OperationContext* opCtx) const;
+    virtual StatusWith<OpTime> multiApply(OperationContext* opCtx,
                                           MultiApplier::Operations ops,
                                           MultiApplier::ApplyOperationFn applyOperation) override;
     virtual Status multiSyncApply(MultiApplier::OperationPtrs* ops) override;
@@ -105,9 +105,9 @@ public:
                                          const HostAndPort& source,
                                          AtomicUInt32* fetchCount) override;
     virtual std::unique_ptr<OplogBuffer> makeInitialSyncOplogBuffer(
-        OperationContext* txn) const override;
+        OperationContext* opCtx) const override;
     virtual std::unique_ptr<OplogBuffer> makeSteadyStateOplogBuffer(
-        OperationContext* txn) const override;
+        OperationContext* opCtx) const override;
     virtual bool shouldUseDataReplicatorInitialSync() const override;
     virtual std::size_t getOplogFetcherMaxFetcherRestarts() const override;
 
diff --git a/src/mongo/db/repl/replication_coordinator_impl.cpp b/src/mongo/db/repl/replication_coordinator_impl.cpp
index 8ad99d7e24a..a238cee74de 100644
--- a/src/mongo/db/repl/replication_coordinator_impl.cpp
+++ b/src/mongo/db/repl/replication_coordinator_impl.cpp
@@ -411,8 +411,8 @@ void ReplicationCoordinatorImpl::appendConnectionStats(executor::ConnectionPoolS
     _replExecutor.appendConnectionStats(stats);
 }
 
-bool ReplicationCoordinatorImpl::_startLoadLocalConfig(OperationContext* txn) {
-    StatusWith<LastVote> lastVote = _externalState->loadLocalLastVoteDocument(txn);
+bool ReplicationCoordinatorImpl::_startLoadLocalConfig(OperationContext* opCtx) {
+    StatusWith<LastVote> lastVote = _externalState->loadLocalLastVoteDocument(opCtx);
     if (!lastVote.isOK()) {
         if (lastVote.getStatus() == ErrorCodes::NoMatchingDocument) {
             log() << "Did not find local voted for document at startup.";
@@ -426,7 +426,7 @@ bool ReplicationCoordinatorImpl::_startLoadLocalConfig(OperationContext* txn) {
         _topCoord->loadLastVote(lastVote.getValue());
     }
 
-    StatusWith<BSONObj> cfg = _externalState->loadLocalConfigDocument(txn);
+    StatusWith<BSONObj> cfg = _externalState->loadLocalConfigDocument(opCtx);
     if (!cfg.isOK()) {
         log() << "Did not find local replica set configuration document at startup;  "
               << cfg.getStatus();
@@ -443,8 +443,8 @@ bool ReplicationCoordinatorImpl::_startLoadLocalConfig(OperationContext* txn) {
     }
 
     // Read the last op from the oplog after cleaning up any partially applied batches.
-    _externalState->cleanUpLastApplyBatch(txn);
-    auto lastOpTimeStatus = _externalState->loadLastOpTime(txn);
+    _externalState->cleanUpLastApplyBatch(opCtx);
+    auto lastOpTimeStatus = _externalState->loadLastOpTime(opCtx);
 
     // Use a callback here, because _finishLoadLocalConfig calls isself() which requires
     // that the server's networking layer be up and running and accepting connections, which
@@ -546,12 +546,12 @@ void ReplicationCoordinatorImpl::_finishLoadLocalConfig(
     _performPostMemberStateUpdateAction(action);
     if (!isArbiter) {
         _externalState->startThreads(_settings);
-        invariant(cbData.txn);
-        _startDataReplication(cbData.txn);
+        invariant(cbData.opCtx);
+        _startDataReplication(cbData.opCtx);
     }
 }
 
-void ReplicationCoordinatorImpl::_stopDataReplication(OperationContext* txn) {
+void ReplicationCoordinatorImpl::_stopDataReplication(OperationContext* opCtx) {
     std::shared_ptr<DataReplicator> drCopy;
     {
         LockGuard lk(_mutex);
@@ -569,19 +569,20 @@ void ReplicationCoordinatorImpl::_stopDataReplication(OperationContext* txn) {
     }
     LOG(1) << "ReplicationCoordinatorImpl::_stopDataReplication calling "
               "ReplCoordExtState::stopDataReplication.";
-    _externalState->stopDataReplication(txn);
+    _externalState->stopDataReplication(opCtx);
 }
 
-void ReplicationCoordinatorImpl::_startDataReplication(OperationContext* txn,
+void ReplicationCoordinatorImpl::_startDataReplication(OperationContext* opCtx,
                                                        stdx::function<void()> startCompleted) {
     // Check to see if we need to do an initial sync.
     const auto lastOpTime = getMyLastAppliedOpTime();
-    const auto needsInitialSync = lastOpTime.isNull() || _externalState->isInitialSyncFlagSet(txn);
+    const auto needsInitialSync =
+        lastOpTime.isNull() || _externalState->isInitialSyncFlagSet(opCtx);
     if (!needsInitialSync) {
         stdx::lock_guard<stdx::mutex> lk(_mutex);
         if (!_inShutdown) {
             // Start steady replication, since we already have data.
-            _externalState->startSteadyStateReplication(txn, this);
+            _externalState->startSteadyStateReplication(opCtx, this);
         }
         return;
     }
@@ -624,9 +625,9 @@ void ReplicationCoordinatorImpl::_startDataReplication(OperationContext* txn,
                 startCompleted();
             }
             // Repair local db (to compact it).
-            auto txn = cc().makeOperationContext();
-            uassertStatusOK(_externalState->runRepairOnLocalDB(txn.get()));
-            _externalState->startSteadyStateReplication(txn.get(), this);
+            auto opCtx = cc().makeOperationContext();
+            uassertStatusOK(_externalState->runRepairOnLocalDB(opCtx.get()));
+            _externalState->startSteadyStateReplication(opCtx.get(), this);
         };
 
         std::shared_ptr<DataReplicator> drCopy;
@@ -644,7 +645,7 @@ void ReplicationCoordinatorImpl::_startDataReplication(OperationContext* txn,
             }
             // DataReplicator::startup() must be called outside lock because it uses features (eg.
             // setting the initial sync flag) which depend on the ReplicationCoordinatorImpl.
-            uassertStatusOK(drCopy->startup(txn, numInitialSyncAttempts.load()));
+            uassertStatusOK(drCopy->startup(opCtx, numInitialSyncAttempts.load()));
         } catch (...) {
             auto status = exceptionToStatus();
             log() << "Initial Sync failed to start: " << status;
@@ -655,19 +656,19 @@ void ReplicationCoordinatorImpl::_startDataReplication(OperationContext* txn,
             fassertFailedWithStatusNoTrace(40354, status);
         }
     } else {
-        _externalState->startInitialSync([this, startCompleted](OperationContext* txn) {
+        _externalState->startInitialSync([this, startCompleted](OperationContext* opCtx) {
             stdx::lock_guard<stdx::mutex> lk(_mutex);
             if (!_inShutdown) {
                 if (startCompleted) {
                     startCompleted();
                 }
-                _externalState->startSteadyStateReplication(txn, this);
+                _externalState->startSteadyStateReplication(opCtx, this);
             }
         });
     }
 }
 
-void ReplicationCoordinatorImpl::startup(OperationContext* txn) {
+void ReplicationCoordinatorImpl::startup(OperationContext* opCtx) {
     if (!isReplEnabled()) {
         stdx::lock_guard<stdx::mutex> lk(_mutex);
         _setConfigState_inlock(kConfigReplicationDisabled);
@@ -675,7 +676,7 @@ void ReplicationCoordinatorImpl::startup(OperationContext* txn) {
     }
 
     {
-        OID rid = _externalState->ensureMe(txn);
+        OID rid = _externalState->ensureMe(opCtx);
 
         stdx::lock_guard<stdx::mutex> lk(_mutex);
         fassert(18822, !_inShutdown);
@@ -687,16 +688,16 @@ void ReplicationCoordinatorImpl::startup(OperationContext* txn) {
     if (!_settings.usingReplSets()) {
         // Must be Master/Slave
         invariant(_settings.isMaster() || _settings.isSlave());
-        _externalState->startMasterSlave(txn);
+        _externalState->startMasterSlave(opCtx);
         return;
     }
 
     _replExecutor.startup();
 
     _topCoord->setStorageEngineSupportsReadCommitted(
-        _externalState->isReadCommittedSupportedByStorageEngine(txn));
+        _externalState->isReadCommittedSupportedByStorageEngine(opCtx));
 
-    bool doneLoadingConfig = _startLoadLocalConfig(txn);
+    bool doneLoadingConfig = _startLoadLocalConfig(opCtx);
     if (doneLoadingConfig) {
         // If we're not done loading the config, then the config state will be set by
         // _finishLoadLocalConfig.
@@ -706,7 +707,7 @@ void ReplicationCoordinatorImpl::startup(OperationContext* txn) {
     }
 }
 
-void ReplicationCoordinatorImpl::shutdown(OperationContext* txn) {
+void ReplicationCoordinatorImpl::shutdown(OperationContext* opCtx) {
     // Shutdown must:
     // * prevent new threads from blocking in awaitReplication
     // * wake up all existing threads blocking in awaitReplication
@@ -759,7 +760,7 @@ void ReplicationCoordinatorImpl::shutdown(OperationContext* txn) {
         drCopy->join();
         drCopy.reset();
     }
-    _externalState->shutdown(txn);
+    _externalState->shutdown(opCtx);
     _replExecutor.shutdown();
     _replExecutor.join();
 }
@@ -892,7 +893,7 @@ ReplicationCoordinator::ApplierState ReplicationCoordinatorImpl::getApplierState
     return _applierState;
 }
 
-void ReplicationCoordinatorImpl::signalDrainComplete(OperationContext* txn,
+void ReplicationCoordinatorImpl::signalDrainComplete(OperationContext* opCtx,
                                                      long long termWhenBufferIsEmpty) {
     // This logic is a little complicated in order to avoid acquiring the global exclusive lock
     // unnecessarily.  This is important because the applier may call signalDrainComplete()
@@ -918,7 +919,7 @@ void ReplicationCoordinatorImpl::signalDrainComplete(OperationContext* txn,
     // temp collection isn't introduced on the new primary before we drop all the temp collections.
 
     // When we go to drop all temp collections, we must replicate the drops.
-    invariant(txn->writesAreReplicated());
+    invariant(opCtx->writesAreReplicated());
 
     stdx::unique_lock<stdx::mutex> lk(_mutex);
     if (_applierState != ApplierState::Draining) {
@@ -926,7 +927,7 @@ void ReplicationCoordinatorImpl::signalDrainComplete(OperationContext* txn,
     }
     lk.unlock();
 
-    _externalState->onDrainComplete(txn);
+    _externalState->onDrainComplete(opCtx);
 
     if (MONGO_FAIL_POINT(transitionToPrimaryHangBeforeTakingGlobalExclusiveLock)) {
         log() << "transition to primary - "
@@ -943,8 +944,8 @@ void ReplicationCoordinatorImpl::signalDrainComplete(OperationContext* txn,
         }
     }
 
-    ScopedTransaction transaction(txn, MODE_X);
-    Lock::GlobalWrite globalWriteLock(txn->lockState());
+    ScopedTransaction transaction(opCtx, MODE_X);
+    Lock::GlobalWrite globalWriteLock(opCtx->lockState());
     lk.lock();
 
     // Exit drain mode when the buffer is empty in the current term and we're in Draining mode.
@@ -959,7 +960,7 @@ void ReplicationCoordinatorImpl::signalDrainComplete(OperationContext* txn,
     _canAcceptNonLocalWrites = true;
 
     lk.unlock();
-    _setFirstOpTimeOfMyTerm(_externalState->onTransitionToPrimary(txn, isV1ElectionProtocol()));
+    _setFirstOpTimeOfMyTerm(_externalState->onTransitionToPrimary(opCtx, isV1ElectionProtocol()));
     lk.lock();
 
     // Must calculate the commit level again because firstOpTimeOfMyTerm wasn't set when we logged
@@ -1232,11 +1233,11 @@ OpTime ReplicationCoordinatorImpl::getMyLastDurableOpTime() const {
     return _getMyLastDurableOpTime_inlock();
 }
 
-Status ReplicationCoordinatorImpl::waitUntilOpTimeForRead(OperationContext* txn,
+Status ReplicationCoordinatorImpl::waitUntilOpTimeForRead(OperationContext* opCtx,
                                                           const ReadConcernArgs& settings) {
     // We should never wait for replication if we are holding any locks, because this can
     // potentially block for long time while doing network activity.
-    if (txn->lockState()->isLocked()) {
+    if (opCtx->lockState()->isLocked()) {
         return {ErrorCodes::IllegalOperation,
                 "Waiting for replication not allowed while holding a lock"};
     }
@@ -1291,10 +1292,10 @@ Status ReplicationCoordinatorImpl::waitUntilOpTimeForRead(OperationContext* txn,
         // If we are doing a majority read concern we only need to wait for a new snapshot.
         if (isMajorityReadConcern) {
             // Wait for a snapshot that meets our needs (< targetOpTime).
-            LOG(3) << "waitUntilOpTime: waiting for a new snapshot until " << txn->getDeadline();
+            LOG(3) << "waitUntilOpTime: waiting for a new snapshot until " << opCtx->getDeadline();
 
             auto waitStatus =
-                txn->waitForConditionOrInterruptNoAssert(_currentCommittedSnapshotCond, lock);
+                opCtx->waitForConditionOrInterruptNoAssert(_currentCommittedSnapshotCond, lock);
             if (!waitStatus.isOK()) {
                 return waitStatus;
             }
@@ -1305,12 +1306,12 @@ Status ReplicationCoordinatorImpl::waitUntilOpTimeForRead(OperationContext* txn,
         // We just need to wait for the opTime to catch up to what we need (not majority RC).
         stdx::condition_variable condVar;
         WaiterInfoGuard waitInfo(
-            &_opTimeWaiterList, txn->getOpID(), targetOpTime, nullptr, &condVar);
+            &_opTimeWaiterList, opCtx->getOpID(), targetOpTime, nullptr, &condVar);
 
         LOG(3) << "waituntilOpTime: waiting for OpTime " << waitInfo.waiter << " until "
-               << txn->getDeadline();
+               << opCtx->getDeadline();
 
-        auto waitStatus = txn->waitForConditionOrInterruptNoAssert(condVar, lock);
+        auto waitStatus = opCtx->waitForConditionOrInterruptNoAssert(condVar, lock);
         if (!waitStatus.isOK()) {
             return waitStatus;
         }
@@ -1591,37 +1592,37 @@ bool ReplicationCoordinatorImpl::_haveTaggedNodesReachedOpTime_inlock(
 }
 
 ReplicationCoordinator::StatusAndDuration ReplicationCoordinatorImpl::awaitReplication(
-    OperationContext* txn, const OpTime& opTime, const WriteConcernOptions& writeConcern) {
+    OperationContext* opCtx, const OpTime& opTime, const WriteConcernOptions& writeConcern) {
     Timer timer;
     WriteConcernOptions fixedWriteConcern = populateUnsetWriteConcernOptionsSyncMode(writeConcern);
     stdx::unique_lock<stdx::mutex> lock(_mutex);
     auto status =
-        _awaitReplication_inlock(&lock, txn, opTime, SnapshotName::min(), fixedWriteConcern);
+        _awaitReplication_inlock(&lock, opCtx, opTime, SnapshotName::min(), fixedWriteConcern);
     return {std::move(status), duration_cast<Milliseconds>(timer.elapsed())};
 }
 
 ReplicationCoordinator::StatusAndDuration
 ReplicationCoordinatorImpl::awaitReplicationOfLastOpForClient(
-    OperationContext* txn, const WriteConcernOptions& writeConcern) {
+    OperationContext* opCtx, const WriteConcernOptions& writeConcern) {
     Timer timer;
     WriteConcernOptions fixedWriteConcern = populateUnsetWriteConcernOptionsSyncMode(writeConcern);
     stdx::unique_lock<stdx::mutex> lock(_mutex);
-    const auto& clientInfo = ReplClientInfo::forClient(txn->getClient());
+    const auto& clientInfo = ReplClientInfo::forClient(opCtx->getClient());
     auto status = _awaitReplication_inlock(
-        &lock, txn, clientInfo.getLastOp(), clientInfo.getLastSnapshot(), fixedWriteConcern);
+        &lock, opCtx, clientInfo.getLastOp(), clientInfo.getLastSnapshot(), fixedWriteConcern);
     return {std::move(status), duration_cast<Milliseconds>(timer.elapsed())};
 }
 
 Status ReplicationCoordinatorImpl::_awaitReplication_inlock(
     stdx::unique_lock<stdx::mutex>* lock,
-    OperationContext* txn,
+    OperationContext* opCtx,
     const OpTime& opTime,
     SnapshotName minSnapshot,
     const WriteConcernOptions& writeConcern) {
 
     // We should never wait for replication if we are holding any locks, because this can
     // potentially block for long time while doing network activity.
-    if (txn->lockState()->isLocked()) {
+    if (opCtx->lockState()->isLocked()) {
         return {ErrorCodes::IllegalOperation,
                 "Waiting for replication not allowed while holding a lock"};
     }
@@ -1668,7 +1669,7 @@ Status ReplicationCoordinatorImpl::_awaitReplication_inlock(
         return stepdownStatus;
     }
 
-    auto interruptStatus = txn->checkForInterruptNoAssert();
+    auto interruptStatus = opCtx->checkForInterruptNoAssert();
     if (!interruptStatus.isOK()) {
         return interruptStatus;
     }
@@ -1681,7 +1682,7 @@ Status ReplicationCoordinatorImpl::_awaitReplication_inlock(
         }
     }
 
-    auto clockSource = txn->getServiceContext()->getFastClockSource();
+    auto clockSource = opCtx->getServiceContext()->getFastClockSource();
     const auto wTimeoutDate = [&]() -> const Date_t {
         if (writeConcern.wDeadline != Date_t::max()) {
             return writeConcern.wDeadline;
@@ -1696,14 +1697,14 @@ Status ReplicationCoordinatorImpl::_awaitReplication_inlock(
     // Must hold _mutex before constructing waitInfo as it will modify _replicationWaiterList
     stdx::condition_variable condVar;
     WaiterInfoGuard waitInfo(
-        &_replicationWaiterList, txn->getOpID(), opTime, &writeConcern, &condVar);
+        &_replicationWaiterList, opCtx->getOpID(), opTime, &writeConcern, &condVar);
     while (!_doneWaitingForReplication_inlock(opTime, minSnapshot, writeConcern)) {
 
         if (_inShutdown) {
             return {ErrorCodes::ShutdownInProgress, "Replication is being shut down"};
         }
 
-        auto status = txn->waitForConditionOrInterruptNoAssertUntil(condVar, *lock, wTimeoutDate);
+        auto status = opCtx->waitForConditionOrInterruptNoAssertUntil(condVar, *lock, wTimeoutDate);
         if (!status.isOK()) {
             return status.getStatus();
         }
@@ -1729,7 +1730,7 @@ Status ReplicationCoordinatorImpl::_awaitReplication_inlock(
     return _checkIfWriteConcernCanBeSatisfied_inlock(writeConcern);
 }
 
-Status ReplicationCoordinatorImpl::stepDown(OperationContext* txn,
+Status ReplicationCoordinatorImpl::stepDown(OperationContext* opCtx,
                                             const bool force,
                                             const Milliseconds& waitTime,
                                             const Milliseconds& stepdownTime) {
@@ -1745,12 +1746,12 @@ Status ReplicationCoordinatorImpl::stepDown(OperationContext* txn,
         return {ErrorCodes::NotMaster, "not primary so can't step down"};
     }
 
-    Lock::GlobalLock globalReadLock(txn->lockState(), MODE_S, Lock::GlobalLock::EnqueueOnly());
+    Lock::GlobalLock globalReadLock(opCtx->lockState(), MODE_S, Lock::GlobalLock::EnqueueOnly());
 
     // We've requested the global shared lock which will stop new writes from coming in,
     // but existing writes could take a long time to finish, so kill all user operations
     // to help us get the global lock faster.
-    _externalState->killAllUserOperations(txn);
+    _externalState->killAllUserOperations(opCtx);
 
     globalReadLock.waitForLock(durationCount<Milliseconds>(stepdownTime));
 
@@ -1763,7 +1764,7 @@ Status ReplicationCoordinatorImpl::stepDown(OperationContext* txn,
     try {
         stdx::unique_lock<stdx::mutex> topoLock(_topoMutex);
         bool restartHeartbeats = true;
-        txn->checkForInterrupt();
+        opCtx->checkForInterrupt();
         while (!_tryToStepDown(waitUntil, stepDownUntil, force)) {
             if (restartHeartbeats) {
                 // We send out a fresh round of heartbeats because stepping down successfully
@@ -1773,7 +1774,7 @@ Status ReplicationCoordinatorImpl::stepDown(OperationContext* txn,
                 _restartHeartbeats_inlock();
                 restartHeartbeats = false;
             }
-            txn->waitForConditionOrInterruptUntil(
+            opCtx->waitForConditionOrInterruptUntil(
                 _stepDownWaiters, topoLock, std::min(stepDownUntil, waitUntil));
         }
     } catch (const DBException& ex) {
@@ -1864,14 +1865,14 @@ bool ReplicationCoordinatorImpl::isMasterForReportingPurposes() {
     return false;
 }
 
-bool ReplicationCoordinatorImpl::canAcceptWritesForDatabase(OperationContext* txn,
+bool ReplicationCoordinatorImpl::canAcceptWritesForDatabase(OperationContext* opCtx,
                                                             StringData dbName) {
     // The answer isn't meaningful unless we hold the global lock.
-    invariant(txn->lockState()->isLocked());
-    return canAcceptWritesForDatabase_UNSAFE(txn, dbName);
+    invariant(opCtx->lockState()->isLocked());
+    return canAcceptWritesForDatabase_UNSAFE(opCtx, dbName);
 }
 
-bool ReplicationCoordinatorImpl::canAcceptWritesForDatabase_UNSAFE(OperationContext* txn,
+bool ReplicationCoordinatorImpl::canAcceptWritesForDatabase_UNSAFE(OperationContext* opCtx,
                                                                    StringData dbName) {
     // _canAcceptNonLocalWrites is always true for standalone nodes, always false for nodes
     // started with --slave, and adjusted based on primary+drain state in replica sets.
@@ -1889,32 +1890,32 @@ bool ReplicationCoordinatorImpl::canAcceptWritesForDatabase_UNSAFE(OperationCont
     return !replAllDead && _settings.isMaster();
 }
 
-bool ReplicationCoordinatorImpl::canAcceptWritesFor(OperationContext* txn,
+bool ReplicationCoordinatorImpl::canAcceptWritesFor(OperationContext* opCtx,
                                                     const NamespaceString& ns) {
-    invariant(txn->lockState()->isLocked());
-    return canAcceptWritesFor_UNSAFE(txn, ns);
+    invariant(opCtx->lockState()->isLocked());
+    return canAcceptWritesFor_UNSAFE(opCtx, ns);
 }
 
-bool ReplicationCoordinatorImpl::canAcceptWritesFor_UNSAFE(OperationContext* txn,
+bool ReplicationCoordinatorImpl::canAcceptWritesFor_UNSAFE(OperationContext* opCtx,
                                                            const NamespaceString& ns) {
     if (_memberState.rollback() && ns.isOplog()) {
         return false;
     }
     StringData dbName = ns.db();
-    return canAcceptWritesForDatabase_UNSAFE(txn, dbName);
+    return canAcceptWritesForDatabase_UNSAFE(opCtx, dbName);
 }
 
-Status ReplicationCoordinatorImpl::checkCanServeReadsFor(OperationContext* txn,
+Status ReplicationCoordinatorImpl::checkCanServeReadsFor(OperationContext* opCtx,
                                                          const NamespaceString& ns,
                                                          bool slaveOk) {
-    invariant(txn->lockState()->isLocked());
-    return checkCanServeReadsFor_UNSAFE(txn, ns, slaveOk);
+    invariant(opCtx->lockState()->isLocked());
+    return checkCanServeReadsFor_UNSAFE(opCtx, ns, slaveOk);
 }
 
-Status ReplicationCoordinatorImpl::checkCanServeReadsFor_UNSAFE(OperationContext* txn,
+Status ReplicationCoordinatorImpl::checkCanServeReadsFor_UNSAFE(OperationContext* opCtx,
                                                                 const NamespaceString& ns,
                                                                 bool slaveOk) {
-    auto client = txn->getClient();
+    auto client = opCtx->getClient();
     // Oplog reads are not allowed during STARTUP state, but we make an exception for internal
     // reads and master-slave replication. Internel reads are required for cleaning up unfinished
     // apply batches. Master-slave never sets the state so we make an exception for it as well.
@@ -1928,7 +1929,7 @@ Status ReplicationCoordinatorImpl::checkCanServeReadsFor_UNSAFE(OperationContext
     if (client->isInDirectClient()) {
         return Status::OK();
     }
-    if (canAcceptWritesFor_UNSAFE(txn, ns)) {
+    if (canAcceptWritesFor_UNSAFE(opCtx, ns)) {
         return Status::OK();
     }
     if (_settings.isSlave() || _settings.isMaster()) {
@@ -1948,9 +1949,9 @@ bool ReplicationCoordinatorImpl::isInPrimaryOrSecondaryState() const {
     return _canServeNonLocalReads.loadRelaxed();
 }
 
-bool ReplicationCoordinatorImpl::shouldRelaxIndexConstraints(OperationContext* txn,
+bool ReplicationCoordinatorImpl::shouldRelaxIndexConstraints(OperationContext* opCtx,
                                                              const NamespaceString& ns) {
-    return !canAcceptWritesFor(txn, ns);
+    return !canAcceptWritesFor(opCtx, ns);
 }
 
 OID ReplicationCoordinatorImpl::getElectionId() {
@@ -1977,8 +1978,8 @@ int ReplicationCoordinatorImpl::_getMyId_inlock() const {
     return self.getId();
 }
 
-Status ReplicationCoordinatorImpl::resyncData(OperationContext* txn, bool waitUntilCompleted) {
-    _stopDataReplication(txn);
+Status ReplicationCoordinatorImpl::resyncData(OperationContext* opCtx, bool waitUntilCompleted) {
+    _stopDataReplication(opCtx);
     auto finishedEvent = uassertStatusOK(_replExecutor.makeEvent());
     stdx::function<void()> f;
     if (waitUntilCompleted)
@@ -1987,7 +1988,7 @@ Status ReplicationCoordinatorImpl::resyncData(OperationContext* txn, bool waitUn
     stdx::unique_lock<stdx::mutex> lk(_mutex);
     _resetMyLastOpTimes_inlock();
     lk.unlock();  // unlock before calling into replCoordExtState.
-    _startDataReplication(txn, f);
+    _startDataReplication(opCtx, f);
     if (waitUntilCompleted) {
         _replExecutor.waitForEvent(finishedEvent);
     }
@@ -2212,7 +2213,7 @@ Status ReplicationCoordinatorImpl::setMaintenanceMode(bool activate) {
     return Status::OK();
 }
 
-Status ReplicationCoordinatorImpl::processReplSetSyncFrom(OperationContext* txn,
+Status ReplicationCoordinatorImpl::processReplSetSyncFrom(OperationContext* opCtx,
                                                           const HostAndPort& target,
                                                           BSONObjBuilder* resultObj) {
     Status result(ErrorCodes::InternalError, "didn't set status in prepareSyncFromResponse");
@@ -2227,7 +2228,7 @@ Status ReplicationCoordinatorImpl::processReplSetSyncFrom(OperationContext* txn,
     }
 
     if (doResync) {
-        return resyncData(txn, false);
+        return resyncData(opCtx, false);
     }
 
     return result;
@@ -2292,7 +2293,7 @@ Status ReplicationCoordinatorImpl::processHeartbeat(const ReplSetHeartbeatArgs&
     return result;
 }
 
-Status ReplicationCoordinatorImpl::processReplSetReconfig(OperationContext* txn,
+Status ReplicationCoordinatorImpl::processReplSetReconfig(OperationContext* opCtx,
                                                           const ReplSetReconfigArgs& args,
                                                           BSONObjBuilder* resultObj) {
     log() << "replSetReconfig admin command received from client";
@@ -2363,7 +2364,7 @@ Status ReplicationCoordinatorImpl::processReplSetReconfig(OperationContext* txn,
     }
 
     StatusWith<int> myIndex = validateConfigForReconfig(
-        _externalState.get(), oldConfig, newConfig, txn->getServiceContext(), args.force);
+        _externalState.get(), oldConfig, newConfig, opCtx->getServiceContext(), args.force);
     if (!myIndex.isOK()) {
         error() << "replSetReconfig got " << myIndex.getStatus() << " while validating "
                 << newConfigObj;
@@ -2382,7 +2383,7 @@ Status ReplicationCoordinatorImpl::processReplSetReconfig(OperationContext* txn,
         }
     }
 
-    status = _externalState->storeLocalConfigDocument(txn, newConfig.toBSON());
+    status = _externalState->storeLocalConfigDocument(opCtx, newConfig.toBSON());
     if (!status.isOK()) {
         error() << "replSetReconfig failed to store config document; " << status;
         return status;
@@ -2465,7 +2466,7 @@ void ReplicationCoordinatorImpl::_finishReplSetReconfig(
     }
 }
 
-Status ReplicationCoordinatorImpl::processReplSetInitiate(OperationContext* txn,
+Status ReplicationCoordinatorImpl::processReplSetInitiate(OperationContext* opCtx,
                                                           const BSONObj& configObj,
                                                           BSONObjBuilder* resultObj) {
     log() << "replSetInitiate admin command received from client";
@@ -2508,7 +2509,7 @@ Status ReplicationCoordinatorImpl::processReplSetInitiate(OperationContext* txn,
     }
 
     StatusWith<int> myIndex =
-        validateConfigForInitiate(_externalState.get(), newConfig, txn->getServiceContext());
+        validateConfigForInitiate(_externalState.get(), newConfig, opCtx->getServiceContext());
     if (!myIndex.isOK()) {
         error() << "replSet initiate got " << myIndex.getStatus() << " while validating "
                 << configObj;
@@ -2525,7 +2526,7 @@ Status ReplicationCoordinatorImpl::processReplSetInitiate(OperationContext* txn,
         return status;
     }
 
-    status = _externalState->initializeReplSetStorage(txn, newConfig.toBSON());
+    status = _externalState->initializeReplSetStorage(opCtx, newConfig.toBSON());
     if (!status.isOK()) {
         error() << "replSetInitiate failed to store config document or create the oplog; "
                 << status;
@@ -2545,7 +2546,7 @@ Status ReplicationCoordinatorImpl::processReplSetInitiate(OperationContext* txn,
     // will fail validation with a "replSet initiate got ... while validating" reason.
     invariant(!newConfig.getMemberAt(myIndex.getValue()).isArbiter());
     _externalState->startThreads(_settings);
-    _startDataReplication(txn);
+    _startDataReplication(opCtx);
 
     configStateGuard.Dismiss();
     return Status::OK();
@@ -2949,7 +2950,7 @@ Status ReplicationCoordinatorImpl::processReplSetUpdatePosition(const UpdatePosi
     return status;
 }
 
-Status ReplicationCoordinatorImpl::processHandshake(OperationContext* txn,
+Status ReplicationCoordinatorImpl::processHandshake(OperationContext* opCtx,
                                                     const HandshakeArgs& handshake) {
     LOG(2) << "Received handshake " << handshake.toBSON();
 
@@ -2968,7 +2969,7 @@ Status ReplicationCoordinatorImpl::processHandshake(OperationContext* txn,
     SlaveInfo newSlaveInfo;
     newSlaveInfo.rid = handshake.getRid();
     newSlaveInfo.memberId = -1;
-    newSlaveInfo.hostAndPort = _externalState->getClientHostAndPort(txn);
+    newSlaveInfo.hostAndPort = _externalState->getClientHostAndPort(opCtx);
     // Don't call _addSlaveInfo_inlock as that would wake sleepers unnecessarily.
     _slaveInfo.push_back(newSlaveInfo);
 
@@ -3121,8 +3122,8 @@ void ReplicationCoordinatorImpl::blacklistSyncSource(const HostAndPort& host, Da
                                host));
 }
 
-void ReplicationCoordinatorImpl::resetLastOpTimesFromOplog(OperationContext* txn) {
-    StatusWith<OpTime> lastOpTimeStatus = _externalState->loadLastOpTime(txn);
+void ReplicationCoordinatorImpl::resetLastOpTimesFromOplog(OperationContext* opCtx) {
+    StatusWith<OpTime> lastOpTimeStatus = _externalState->loadLastOpTime(opCtx);
     OpTime lastOpTime;
     if (!lastOpTimeStatus.isOK()) {
         warning() << "Failed to load timestamp of most recently applied operation; "
@@ -3137,7 +3138,7 @@ void ReplicationCoordinatorImpl::resetLastOpTimesFromOplog(OperationContext* txn
     _reportUpstream_inlock(std::move(lock));
     // Unlocked below.
 
-    _externalState->setGlobalTimestamp(txn->getServiceContext(), lastOpTime.getTimestamp());
+    _externalState->setGlobalTimestamp(opCtx->getServiceContext(), lastOpTime.getTimestamp());
 }
 
 bool ReplicationCoordinatorImpl::shouldChangeSyncSource(
@@ -3244,14 +3245,14 @@ OpTime ReplicationCoordinatorImpl::getLastCommittedOpTime() const {
 }
 
 Status ReplicationCoordinatorImpl::processReplSetRequestVotes(
-    OperationContext* txn,
+    OperationContext* opCtx,
     const ReplSetRequestVotesArgs& args,
     ReplSetRequestVotesResponse* response) {
     if (!isV1ElectionProtocol()) {
         return {ErrorCodes::BadValue, "not using election protocol v1"};
     }
 
-    auto termStatus = updateTerm(txn, args.getTerm());
+    auto termStatus = updateTerm(opCtx, args.getTerm());
     if (!termStatus.isOK() && termStatus.code() != ErrorCodes::StaleTerm)
         return termStatus;
 
@@ -3264,7 +3265,7 @@ Status ReplicationCoordinatorImpl::processReplSetRequestVotes(
     if (!args.isADryRun() && response->getVoteGranted()) {
         LastVote lastVote{args.getTerm(), args.getCandidateIndex()};
 
-        Status status = _externalState->storeLocalLastVoteDocument(txn, lastVote);
+        Status status = _externalState->storeLocalLastVoteDocument(opCtx, lastVote);
         if (!status.isOK()) {
             error() << "replSetRequestVotes failed to store LastVote document; " << status;
             return status;
@@ -3405,7 +3406,7 @@ EventHandle ReplicationCoordinatorImpl::updateTerm_forTest(
     return finishEvh;
 }
 
-Status ReplicationCoordinatorImpl::updateTerm(OperationContext* txn, long long term) {
+Status ReplicationCoordinatorImpl::updateTerm(OperationContext* opCtx, long long term) {
     // Term is only valid if we are replicating.
     if (getReplicationMode() != modeReplSet) {
         return {ErrorCodes::BadValue, "cannot supply 'term' without active replication"};
@@ -3417,7 +3418,7 @@ Status ReplicationCoordinatorImpl::updateTerm(OperationContext* txn, long long t
     }
 
     // Check we haven't acquired any lock, because potential stepdown needs global lock.
-    dassert(!txn->lockState()->isLocked());
+    dassert(!opCtx->lockState()->isLocked());
     TopologyCoordinator::UpdateTermResult updateTermResult;
     EventHandle finishEvh;
 
@@ -3469,12 +3470,12 @@ EventHandle ReplicationCoordinatorImpl::_updateTerm_incallback(
     return EventHandle();
 }
 
-SnapshotName ReplicationCoordinatorImpl::reserveSnapshotName(OperationContext* txn) {
+SnapshotName ReplicationCoordinatorImpl::reserveSnapshotName(OperationContext* opCtx) {
     auto reservedName = SnapshotName(_snapshotNameGenerator.addAndFetch(1));
     dassert(reservedName > SnapshotName::min());
     dassert(reservedName < SnapshotName::max());
-    if (txn) {
-        ReplClientInfo::forClient(txn->getClient()).setLastSnapshot(reservedName);
+    if (opCtx) {
+        ReplClientInfo::forClient(opCtx->getClient()).setLastSnapshot(reservedName);
     }
     return reservedName;
 }
@@ -3483,12 +3484,12 @@ void ReplicationCoordinatorImpl::forceSnapshotCreation() {
     _externalState->forceSnapshotCreation();
 }
 
-void ReplicationCoordinatorImpl::waitUntilSnapshotCommitted(OperationContext* txn,
+void ReplicationCoordinatorImpl::waitUntilSnapshotCommitted(OperationContext* opCtx,
                                                             const SnapshotName& untilSnapshot) {
     stdx::unique_lock<stdx::mutex> lock(_mutex);
 
     while (!_currentCommittedSnapshot || _currentCommittedSnapshot->name < untilSnapshot) {
-        txn->waitForConditionOrInterrupt(_currentCommittedSnapshotCond, lock);
+        opCtx->waitForConditionOrInterrupt(_currentCommittedSnapshotCond, lock);
     }
 }
 
@@ -3496,11 +3497,11 @@ size_t ReplicationCoordinatorImpl::getNumUncommittedSnapshots() {
     return _uncommittedSnapshotsSize.load();
 }
 
-void ReplicationCoordinatorImpl::createSnapshot(OperationContext* txn,
+void ReplicationCoordinatorImpl::createSnapshot(OperationContext* opCtx,
                                                 OpTime timeOfSnapshot,
                                                 SnapshotName name) {
     stdx::lock_guard<stdx::mutex> lock(_mutex);
-    _externalState->createSnapshot(txn, name);
+    _externalState->createSnapshot(opCtx, name);
     auto snapshotInfo = SnapshotInfo{timeOfSnapshot, name};
 
     if (timeOfSnapshot <= _lastCommittedOpTime) {
@@ -3588,10 +3589,10 @@ EventHandle ReplicationCoordinatorImpl::_resetElectionInfoOnProtocolVersionUpgra
         if (cbData.status == ErrorCodes::CallbackCanceled) {
             return;
         }
-        invariant(cbData.txn);
+        invariant(cbData.opCtx);
 
         LastVote lastVote{OpTime::kInitialTerm, -1};
-        auto status = _externalState->storeLocalLastVoteDocument(cbData.txn, lastVote);
+        auto status = _externalState->storeLocalLastVoteDocument(cbData.opCtx, lastVote);
         invariant(status.isOK());
         _replExecutor.signalEvent(evh);
     });
diff --git a/src/mongo/db/repl/replication_coordinator_impl.h b/src/mongo/db/repl/replication_coordinator_impl.h
index 5b2722eaab2..1fa82993ff6 100644
--- a/src/mongo/db/repl/replication_coordinator_impl.h
+++ b/src/mongo/db/repl/replication_coordinator_impl.h
@@ -101,9 +101,9 @@ public:
 
     // ================== Members of public ReplicationCoordinator API ===================
 
-    virtual void startup(OperationContext* txn) override;
+    virtual void startup(OperationContext* opCtx) override;
 
-    virtual void shutdown(OperationContext* txn) override;
+    virtual void shutdown(OperationContext* opCtx) override;
 
     virtual ReplicationExecutor* getExecutor() override {
         return &_replExecutor;
@@ -124,34 +124,34 @@ public:
     virtual void clearSyncSourceBlacklist() override;
 
     virtual ReplicationCoordinator::StatusAndDuration awaitReplication(
-        OperationContext* txn, const OpTime& opTime, const WriteConcernOptions& writeConcern);
+        OperationContext* opCtx, const OpTime& opTime, const WriteConcernOptions& writeConcern);
 
     virtual ReplicationCoordinator::StatusAndDuration awaitReplicationOfLastOpForClient(
-        OperationContext* txn, const WriteConcernOptions& writeConcern);
+        OperationContext* opCtx, const WriteConcernOptions& writeConcern);
 
-    virtual Status stepDown(OperationContext* txn,
+    virtual Status stepDown(OperationContext* opCtx,
                             bool force,
                             const Milliseconds& waitTime,
                             const Milliseconds& stepdownTime);
 
     virtual bool isMasterForReportingPurposes();
 
-    virtual bool canAcceptWritesForDatabase(OperationContext* txn, StringData dbName);
-    virtual bool canAcceptWritesForDatabase_UNSAFE(OperationContext* txn, StringData dbName);
+    virtual bool canAcceptWritesForDatabase(OperationContext* opCtx, StringData dbName);
+    virtual bool canAcceptWritesForDatabase_UNSAFE(OperationContext* opCtx, StringData dbName);
 
-    bool canAcceptWritesFor(OperationContext* txn, const NamespaceString& ns) override;
-    bool canAcceptWritesFor_UNSAFE(OperationContext* txn, const NamespaceString& ns) override;
+    bool canAcceptWritesFor(OperationContext* opCtx, const NamespaceString& ns) override;
+    bool canAcceptWritesFor_UNSAFE(OperationContext* opCtx, const NamespaceString& ns) override;
 
     virtual Status checkIfWriteConcernCanBeSatisfied(const WriteConcernOptions& writeConcern) const;
 
-    virtual Status checkCanServeReadsFor(OperationContext* txn,
+    virtual Status checkCanServeReadsFor(OperationContext* opCtx,
                                          const NamespaceString& ns,
                                          bool slaveOk);
-    virtual Status checkCanServeReadsFor_UNSAFE(OperationContext* txn,
+    virtual Status checkCanServeReadsFor_UNSAFE(OperationContext* opCtx,
                                                 const NamespaceString& ns,
                                                 bool slaveOk);
 
-    virtual bool shouldRelaxIndexConstraints(OperationContext* txn, const NamespaceString& ns);
+    virtual bool shouldRelaxIndexConstraints(OperationContext* opCtx, const NamespaceString& ns);
 
     virtual Status setLastOptimeForSlave(const OID& rid, const Timestamp& ts);
 
@@ -168,7 +168,7 @@ public:
     virtual OpTime getMyLastAppliedOpTime() const override;
     virtual OpTime getMyLastDurableOpTime() const override;
 
-    virtual Status waitUntilOpTimeForRead(OperationContext* txn,
+    virtual Status waitUntilOpTimeForRead(OperationContext* opCtx,
                                           const ReadConcernArgs& settings) override;
 
     virtual OID getElectionId() override;
@@ -181,14 +181,14 @@ public:
 
     virtual ApplierState getApplierState() override;
 
-    virtual void signalDrainComplete(OperationContext* txn,
+    virtual void signalDrainComplete(OperationContext* opCtx,
                                      long long termWhenBufferIsEmpty) override;
 
     virtual Status waitForDrainFinish(Milliseconds timeout) override;
 
     virtual void signalUpstreamUpdater() override;
 
-    virtual Status resyncData(OperationContext* txn, bool waitUntilCompleted) override;
+    virtual Status resyncData(OperationContext* opCtx, bool waitUntilCompleted) override;
 
     virtual StatusWith<BSONObj> prepareReplSetUpdatePositionCommand(
         ReplSetUpdatePositionCommandStyle commandStyle) const override;
@@ -214,7 +214,7 @@ public:
 
     virtual bool getMaintenanceMode() override;
 
-    virtual Status processReplSetSyncFrom(OperationContext* txn,
+    virtual Status processReplSetSyncFrom(OperationContext* opCtx,
                                           const HostAndPort& target,
                                           BSONObjBuilder* resultObj) override;
 
@@ -223,11 +223,11 @@ public:
     virtual Status processHeartbeat(const ReplSetHeartbeatArgs& args,
                                     ReplSetHeartbeatResponse* response) override;
 
-    virtual Status processReplSetReconfig(OperationContext* txn,
+    virtual Status processReplSetReconfig(OperationContext* opCtx,
                                           const ReplSetReconfigArgs& args,
                                           BSONObjBuilder* resultObj) override;
 
-    virtual Status processReplSetInitiate(OperationContext* txn,
+    virtual Status processReplSetInitiate(OperationContext* opCtx,
                                           const BSONObj& configObj,
                                           BSONObjBuilder* resultObj) override;
 
@@ -246,7 +246,8 @@ public:
     virtual Status processReplSetUpdatePosition(const UpdatePositionArgs& updates,
                                                 long long* configVersion) override;
 
-    virtual Status processHandshake(OperationContext* txn, const HandshakeArgs& handshake) override;
+    virtual Status processHandshake(OperationContext* opCtx,
+                                    const HandshakeArgs& handshake) override;
 
     virtual bool buildsIndexes() override;
 
@@ -265,7 +266,7 @@ public:
 
     virtual void blacklistSyncSource(const HostAndPort& host, Date_t until) override;
 
-    virtual void resetLastOpTimesFromOplog(OperationContext* txn) override;
+    virtual void resetLastOpTimesFromOplog(OperationContext* opCtx) override;
 
     virtual bool shouldChangeSyncSource(
         const HostAndPort& currentSource,
@@ -274,7 +275,7 @@ public:
 
     virtual OpTime getLastCommittedOpTime() const override;
 
-    virtual Status processReplSetRequestVotes(OperationContext* txn,
+    virtual Status processReplSetRequestVotes(OperationContext* opCtx,
                                               const ReplSetRequestVotesArgs& args,
                                               ReplSetRequestVotesResponse* response) override;
 
@@ -302,19 +303,19 @@ public:
         return _service;
     }
 
-    virtual Status updateTerm(OperationContext* txn, long long term) override;
+    virtual Status updateTerm(OperationContext* opCtx, long long term) override;
 
-    virtual SnapshotName reserveSnapshotName(OperationContext* txn) override;
+    virtual SnapshotName reserveSnapshotName(OperationContext* opCtx) override;
 
     virtual void forceSnapshotCreation() override;
 
-    virtual void createSnapshot(OperationContext* txn,
+    virtual void createSnapshot(OperationContext* opCtx,
                                 OpTime timeOfSnapshot,
                                 SnapshotName name) override;
 
     virtual OpTime getCurrentCommittedSnapshotOpTime() const override;
 
-    virtual void waitUntilSnapshotCommitted(OperationContext* txn,
+    virtual void waitUntilSnapshotCommitted(OperationContext* opCtx,
                                             const SnapshotName& untilSnapshot) override;
 
     virtual void appendConnectionStats(executor::ConnectionPoolStats* stats) const override;
@@ -622,7 +623,7 @@ private:
      * operation timing to the caller.
      */
     Status _awaitReplication_inlock(stdx::unique_lock<stdx::mutex>* lock,
-                                    OperationContext* txn,
+                                    OperationContext* opCtx,
                                     const OpTime& opTime,
                                     SnapshotName minSnapshot,
                                     const WriteConcernOptions& writeConcern);
@@ -793,7 +794,7 @@ private:
      * config detected but more work is needed to set it as the local config (which will be
      * handled by the callback to _finishLoadLocalConfig).
      */
-    bool _startLoadLocalConfig(OperationContext* txn);
+    bool _startLoadLocalConfig(OperationContext* opCtx);
 
     /**
      * Callback that finishes the work started in _startLoadLocalConfig and sets _rsConfigState
@@ -807,13 +808,13 @@ private:
     /**
      * Start replicating data, and does an initial sync if needed first.
      */
-    void _startDataReplication(OperationContext* txn,
+    void _startDataReplication(OperationContext* opCtx,
                                stdx::function<void()> startCompleted = nullptr);
 
     /**
      * Stops replicating data by stopping the applier, fetcher and such.
      */
-    void _stopDataReplication(OperationContext* txn);
+    void _stopDataReplication(OperationContext* opCtx);
 
     /**
      * Finishes the work of processReplSetInitiate() while holding _topoMutex, in the event of
diff --git a/src/mongo/db/repl/replication_coordinator_impl_elect_test.cpp b/src/mongo/db/repl/replication_coordinator_impl_elect_test.cpp
index 89325f7f424..5724fb43bf6 100644
--- a/src/mongo/db/repl/replication_coordinator_impl_elect_test.cpp
+++ b/src/mongo/db/repl/replication_coordinator_impl_elect_test.cpp
@@ -157,15 +157,15 @@ TEST_F(ReplCoordElectTest, ElectionSucceedsWhenNodeIsTheOnlyElectableNode) {
         << getReplCoord()->getMemberState().toString();
     ASSERT(getReplCoord()->getApplierState() == ReplicationCoordinator::ApplierState::Draining);
 
-    const auto txnPtr = makeOperationContext();
-    auto& txn = *txnPtr;
+    const auto opCtxPtr = makeOperationContext();
+    auto& opCtx = *opCtxPtr;
 
     // Since we're still in drain mode, expect that we report ismaster: false, issecondary:true.
     IsMasterResponse imResponse;
     getReplCoord()->fillIsMasterForReplSet(&imResponse);
     ASSERT_FALSE(imResponse.isMaster()) << imResponse.toBSON().toString();
     ASSERT_TRUE(imResponse.isSecondary()) << imResponse.toBSON().toString();
-    getReplCoord()->signalDrainComplete(&txn, getReplCoord()->getTerm());
+    getReplCoord()->signalDrainComplete(&opCtx, getReplCoord()->getTerm());
     getReplCoord()->fillIsMasterForReplSet(&imResponse);
     ASSERT_TRUE(imResponse.isMaster()) << imResponse.toBSON().toString();
     ASSERT_FALSE(imResponse.isSecondary()) << imResponse.toBSON().toString();
@@ -191,15 +191,15 @@ TEST_F(ReplCoordElectTest, ElectionSucceedsWhenNodeIsTheOnlyNode) {
         << getReplCoord()->getMemberState().toString();
     ASSERT(getReplCoord()->getApplierState() == ReplicationCoordinator::ApplierState::Draining);
 
-    const auto txnPtr = makeOperationContext();
-    auto& txn = *txnPtr;
+    const auto opCtxPtr = makeOperationContext();
+    auto& opCtx = *opCtxPtr;
 
     // Since we're still in drain mode, expect that we report ismaster: false, issecondary:true.
     IsMasterResponse imResponse;
     getReplCoord()->fillIsMasterForReplSet(&imResponse);
     ASSERT_FALSE(imResponse.isMaster()) << imResponse.toBSON().toString();
     ASSERT_TRUE(imResponse.isSecondary()) << imResponse.toBSON().toString();
-    getReplCoord()->signalDrainComplete(&txn, getReplCoord()->getTerm());
+    getReplCoord()->signalDrainComplete(&opCtx, getReplCoord()->getTerm());
     getReplCoord()->fillIsMasterForReplSet(&imResponse);
     ASSERT_TRUE(imResponse.isMaster()) << imResponse.toBSON().toString();
     ASSERT_FALSE(imResponse.isSecondary()) << imResponse.toBSON().toString();
@@ -218,7 +218,7 @@ TEST_F(ReplCoordElectTest, ElectionSucceedsWhenAllNodesVoteYea) {
                                            << BSON("_id" << 3 << "host"
                                                          << "node3:12345")));
     assertStartSuccess(configObj, HostAndPort("node1", 12345));
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     getReplCoord()->setMyLastAppliedOpTime(OpTime{{100, 1}, 0});
     getExternalState()->setLastOpTime(OpTime{{100, 1}, 0});
 
@@ -246,7 +246,7 @@ TEST_F(ReplCoordElectTest, ElectionFailsWhenOneNodeVotesNay) {
     assertStartSuccess(configObj, HostAndPort("node1", 12345));
     ReplSetConfig config = assertMakeRSConfig(configObj);
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     OpTime time1(Timestamp(100, 1), 0);
     getReplCoord()->setMyLastAppliedOpTime(time1);
     ASSERT(getReplCoord()->setFollowerMode(MemberState::RS_SECONDARY));
@@ -293,7 +293,7 @@ TEST_F(ReplCoordElectTest, VotesWithStringValuesAreNotCountedAsYeas) {
     assertStartSuccess(configObj, HostAndPort("node1", 12345));
     ReplSetConfig config = assertMakeRSConfig(configObj);
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     OpTime time1(Timestamp(100, 1), 0);
     getReplCoord()->setMyLastAppliedOpTime(time1);
     ASSERT(getReplCoord()->setFollowerMode(MemberState::RS_SECONDARY));
@@ -341,7 +341,7 @@ TEST_F(ReplCoordElectTest, ElectionsAbortWhenNodeTransitionsToRollbackState) {
     assertStartSuccess(configObj, HostAndPort("node1", 12345));
     ReplSetConfig config = assertMakeRSConfig(configObj);
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     OpTime time1(Timestamp(100, 1), 0);
     getReplCoord()->setMyLastAppliedOpTime(time1);
     ASSERT(getReplCoord()->setFollowerMode(MemberState::RS_SECONDARY));
@@ -363,7 +363,7 @@ TEST_F(ReplCoordElectTest, ElectionsAbortWhenNodeTransitionsToRollbackState) {
 TEST_F(ReplCoordElectTest, NodeWillNotStandForElectionDuringHeartbeatReconfig) {
     // start up, receive reconfig via heartbeat while at the same time, become candidate.
     // candidate state should be cleared.
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     assertStartSuccess(BSON("_id"
                             << "mySet"
                             << "version"
@@ -419,7 +419,7 @@ TEST_F(ReplCoordElectTest, NodeWillNotStandForElectionDuringHeartbeatReconfig) {
     args.force = false;
     args.newConfigObj = config.toBSON();
     ASSERT_EQUALS(ErrorCodes::ConfigurationInProgress,
-                  getReplCoord()->processReplSetReconfig(&txn, args, &result));
+                  getReplCoord()->processReplSetReconfig(&opCtx, args, &result));
 
     logger::globalLogDomain()->setMinimumLoggedSeverity(logger::LogSeverity::Debug(2));
     startCapturingLogMessages();
@@ -477,7 +477,7 @@ TEST_F(ReplCoordElectTest, StepsDownRemoteIfNodeHasHigherPriorityThanCurrentPrim
 
     auto replCoord = getReplCoord();
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     OpTime time1(Timestamp(100, 1), 0);
     getReplCoord()->setMyLastAppliedOpTime(time1);
     ASSERT(getReplCoord()->setFollowerMode(MemberState::RS_SECONDARY));
@@ -583,8 +583,8 @@ TEST_F(ReplCoordElectTest, NodeCancelsElectionUponReceivingANewConfigDuringFresh
         true};
 
     BSONObjBuilder result;
-    const auto txn = makeOperationContext();
-    ASSERT_OK(getReplCoord()->processReplSetReconfig(txn.get(), config, &result));
+    const auto opCtx = makeOperationContext();
+    ASSERT_OK(getReplCoord()->processReplSetReconfig(opCtx.get(), config, &result));
     // Wait until election cancels.
     net->enterNetwork();
     net->runReadyNetworkOperations();
@@ -629,8 +629,8 @@ TEST_F(ReplCoordElectTest, NodeCancelsElectionUponReceivingANewConfigDuringElect
         true};
 
     BSONObjBuilder result;
-    const auto txn = makeOperationContext();
-    ASSERT_OK(getReplCoord()->processReplSetReconfig(txn.get(), config, &result));
+    const auto opCtx = makeOperationContext();
+    ASSERT_OK(getReplCoord()->processReplSetReconfig(opCtx.get(), config, &result));
     // Wait until election cancels.
     getNet()->enterNetwork();
     getNet()->runReadyNetworkOperations();
diff --git a/src/mongo/db/repl/replication_coordinator_impl_elect_v1.cpp b/src/mongo/db/repl/replication_coordinator_impl_elect_v1.cpp
index 4484e3beead..e5d2dc214f7 100644
--- a/src/mongo/db/repl/replication_coordinator_impl_elect_v1.cpp
+++ b/src/mongo/db/repl/replication_coordinator_impl_elect_v1.cpp
@@ -210,9 +210,9 @@ void ReplicationCoordinatorImpl::_writeLastVoteForMyElection(
     if (cbData.status == ErrorCodes::CallbackCanceled) {
         return;
     }
-    invariant(cbData.txn);
+    invariant(cbData.opCtx);
 
-    Status status = _externalState->storeLocalLastVoteDocument(cbData.txn, lastVote);
+    Status status = _externalState->storeLocalLastVoteDocument(cbData.opCtx, lastVote);
     if (!status.isOK()) {
         error() << "failed to store LastVote document when voting for myself: " << status;
         return;
diff --git a/src/mongo/db/repl/replication_coordinator_impl_elect_v1_test.cpp b/src/mongo/db/repl/replication_coordinator_impl_elect_v1_test.cpp
index e3660682e3c..be2370b7108 100644
--- a/src/mongo/db/repl/replication_coordinator_impl_elect_v1_test.cpp
+++ b/src/mongo/db/repl/replication_coordinator_impl_elect_v1_test.cpp
@@ -162,15 +162,15 @@ TEST_F(ReplCoordTest, ElectionSucceedsWhenNodeIsTheOnlyElectableNode) {
     simulateCatchUpTimeout();
     ASSERT(getReplCoord()->getApplierState() == ApplierState::Draining);
 
-    const auto txnPtr = makeOperationContext();
-    auto& txn = *txnPtr;
+    const auto opCtxPtr = makeOperationContext();
+    auto& opCtx = *opCtxPtr;
 
     // Since we're still in drain mode, expect that we report ismaster: false, issecondary:true.
     IsMasterResponse imResponse;
     getReplCoord()->fillIsMasterForReplSet(&imResponse);
     ASSERT_FALSE(imResponse.isMaster()) << imResponse.toBSON().toString();
     ASSERT_TRUE(imResponse.isSecondary()) << imResponse.toBSON().toString();
-    getReplCoord()->signalDrainComplete(&txn, getReplCoord()->getTerm());
+    getReplCoord()->signalDrainComplete(&opCtx, getReplCoord()->getTerm());
     getReplCoord()->fillIsMasterForReplSet(&imResponse);
     ASSERT_TRUE(imResponse.isMaster()) << imResponse.toBSON().toString();
     ASSERT_FALSE(imResponse.isSecondary()) << imResponse.toBSON().toString();
@@ -226,15 +226,15 @@ TEST_F(ReplCoordTest, ElectionSucceedsWhenNodeIsTheOnlyNode) {
     simulateCatchUpTimeout();
     ASSERT(getReplCoord()->getApplierState() == ApplierState::Draining);
 
-    const auto txnPtr = makeOperationContext();
-    auto& txn = *txnPtr;
+    const auto opCtxPtr = makeOperationContext();
+    auto& opCtx = *opCtxPtr;
 
     // Since we're still in drain mode, expect that we report ismaster: false, issecondary:true.
     IsMasterResponse imResponse;
     getReplCoord()->fillIsMasterForReplSet(&imResponse);
     ASSERT_FALSE(imResponse.isMaster()) << imResponse.toBSON().toString();
     ASSERT_TRUE(imResponse.isSecondary()) << imResponse.toBSON().toString();
-    getReplCoord()->signalDrainComplete(&txn, getReplCoord()->getTerm());
+    getReplCoord()->signalDrainComplete(&opCtx, getReplCoord()->getTerm());
     getReplCoord()->fillIsMasterForReplSet(&imResponse);
     ASSERT_TRUE(imResponse.isMaster()) << imResponse.toBSON().toString();
     ASSERT_FALSE(imResponse.isSecondary()) << imResponse.toBSON().toString();
@@ -255,7 +255,7 @@ TEST_F(ReplCoordTest, ElectionSucceedsWhenAllNodesVoteYea) {
                              << "protocolVersion"
                              << 1);
     assertStartSuccess(configObj, HostAndPort("node1", 12345));
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     getReplCoord()->setMyLastAppliedOpTime(OpTime(Timestamp(100, 1), 0));
     getReplCoord()->setMyLastDurableOpTime(OpTime(Timestamp(100, 1), 0));
     ASSERT(getReplCoord()->setFollowerMode(MemberState::RS_SECONDARY));
@@ -296,7 +296,7 @@ TEST_F(ReplCoordTest, ElectionSucceedsWhenMaxSevenNodesVoteYea) {
                              << "protocolVersion"
                              << 1);
     assertStartSuccess(configObj, HostAndPort("node1", 12345));
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     getReplCoord()->setMyLastAppliedOpTime(OpTime(Timestamp(100, 1), 0));
     getReplCoord()->setMyLastDurableOpTime(OpTime(Timestamp(100, 1), 0));
     ASSERT(getReplCoord()->setFollowerMode(MemberState::RS_SECONDARY));
@@ -332,7 +332,7 @@ TEST_F(ReplCoordTest, ElectionFailsWhenInsufficientVotesAreReceivedDuringDryRun)
     assertStartSuccess(configObj, HostAndPort("node1", 12345));
     ReplSetConfig config = assertMakeRSConfig(configObj);
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     OpTime time1(Timestamp(100, 1), 0);
     getReplCoord()->setMyLastAppliedOpTime(time1);
     getReplCoord()->setMyLastDurableOpTime(time1);
@@ -391,7 +391,7 @@ TEST_F(ReplCoordTest, ElectionFailsWhenDryRunResponseContainsANewerTerm) {
     assertStartSuccess(configObj, HostAndPort("node1", 12345));
     ReplSetConfig config = assertMakeRSConfig(configObj);
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     OpTime time1(Timestamp(100, 1), 0);
     getReplCoord()->setMyLastAppliedOpTime(time1);
     getReplCoord()->setMyLastDurableOpTime(time1);
@@ -439,7 +439,7 @@ TEST_F(ReplCoordTest, ElectionFailsWhenDryRunResponseContainsANewerTerm) {
 TEST_F(ReplCoordTest, NodeWillNotStandForElectionDuringHeartbeatReconfig) {
     // start up, receive reconfig via heartbeat while at the same time, become candidate.
     // candidate state should be cleared.
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     assertStartSuccess(BSON("_id"
                             << "mySet"
                             << "version"
@@ -497,7 +497,7 @@ TEST_F(ReplCoordTest, NodeWillNotStandForElectionDuringHeartbeatReconfig) {
     args.force = false;
     args.newConfigObj = config.toBSON();
     ASSERT_EQUALS(ErrorCodes::ConfigurationInProgress,
-                  getReplCoord()->processReplSetReconfig(&txn, args, &result));
+                  getReplCoord()->processReplSetReconfig(&opCtx, args, &result));
 
     logger::globalLogDomain()->setMinimumLoggedSeverity(logger::LogSeverity::Debug(2));
     startCapturingLogMessages();
@@ -568,7 +568,7 @@ TEST_F(ReplCoordTest, ElectionFailsWhenInsufficientVotesAreReceivedDuringRequest
     assertStartSuccess(configObj, HostAndPort("node1", 12345));
     ReplSetConfig config = assertMakeRSConfig(configObj);
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     OpTime time1(Timestamp(100, 1), 0);
     getReplCoord()->setMyLastAppliedOpTime(time1);
     getReplCoord()->setMyLastDurableOpTime(time1);
@@ -619,7 +619,7 @@ TEST_F(ReplCoordTest, ElectionsAbortWhenNodeTransitionsToRollbackState) {
     assertStartSuccess(configObj, HostAndPort("node1", 12345));
     ReplSetConfig config = assertMakeRSConfig(configObj);
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     OpTime time1(Timestamp(100, 1), 0);
     getReplCoord()->setMyLastAppliedOpTime(time1);
     getReplCoord()->setMyLastDurableOpTime(time1);
@@ -657,7 +657,7 @@ TEST_F(ReplCoordTest, ElectionFailsWhenVoteRequestResponseContainsANewerTerm) {
     assertStartSuccess(configObj, HostAndPort("node1", 12345));
     ReplSetConfig config = assertMakeRSConfig(configObj);
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     OpTime time1(Timestamp(100, 1), 0);
     getReplCoord()->setMyLastAppliedOpTime(time1);
     getReplCoord()->setMyLastDurableOpTime(time1);
@@ -713,7 +713,7 @@ TEST_F(ReplCoordTest, ElectionFailsWhenTermChangesDuringDryRun) {
     assertStartSuccess(configObj, HostAndPort("node1", 12345));
     ReplSetConfig config = assertMakeRSConfig(configObj);
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     OpTime time1(Timestamp(100, 1), 0);
     getReplCoord()->setMyLastAppliedOpTime(time1);
     getReplCoord()->setMyLastDurableOpTime(time1);
@@ -752,7 +752,7 @@ TEST_F(ReplCoordTest, ElectionFailsWhenTermChangesDuringActualElection) {
     assertStartSuccess(configObj, HostAndPort("node1", 12345));
     ReplSetConfig config = assertMakeRSConfig(configObj);
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     OpTime time1(Timestamp(100, 1), 0);
     getReplCoord()->setMyLastAppliedOpTime(time1);
     getReplCoord()->setMyLastDurableOpTime(time1);
@@ -761,7 +761,7 @@ TEST_F(ReplCoordTest, ElectionFailsWhenTermChangesDuringActualElection) {
     simulateEnoughHeartbeatsForAllNodesUp();
     simulateSuccessfulDryRun();
     // update to a future term before the election completes
-    getReplCoord()->updateTerm(&txn, 1000);
+    getReplCoord()->updateTerm(&opCtx, 1000);
 
     NetworkInterfaceMock* net = getNet();
     net->enterNetwork();
@@ -942,7 +942,7 @@ TEST_F(PriorityTakeoverTest, SchedulesPriorityTakeoverIfNodeHasHigherPriorityTha
     auto replCoord = getReplCoord();
     auto now = getNet()->now();
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     OpTime myOptime(Timestamp(100, 1), 0);
     replCoord->setMyLastAppliedOpTime(myOptime);
     replCoord->setMyLastDurableOpTime(myOptime);
@@ -963,7 +963,7 @@ TEST_F(PriorityTakeoverTest, SchedulesPriorityTakeoverIfNodeHasHigherPriorityTha
     assertValidTakeoverDelay(config, now, priorityTakeoverTime, 0);
 
     // Also make sure that updating the term cancels the scheduled priority takeover.
-    ASSERT_EQUALS(ErrorCodes::StaleTerm, replCoord->updateTerm(&txn, replCoord->getTerm() + 1));
+    ASSERT_EQUALS(ErrorCodes::StaleTerm, replCoord->updateTerm(&opCtx, replCoord->getTerm() + 1));
     ASSERT_FALSE(replCoord->getPriorityTakeover_forTest());
 }
 
@@ -989,7 +989,7 @@ TEST_F(PriorityTakeoverTest, SuccessfulPriorityTakeover) {
     auto replCoord = getReplCoord();
     auto now = getNet()->now();
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     OpTime myOptime(Timestamp(100, 1), 0);
     replCoord->setMyLastAppliedOpTime(myOptime);
     replCoord->setMyLastDurableOpTime(myOptime);
@@ -1043,7 +1043,7 @@ TEST_F(PriorityTakeoverTest, DontCallForPriorityTakeoverWhenLaggedSameSecond) {
     auto timeZero = getNet()->now();
     auto now = getNet()->now();
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     OpTime currentOpTime(Timestamp(100, 5000), 0);
     OpTime behindOpTime(Timestamp(100, 3999), 0);
     OpTime closeEnoughOpTime(Timestamp(100, 4000), 0);
@@ -1119,7 +1119,7 @@ TEST_F(PriorityTakeoverTest, DontCallForPriorityTakeoverWhenLaggedDifferentSecon
     auto timeZero = getNet()->now();
     auto now = getNet()->now();
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     OpTime currentOpTime(Timestamp(100, 0), 0);
     OpTime behindOpTime(Timestamp(97, 0), 0);
     OpTime closeEnoughOpTime(Timestamp(98, 0), 0);
@@ -1218,8 +1218,8 @@ TEST_F(ReplCoordTest, NodeCancelsElectionUponReceivingANewConfigDuringDryRun) {
         true};
 
     BSONObjBuilder result;
-    const auto txn = makeOperationContext();
-    ASSERT_OK(getReplCoord()->processReplSetReconfig(txn.get(), config, &result));
+    const auto opCtx = makeOperationContext();
+    ASSERT_OK(getReplCoord()->processReplSetReconfig(opCtx.get(), config, &result));
     // Wait until election cancels.
     net->enterNetwork();
     net->runReadyNetworkOperations();
@@ -1264,8 +1264,8 @@ TEST_F(ReplCoordTest, NodeCancelsElectionUponReceivingANewConfigDuringVotePhase)
         true};
 
     BSONObjBuilder result;
-    const auto txn = makeOperationContext();
-    ASSERT_OK(getReplCoord()->processReplSetReconfig(txn.get(), config, &result));
+    const auto opCtx = makeOperationContext();
+    ASSERT_OK(getReplCoord()->processReplSetReconfig(opCtx.get(), config, &result));
     // Wait until election cancels.
     getNet()->enterNetwork();
     getNet()->runReadyNetworkOperations();
@@ -1429,10 +1429,10 @@ TEST_F(PrimaryCatchUpTest, PrimaryDoNotNeedToCatchUp) {
     ASSERT(getReplCoord()->getApplierState() == ApplierState::Draining);
     stopCapturingLogMessages();
     ASSERT_EQUALS(1, countLogLinesContaining("My optime is most up-to-date, skipping catch-up"));
-    auto txn = makeOperationContext();
-    getReplCoord()->signalDrainComplete(txn.get(), getReplCoord()->getTerm());
-    Lock::GlobalLock lock(txn->lockState(), MODE_IX, 1);
-    ASSERT_TRUE(getReplCoord()->canAcceptWritesForDatabase(txn.get(), "test"));
+    auto opCtx = makeOperationContext();
+    getReplCoord()->signalDrainComplete(opCtx.get(), getReplCoord()->getTerm());
+    Lock::GlobalLock lock(opCtx->lockState(), MODE_IX, 1);
+    ASSERT_TRUE(getReplCoord()->canAcceptWritesForDatabase(opCtx.get(), "test"));
 }
 
 TEST_F(PrimaryCatchUpTest, PrimaryFreshnessScanTimeout) {
@@ -1453,10 +1453,10 @@ TEST_F(PrimaryCatchUpTest, PrimaryFreshnessScanTimeout) {
     ASSERT(getReplCoord()->getApplierState() == ApplierState::Draining);
     stopCapturingLogMessages();
     ASSERT_EQUALS(1, countLogLinesContaining("Could not access any nodes within timeout"));
-    auto txn = makeOperationContext();
-    getReplCoord()->signalDrainComplete(txn.get(), getReplCoord()->getTerm());
-    Lock::GlobalLock lock(txn->lockState(), MODE_IX, 1);
-    ASSERT_TRUE(getReplCoord()->canAcceptWritesForDatabase(txn.get(), "test"));
+    auto opCtx = makeOperationContext();
+    getReplCoord()->signalDrainComplete(opCtx.get(), getReplCoord()->getTerm());
+    Lock::GlobalLock lock(opCtx->lockState(), MODE_IX, 1);
+    ASSERT_TRUE(getReplCoord()->canAcceptWritesForDatabase(opCtx.get(), "test"));
 }
 
 TEST_F(PrimaryCatchUpTest, PrimaryCatchUpSucceeds) {
@@ -1483,10 +1483,10 @@ TEST_F(PrimaryCatchUpTest, PrimaryCatchUpSucceeds) {
     ASSERT(getReplCoord()->getApplierState() == ApplierState::Draining);
     stopCapturingLogMessages();
     ASSERT_EQUALS(1, countLogLinesContaining("Finished catch-up oplog after becoming primary."));
-    auto txn = makeOperationContext();
-    getReplCoord()->signalDrainComplete(txn.get(), getReplCoord()->getTerm());
-    Lock::GlobalLock lock(txn->lockState(), MODE_IX, 1);
-    ASSERT_TRUE(getReplCoord()->canAcceptWritesForDatabase(txn.get(), "test"));
+    auto opCtx = makeOperationContext();
+    getReplCoord()->signalDrainComplete(opCtx.get(), getReplCoord()->getTerm());
+    Lock::GlobalLock lock(opCtx->lockState(), MODE_IX, 1);
+    ASSERT_TRUE(getReplCoord()->canAcceptWritesForDatabase(opCtx.get(), "test"));
 }
 
 TEST_F(PrimaryCatchUpTest, PrimaryCatchUpTimeout) {
@@ -1507,10 +1507,10 @@ TEST_F(PrimaryCatchUpTest, PrimaryCatchUpTimeout) {
     ASSERT(getReplCoord()->getApplierState() == ApplierState::Draining);
     stopCapturingLogMessages();
     ASSERT_EQUALS(1, countLogLinesContaining("Cannot catch up oplog after becoming primary"));
-    auto txn = makeOperationContext();
-    getReplCoord()->signalDrainComplete(txn.get(), getReplCoord()->getTerm());
-    Lock::GlobalLock lock(txn->lockState(), MODE_IX, 1);
-    ASSERT_TRUE(getReplCoord()->canAcceptWritesForDatabase(txn.get(), "test"));
+    auto opCtx = makeOperationContext();
+    getReplCoord()->signalDrainComplete(opCtx.get(), getReplCoord()->getTerm());
+    Lock::GlobalLock lock(opCtx->lockState(), MODE_IX, 1);
+    ASSERT_TRUE(getReplCoord()->canAcceptWritesForDatabase(opCtx.get(), "test"));
 }
 
 TEST_F(PrimaryCatchUpTest, PrimaryStepsDownDuringFreshnessScan) {
@@ -1536,9 +1536,9 @@ TEST_F(PrimaryCatchUpTest, PrimaryStepsDownDuringFreshnessScan) {
     ASSERT(getReplCoord()->getApplierState() == ApplierState::Running);
     stopCapturingLogMessages();
     ASSERT_EQUALS(1, countLogLinesContaining("Stopped transition to primary"));
-    auto txn = makeOperationContext();
-    Lock::GlobalLock lock(txn->lockState(), MODE_IX, 1);
-    ASSERT_FALSE(getReplCoord()->canAcceptWritesForDatabase(txn.get(), "test"));
+    auto opCtx = makeOperationContext();
+    Lock::GlobalLock lock(opCtx->lockState(), MODE_IX, 1);
+    ASSERT_FALSE(getReplCoord()->canAcceptWritesForDatabase(opCtx.get(), "test"));
 }
 
 TEST_F(PrimaryCatchUpTest, PrimaryStepsDownDuringCatchUp) {
@@ -1564,15 +1564,15 @@ TEST_F(PrimaryCatchUpTest, PrimaryStepsDownDuringCatchUp) {
     net->enterNetwork();
     net->runReadyNetworkOperations();
     net->exitNetwork();
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
     // Simulate the applier signaling replCoord to exit drain mode.
     // At this point, we see the stepdown and reset the states.
-    getReplCoord()->signalDrainComplete(txn.get(), getReplCoord()->getTerm());
+    getReplCoord()->signalDrainComplete(opCtx.get(), getReplCoord()->getTerm());
     ASSERT(getReplCoord()->getApplierState() == ApplierState::Running);
     stopCapturingLogMessages();
     ASSERT_EQUALS(1, countLogLinesContaining("Cannot catch up oplog after becoming primary"));
-    Lock::GlobalLock lock(txn->lockState(), MODE_IX, 1);
-    ASSERT_FALSE(getReplCoord()->canAcceptWritesForDatabase(txn.get(), "test"));
+    Lock::GlobalLock lock(opCtx->lockState(), MODE_IX, 1);
+    ASSERT_FALSE(getReplCoord()->canAcceptWritesForDatabase(opCtx.get(), "test"));
 }
 
 TEST_F(PrimaryCatchUpTest, PrimaryStepsDownDuringDrainMode) {
@@ -1618,15 +1618,15 @@ TEST_F(PrimaryCatchUpTest, PrimaryStepsDownDuringDrainMode) {
         getNet()->scheduleResponse(noi, getNet()->now(), makeFreshnessScanResponse(OpTime()));
     });
     ASSERT(replCoord->getApplierState() == ApplierState::Draining);
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
     {
-        Lock::GlobalLock lock(txn->lockState(), MODE_IX, 1);
-        ASSERT_FALSE(replCoord->canAcceptWritesForDatabase(txn.get(), "test"));
+        Lock::GlobalLock lock(opCtx->lockState(), MODE_IX, 1);
+        ASSERT_FALSE(replCoord->canAcceptWritesForDatabase(opCtx.get(), "test"));
     }
-    replCoord->signalDrainComplete(txn.get(), replCoord->getTerm());
-    Lock::GlobalLock lock(txn->lockState(), MODE_IX, 1);
+    replCoord->signalDrainComplete(opCtx.get(), replCoord->getTerm());
+    Lock::GlobalLock lock(opCtx->lockState(), MODE_IX, 1);
     ASSERT(replCoord->getApplierState() == ApplierState::Stopped);
-    ASSERT_TRUE(replCoord->canAcceptWritesForDatabase(txn.get(), "test"));
+    ASSERT_TRUE(replCoord->canAcceptWritesForDatabase(opCtx.get(), "test"));
 }
 
 }  // namespace
diff --git a/src/mongo/db/repl/replication_coordinator_impl_heartbeat.cpp b/src/mongo/db/repl/replication_coordinator_impl_heartbeat.cpp
index 602f3cb5f40..db42e12f13d 100644
--- a/src/mongo/db/repl/replication_coordinator_impl_heartbeat.cpp
+++ b/src/mongo/db/repl/replication_coordinator_impl_heartbeat.cpp
@@ -385,7 +385,7 @@ void ReplicationCoordinatorImpl::_stepDownFinish(
 
     LockGuard topoLock(_topoMutex);
 
-    invariant(cbData.txn);
+    invariant(cbData.opCtx);
     // TODO Add invariant that we've got global shared or global exclusive lock, when supported
     // by lock manager.
     stdx::unique_lock<stdx::mutex> lk(_mutex);
@@ -496,7 +496,7 @@ void ReplicationCoordinatorImpl::_heartbeatReconfigStore(
                      "it is invalid: "
                   << myIndex.getStatus();
     } else {
-        Status status = _externalState->storeLocalConfigDocument(cbd.txn, newConfig.toBSON());
+        Status status = _externalState->storeLocalConfigDocument(cbd.opCtx, newConfig.toBSON());
 
         lk.lock();
         if (!status.isOK()) {
@@ -518,7 +518,7 @@ void ReplicationCoordinatorImpl::_heartbeatReconfigStore(
             newConfig.getMemberAt(myIndex.getValue()).isArbiter();
         if (!isArbiter && isFirstConfig) {
             _externalState->startThreads(_settings);
-            _startDataReplication(cbd.txn);
+            _startDataReplication(cbd.opCtx);
         }
     }
 
@@ -558,7 +558,7 @@ void ReplicationCoordinatorImpl::_heartbeatReconfigFinish(
     invariant(!_rsConfig.isInitialized() ||
               _rsConfig.getConfigVersion() < newConfig.getConfigVersion());
 
-    if (_getMemberState_inlock().primary() && !cbData.txn) {
+    if (_getMemberState_inlock().primary() && !cbData.opCtx) {
         // Not having an OperationContext in the CallbackData means we definitely aren't holding
         // the global lock.  Since we're primary and this reconfig could cause us to stepdown,
         // reschedule this work with the global exclusive lock so the stepdown is safe.
diff --git a/src/mongo/db/repl/replication_coordinator_impl_heartbeat_test.cpp b/src/mongo/db/repl/replication_coordinator_impl_heartbeat_test.cpp
index 69c9b6541c6..2aee49fd3e4 100644
--- a/src/mongo/db/repl/replication_coordinator_impl_heartbeat_test.cpp
+++ b/src/mongo/db/repl/replication_coordinator_impl_heartbeat_test.cpp
@@ -139,10 +139,10 @@ TEST_F(ReplCoordHBTest, NodeJoinsExistingReplSetWhenReceivingAConfigContainingTh
     noi = net->getNextReadyRequest();
 
     assertMemberState(MemberState::RS_STARTUP2);
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     ReplSetConfig storedConfig;
     ASSERT_OK(storedConfig.initialize(
-        unittest::assertGet(getExternalState()->loadLocalConfigDocument(&txn))));
+        unittest::assertGet(getExternalState()->loadLocalConfigDocument(&opCtx))));
     ASSERT_OK(storedConfig.validate());
     ASSERT_EQUALS(3, storedConfig.getConfigVersion());
     ASSERT_EQUALS(3, storedConfig.getNumMembers());
@@ -205,9 +205,9 @@ TEST_F(ReplCoordHBTest,
     noi = net->getNextReadyRequest();
 
     assertMemberState(MemberState::RS_STARTUP, "2");
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
 
-    StatusWith<BSONObj> loadedConfig(getExternalState()->loadLocalConfigDocument(&txn));
+    StatusWith<BSONObj> loadedConfig(getExternalState()->loadLocalConfigDocument(&opCtx));
     ASSERT_NOT_OK(loadedConfig.getStatus()) << loadedConfig.getValue();
     exitNetwork();
 }
diff --git a/src/mongo/db/repl/replication_coordinator_impl_heartbeat_v1_test.cpp b/src/mongo/db/repl/replication_coordinator_impl_heartbeat_v1_test.cpp
index ccc53d0bff9..5f4101e9eb2 100644
--- a/src/mongo/db/repl/replication_coordinator_impl_heartbeat_v1_test.cpp
+++ b/src/mongo/db/repl/replication_coordinator_impl_heartbeat_v1_test.cpp
@@ -138,10 +138,10 @@ TEST_F(ReplCoordHBV1Test,
     noi = net->getNextReadyRequest();
 
     assertMemberState(MemberState::RS_STARTUP2);
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     ReplSetConfig storedConfig;
     ASSERT_OK(storedConfig.initialize(
-        unittest::assertGet(getExternalState()->loadLocalConfigDocument(&txn))));
+        unittest::assertGet(getExternalState()->loadLocalConfigDocument(&opCtx))));
     ASSERT_OK(storedConfig.validate());
     ASSERT_EQUALS(3, storedConfig.getConfigVersion());
     ASSERT_EQUALS(3, storedConfig.getNumMembers());
@@ -207,10 +207,10 @@ TEST_F(ReplCoordHBV1Test,
     noi = net->getNextReadyRequest();
 
     assertMemberState(MemberState::RS_ARBITER);
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     ReplSetConfig storedConfig;
     ASSERT_OK(storedConfig.initialize(
-        unittest::assertGet(getExternalState()->loadLocalConfigDocument(&txn))));
+        unittest::assertGet(getExternalState()->loadLocalConfigDocument(&opCtx))));
     ASSERT_OK(storedConfig.validate());
     ASSERT_EQUALS(3, storedConfig.getConfigVersion());
     ASSERT_EQUALS(3, storedConfig.getNumMembers());
@@ -276,9 +276,9 @@ TEST_F(ReplCoordHBV1Test,
     noi = net->getNextReadyRequest();
 
     assertMemberState(MemberState::RS_STARTUP, "2");
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
 
-    StatusWith<BSONObj> loadedConfig(getExternalState()->loadLocalConfigDocument(&txn));
+    StatusWith<BSONObj> loadedConfig(getExternalState()->loadLocalConfigDocument(&opCtx));
     ASSERT_NOT_OK(loadedConfig.getStatus()) << loadedConfig.getValue();
     exitNetwork();
 }
diff --git a/src/mongo/db/repl/replication_coordinator_impl_reconfig_test.cpp b/src/mongo/db/repl/replication_coordinator_impl_reconfig_test.cpp
index 69c5f2c6fb9..926b4a47a0f 100644
--- a/src/mongo/db/repl/replication_coordinator_impl_reconfig_test.cpp
+++ b/src/mongo/db/repl/replication_coordinator_impl_reconfig_test.cpp
@@ -60,9 +60,9 @@ TEST_F(ReplCoordTest, NodeReturnsNotYetInitializedWhenReconfigReceivedPriorToIni
     BSONObjBuilder result;
     ReplSetReconfigArgs args;
 
-    const auto txn = makeOperationContext();
+    const auto opCtx = makeOperationContext();
     ASSERT_EQUALS(ErrorCodes::NotYetInitialized,
-                  getReplCoord()->processReplSetReconfig(txn.get(), args, &result));
+                  getReplCoord()->processReplSetReconfig(opCtx.get(), args, &result));
     ASSERT_TRUE(result.obj().isEmpty());
 }
 
@@ -87,9 +87,9 @@ TEST_F(ReplCoordTest, NodeReturnsNotMasterWhenReconfigReceivedWhileSecondary) {
     BSONObjBuilder result;
     ReplSetReconfigArgs args;
     args.force = false;
-    const auto txn = makeOperationContext();
+    const auto opCtx = makeOperationContext();
     ASSERT_EQUALS(ErrorCodes::NotMaster,
-                  getReplCoord()->processReplSetReconfig(txn.get(), args, &result));
+                  getReplCoord()->processReplSetReconfig(opCtx.get(), args, &result));
     ASSERT_TRUE(result.obj().isEmpty());
 }
 
@@ -128,10 +128,10 @@ TEST_F(ReplCoordTest, NodeReturnsInvalidReplicaSetConfigWhenReconfigReceivedWith
                                                          << "node2:12345"
                                                          << "arbiterOnly"
                                                          << true)));
-    const auto txn = makeOperationContext();
+    const auto opCtx = makeOperationContext();
     // ErrorCodes::BadValue should be propagated from ReplSetConfig::initialize()
     ASSERT_EQUALS(ErrorCodes::InvalidReplicaSetConfig,
-                  getReplCoord()->processReplSetReconfig(txn.get(), args, &result));
+                  getReplCoord()->processReplSetReconfig(opCtx.get(), args, &result));
     ASSERT_TRUE(result.obj().isEmpty());
 }
 
@@ -165,9 +165,9 @@ TEST_F(ReplCoordTest, NodeReturnsInvalidReplicaSetConfigWhenReconfigReceivedWith
                                            << BSON("_id" << 2 << "host"
                                                          << "node2:12345")));
 
-    const auto txn = makeOperationContext();
+    const auto opCtx = makeOperationContext();
     ASSERT_EQUALS(ErrorCodes::InvalidReplicaSetConfig,
-                  getReplCoord()->processReplSetReconfig(txn.get(), args, &result));
+                  getReplCoord()->processReplSetReconfig(opCtx.get(), args, &result));
     ASSERT_TRUE(result.obj().isEmpty());
 }
 
@@ -205,9 +205,9 @@ TEST_F(ReplCoordTest, NodeReturnsInvalidReplicaSetConfigWhenReconfigReceivedWith
                              << "settings"
                              << BSON("replicaSetId" << OID::gen()));
 
-    const auto txn = makeOperationContext();
+    const auto opCtx = makeOperationContext();
     ASSERT_EQUALS(ErrorCodes::NewReplicaSetConfigurationIncompatible,
-                  getReplCoord()->processReplSetReconfig(txn.get(), args, &result));
+                  getReplCoord()->processReplSetReconfig(opCtx.get(), args, &result));
     ASSERT_TRUE(result.obj().isEmpty());
 }
 
@@ -242,18 +242,18 @@ TEST_F(ReplCoordTest,
                                            << BSON("_id" << 2 << "host"
                                                          << "node2:12345")));
 
-    const auto txn = makeOperationContext();
+    const auto opCtx = makeOperationContext();
     ASSERT_EQUALS(ErrorCodes::NewReplicaSetConfigurationIncompatible,
-                  getReplCoord()->processReplSetReconfig(txn.get(), args, &result));
+                  getReplCoord()->processReplSetReconfig(opCtx.get(), args, &result));
     ASSERT_TRUE(result.obj().isEmpty());
 }
 
 void doReplSetInitiate(ReplicationCoordinatorImpl* replCoord,
                        Status* status,
-                       OperationContext* txn) {
+                       OperationContext* opCtx) {
     BSONObjBuilder garbage;
     *status =
-        replCoord->processReplSetInitiate(txn,
+        replCoord->processReplSetInitiate(opCtx,
                                           BSON("_id"
                                                << "mySet"
                                                << "version"
@@ -268,7 +268,7 @@ void doReplSetInitiate(ReplicationCoordinatorImpl* replCoord,
 
 void doReplSetReconfig(ReplicationCoordinatorImpl* replCoord,
                        Status* status,
-                       OperationContext* txn) {
+                       OperationContext* opCtx) {
     BSONObjBuilder garbage;
     ReplSetReconfigArgs args;
     args.force = false;
@@ -284,7 +284,7 @@ void doReplSetReconfig(ReplicationCoordinatorImpl* replCoord,
                                                          << "node2:12345"
                                                          << "priority"
                                                          << 3)));
-    *status = replCoord->processReplSetReconfig(txn, args, &garbage);
+    *status = replCoord->processReplSetReconfig(opCtx, args, &garbage);
 }
 
 TEST_F(ReplCoordTest,
@@ -307,8 +307,9 @@ TEST_F(ReplCoordTest,
     simulateSuccessfulV1Election();
 
     Status status(ErrorCodes::InternalError, "Not Set");
-    const auto txn = makeOperationContext();
-    stdx::thread reconfigThread(stdx::bind(doReplSetReconfig, getReplCoord(), &status, txn.get()));
+    const auto opCtx = makeOperationContext();
+    stdx::thread reconfigThread(
+        stdx::bind(doReplSetReconfig, getReplCoord(), &status, opCtx.get()));
 
     NetworkInterfaceMock* net = getNet();
     getNet()->enterNetwork();
@@ -350,8 +351,9 @@ TEST_F(ReplCoordTest, NodeReturnsOutOfDiskSpaceWhenSavingANewConfigFailsDuringRe
     Status status(ErrorCodes::InternalError, "Not Set");
     getExternalState()->setStoreLocalConfigDocumentStatus(
         Status(ErrorCodes::OutOfDiskSpace, "The test set this"));
-    const auto txn = makeOperationContext();
-    stdx::thread reconfigThread(stdx::bind(doReplSetReconfig, getReplCoord(), &status, txn.get()));
+    const auto opCtx = makeOperationContext();
+    stdx::thread reconfigThread(
+        stdx::bind(doReplSetReconfig, getReplCoord(), &status, opCtx.get()));
 
     replyToReceivedHeartbeat();
     reconfigThread.join();
@@ -377,9 +379,10 @@ TEST_F(ReplCoordTest,
     simulateSuccessfulV1Election();
 
     Status status(ErrorCodes::InternalError, "Not Set");
-    const auto txn = makeOperationContext();
+    const auto opCtx = makeOperationContext();
     // first reconfig
-    stdx::thread reconfigThread(stdx::bind(doReplSetReconfig, getReplCoord(), &status, txn.get()));
+    stdx::thread reconfigThread(
+        stdx::bind(doReplSetReconfig, getReplCoord(), &status, opCtx.get()));
     getNet()->enterNetwork();
     getNet()->blackHole(getNet()->getNextReadyRequest());
     getNet()->exitNetwork();
@@ -398,10 +401,10 @@ TEST_F(ReplCoordTest,
                                            << BSON("_id" << 2 << "host"
                                                          << "node2:12345")));
     ASSERT_EQUALS(ErrorCodes::ConfigurationInProgress,
-                  getReplCoord()->processReplSetReconfig(txn.get(), args, &result));
+                  getReplCoord()->processReplSetReconfig(opCtx.get(), args, &result));
     ASSERT_TRUE(result.obj().isEmpty());
 
-    shutdown(txn.get());
+    shutdown(opCtx.get());
     reconfigThread.join();
 }
 
@@ -415,8 +418,8 @@ TEST_F(ReplCoordTest, NodeReturnsConfigurationInProgressWhenReceivingAReconfigWh
 
     // initiate
     Status status(ErrorCodes::InternalError, "Not Set");
-    const auto txn = makeOperationContext();
-    stdx::thread initateThread(stdx::bind(doReplSetInitiate, getReplCoord(), &status, txn.get()));
+    const auto opCtx = makeOperationContext();
+    stdx::thread initateThread(stdx::bind(doReplSetInitiate, getReplCoord(), &status, opCtx.get()));
     getNet()->enterNetwork();
     getNet()->blackHole(getNet()->getNextReadyRequest());
     getNet()->exitNetwork();
@@ -435,10 +438,10 @@ TEST_F(ReplCoordTest, NodeReturnsConfigurationInProgressWhenReceivingAReconfigWh
                                            << BSON("_id" << 2 << "host"
                                                          << "node2:12345")));
     ASSERT_EQUALS(ErrorCodes::ConfigurationInProgress,
-                  getReplCoord()->processReplSetReconfig(txn.get(), args, &result));
+                  getReplCoord()->processReplSetReconfig(opCtx.get(), args, &result));
     ASSERT_TRUE(result.obj().isEmpty());
 
-    shutdown(txn.get());
+    shutdown(opCtx.get());
     initateThread.join();
 }
 
@@ -462,8 +465,9 @@ TEST_F(ReplCoordTest, PrimaryNodeAcceptsNewConfigWhenReceivingAReconfigWithAComp
     simulateSuccessfulV1Election();
 
     Status status(ErrorCodes::InternalError, "Not Set");
-    const auto txn = makeOperationContext();
-    stdx::thread reconfigThread(stdx::bind(doReplSetReconfig, getReplCoord(), &status, txn.get()));
+    const auto opCtx = makeOperationContext();
+    stdx::thread reconfigThread(
+        stdx::bind(doReplSetReconfig, getReplCoord(), &status, opCtx.get()));
 
     NetworkInterfaceMock* net = getNet();
     getNet()->enterNetwork();
@@ -541,9 +545,9 @@ TEST_F(
     ReplSetReconfigArgs args;
     args.force = false;
     args.newConfigObj = config.toBSON();
-    const auto txn = makeOperationContext();
+    const auto opCtx = makeOperationContext();
     ASSERT_EQUALS(ErrorCodes::ConfigurationInProgress,
-                  getReplCoord()->processReplSetReconfig(txn.get(), args, &result));
+                  getReplCoord()->processReplSetReconfig(opCtx.get(), args, &result));
 
     getExternalState()->setStoreLocalConfigDocumentToHang(false);
 }
@@ -568,8 +572,9 @@ TEST_F(ReplCoordTest, NodeDoesNotAcceptHeartbeatReconfigWhileInTheMidstOfReconfi
 
     // start reconfigThread
     Status status(ErrorCodes::InternalError, "Not Set");
-    const auto txn = makeOperationContext();
-    stdx::thread reconfigThread(stdx::bind(doReplSetReconfig, getReplCoord(), &status, txn.get()));
+    const auto opCtx = makeOperationContext();
+    stdx::thread reconfigThread(
+        stdx::bind(doReplSetReconfig, getReplCoord(), &status, opCtx.get()));
 
     // wait for reconfigThread to create network requests to ensure the replication coordinator
     // is in state kConfigReconfiguring
@@ -609,7 +614,7 @@ TEST_F(ReplCoordTest, NodeDoesNotAcceptHeartbeatReconfigWhileInTheMidstOfReconfi
     stopCapturingLogMessages();
     ASSERT_EQUALS(
         1, countLogLinesContaining("because already in the midst of a configuration process"));
-    shutdown(txn.get());
+    shutdown(opCtx.get());
     reconfigThread.join();
     logger::globalLogDomain()->setMinimumLoggedSeverity(logger::LogSeverity::Log());
 }
@@ -644,13 +649,13 @@ TEST_F(ReplCoordTest, NodeAcceptsConfigFromAReconfigWithForceTrueWhileNotPrimary
                                                       << "node1:12345")
                                            << BSON("_id" << 2 << "host"
                                                          << "node2:12345")));
-    const auto txn = makeOperationContext();
+    const auto opCtx = makeOperationContext();
     ASSERT_EQUALS(ErrorCodes::NotMaster,
-                  getReplCoord()->processReplSetReconfig(txn.get(), args, &result));
+                  getReplCoord()->processReplSetReconfig(opCtx.get(), args, &result));
 
     // forced should succeed
     args.force = true;
-    ASSERT_OK(getReplCoord()->processReplSetReconfig(txn.get(), args, &result));
+    ASSERT_OK(getReplCoord()->processReplSetReconfig(opCtx.get(), args, &result));
     getReplCoord()->processReplSetGetConfig(&result);
 
     // ensure forced reconfig results in a random larger version
diff --git a/src/mongo/db/repl/replication_coordinator_impl_test.cpp b/src/mongo/db/repl/replication_coordinator_impl_test.cpp
index 3cb0d2d9e3b..ae8d5b5fe92 100644
--- a/src/mongo/db/repl/replication_coordinator_impl_test.cpp
+++ b/src/mongo/db/repl/replication_coordinator_impl_test.cpp
@@ -100,7 +100,7 @@ struct OpTimeWithTermOne {
     Timestamp timestamp;
 };
 
-void runSingleNodeElection(ServiceContext::UniqueOperationContext txn,
+void runSingleNodeElection(ServiceContext::UniqueOperationContext opCtx,
                            ReplicationCoordinatorImpl* replCoord,
                            executor::NetworkInterfaceMock* net) {
     replCoord->setMyLastAppliedOpTime(OpTime(Timestamp(1, 0), 0));
@@ -116,15 +116,15 @@ void runSingleNodeElection(ServiceContext::UniqueOperationContext txn,
     ASSERT(replCoord->getApplierState() == ReplicationCoordinator::ApplierState::Draining);
     ASSERT(replCoord->getMemberState().primary()) << replCoord->getMemberState().toString();
 
-    replCoord->signalDrainComplete(txn.get(), replCoord->getTerm());
+    replCoord->signalDrainComplete(opCtx.get(), replCoord->getTerm());
 }
 
 /**
  * Helper that kills an operation, taking the necessary locks.
  */
-void killOperation(OperationContext* txn) {
-    stdx::lock_guard<Client> lkClient(*txn->getClient());
-    txn->getServiceContext()->killOperation(txn);
+void killOperation(OperationContext* opCtx) {
+    stdx::lock_guard<Client> lkClient(*opCtx->getClient());
+    opCtx->getServiceContext()->killOperation(opCtx);
 }
 
 TEST_F(ReplCoordTest, NodeEntersStartup2StateWhenStartingUpWithValidLocalConfig) {
@@ -202,10 +202,10 @@ TEST_F(ReplCoordTest, NodeEntersStartupStateWhenStartingUpWithNoLocalConfig) {
 TEST_F(ReplCoordTest, NodeReturnsInvalidReplicaSetConfigWhenInitiatedWithAnEmptyConfig) {
     init("mySet");
     start(HostAndPort("node1", 12345));
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
     BSONObjBuilder result;
     ASSERT_EQUALS(ErrorCodes::InvalidReplicaSetConfig,
-                  getReplCoord()->processReplSetInitiate(txn.get(), BSONObj(), &result));
+                  getReplCoord()->processReplSetInitiate(opCtx.get(), BSONObj(), &result));
     ASSERT_EQUALS(MemberState::RS_STARTUP, getReplCoord()->getMemberState().s);
 }
 
@@ -215,12 +215,12 @@ TEST_F(ReplCoordTest,
     start(HostAndPort("node1", 12345));
     ASSERT_EQUALS(MemberState::RS_STARTUP, getReplCoord()->getMemberState().s);
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
     // Starting uninitialized, show that we can perform the initiate behavior.
     BSONObjBuilder result1;
     ASSERT_OK(
-        getReplCoord()->processReplSetInitiate(txn.get(),
+        getReplCoord()->processReplSetInitiate(opCtx.get(),
                                                BSON("_id"
                                                     << "mySet"
                                                     << "version"
@@ -236,7 +236,7 @@ TEST_F(ReplCoordTest,
     BSONObjBuilder result2;
     ASSERT_EQUALS(
         ErrorCodes::AlreadyInitialized,
-        getReplCoord()->processReplSetInitiate(txn.get(),
+        getReplCoord()->processReplSetInitiate(opCtx.get(),
                                                BSON("_id"
                                                     << "mySet"
                                                     << "version"
@@ -254,14 +254,14 @@ TEST_F(ReplCoordTest,
        NodeReturnsInvalidReplicaSetConfigWhenInitiatingViaANodeThatCannotBecomePrimary) {
     init("mySet");
     start(HostAndPort("node1", 12345));
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
     ASSERT_EQUALS(MemberState::RS_STARTUP, getReplCoord()->getMemberState().s);
 
     // Starting uninitialized, show that we can perform the initiate behavior.
     BSONObjBuilder result1;
     auto status =
-        getReplCoord()->processReplSetInitiate(txn.get(),
+        getReplCoord()->processReplSetInitiate(opCtx.get(),
                                                BSON("_id"
                                                     << "mySet"
                                                     << "version"
@@ -283,16 +283,16 @@ TEST_F(ReplCoordTest,
        InitiateShouldSucceedWithAValidConfigEvenIfItHasFailedWithAnInvalidConfigPreviously) {
     init("mySet");
     start(HostAndPort("node1", 12345));
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
     BSONObjBuilder result;
     ASSERT_EQUALS(ErrorCodes::InvalidReplicaSetConfig,
-                  getReplCoord()->processReplSetInitiate(txn.get(), BSONObj(), &result));
+                  getReplCoord()->processReplSetInitiate(opCtx.get(), BSONObj(), &result));
     ASSERT_EQUALS(MemberState::RS_STARTUP, getReplCoord()->getMemberState().s);
 
     // Having failed to initiate once, show that we can now initiate.
     BSONObjBuilder result1;
     ASSERT_OK(
-        getReplCoord()->processReplSetInitiate(txn.get(),
+        getReplCoord()->processReplSetInitiate(opCtx.get(),
                                                BSON("_id"
                                                     << "mySet"
                                                     << "version"
@@ -309,10 +309,10 @@ TEST_F(ReplCoordTest,
     BSONObjBuilder result;
     init("mySet");
     start(HostAndPort("node1", 12345));
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
     ASSERT_EQUALS(
         ErrorCodes::InvalidReplicaSetConfig,
-        getReplCoord()->processReplSetInitiate(txn.get(),
+        getReplCoord()->processReplSetInitiate(opCtx.get(),
                                                BSON("_id"
                                                     << "mySet"
                                                     << "version"
@@ -326,9 +326,9 @@ TEST_F(ReplCoordTest,
 void doReplSetInitiate(ReplicationCoordinatorImpl* replCoord, Status* status) {
     BSONObjBuilder garbage;
     auto client = getGlobalServiceContext()->makeClient("rsi");
-    auto txn = client->makeOperationContext();
+    auto opCtx = client->makeOperationContext();
     *status =
-        replCoord->processReplSetInitiate(txn.get(),
+        replCoord->processReplSetInitiate(opCtx.get(),
                                           BSON("_id"
                                                << "mySet"
                                                << "version"
@@ -411,13 +411,13 @@ TEST_F(ReplCoordTest,
        NodeReturnsInvalidReplicaSetConfigWhenInitiatingWithAConfigWithAMismatchedSetName) {
     init("mySet");
     start(HostAndPort("node1", 12345));
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
     ASSERT_EQUALS(MemberState::RS_STARTUP, getReplCoord()->getMemberState().s);
 
     BSONObjBuilder result1;
     ASSERT_EQUALS(
         ErrorCodes::InvalidReplicaSetConfig,
-        getReplCoord()->processReplSetInitiate(txn.get(),
+        getReplCoord()->processReplSetInitiate(opCtx.get(),
                                                BSON("_id"
                                                     << "wrongSet"
                                                     << "version"
@@ -432,11 +432,11 @@ TEST_F(ReplCoordTest,
 TEST_F(ReplCoordTest, NodeReturnsInvalidReplicaSetConfigWhenInitiatingWithAnEmptyConfig) {
     init("mySet");
     start(HostAndPort("node1", 12345));
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
     ASSERT_EQUALS(MemberState::RS_STARTUP, getReplCoord()->getMemberState().s);
 
     BSONObjBuilder result1;
-    auto status = getReplCoord()->processReplSetInitiate(txn.get(), BSONObj(), &result1);
+    auto status = getReplCoord()->processReplSetInitiate(opCtx.get(), BSONObj(), &result1);
     ASSERT_EQUALS(ErrorCodes::InvalidReplicaSetConfig, status);
     ASSERT_STRING_CONTAINS(status.reason(), "Missing expected field \"_id\"");
     ASSERT_EQUALS(MemberState::RS_STARTUP, getReplCoord()->getMemberState().s);
@@ -445,12 +445,12 @@ TEST_F(ReplCoordTest, NodeReturnsInvalidReplicaSetConfigWhenInitiatingWithAnEmpt
 TEST_F(ReplCoordTest, NodeReturnsInvalidReplicaSetConfigWhenInitiatingWithoutAn_idField) {
     init("mySet");
     start(HostAndPort("node1", 12345));
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
     ASSERT_EQUALS(MemberState::RS_STARTUP, getReplCoord()->getMemberState().s);
 
     BSONObjBuilder result1;
     auto status = getReplCoord()->processReplSetInitiate(
-        txn.get(),
+        opCtx.get(),
         BSON("version" << 1 << "members" << BSON_ARRAY(BSON("_id" << 0 << "host"
                                                                   << "node1:12345"))),
         &result1);
@@ -463,12 +463,12 @@ TEST_F(ReplCoordTest,
        NodeReturnsInvalidReplicaSetConfigWhenInitiatingWithAConfigVersionNotEqualToOne) {
     init("mySet");
     start(HostAndPort("node1", 12345));
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
     ASSERT_EQUALS(MemberState::RS_STARTUP, getReplCoord()->getMemberState().s);
 
     BSONObjBuilder result1;
     auto status =
-        getReplCoord()->processReplSetInitiate(txn.get(),
+        getReplCoord()->processReplSetInitiate(opCtx.get(),
                                                BSON("_id"
                                                     << "mySet"
                                                     << "version"
@@ -485,13 +485,13 @@ TEST_F(ReplCoordTest,
 TEST_F(ReplCoordTest, InitiateFailsWithoutReplSetFlag) {
     init("");
     start(HostAndPort("node1", 12345));
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
     ASSERT_EQUALS(MemberState::RS_STARTUP, getReplCoord()->getMemberState().s);
 
     BSONObjBuilder result1;
     ASSERT_EQUALS(
         ErrorCodes::NoReplicationEnabled,
-        getReplCoord()->processReplSetInitiate(txn.get(),
+        getReplCoord()->processReplSetInitiate(opCtx.get(),
                                                BSON("_id"
                                                     << "mySet"
                                                     << "version"
@@ -506,7 +506,7 @@ TEST_F(ReplCoordTest, InitiateFailsWithoutReplSetFlag) {
 TEST_F(ReplCoordTest, NodeReturnsOutOfDiskSpaceWhenInitiateCannotWriteConfigToDisk) {
     init("mySet");
     start(HostAndPort("node1", 12345));
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
     ASSERT_EQUALS(MemberState::RS_STARTUP, getReplCoord()->getMemberState().s);
 
     BSONObjBuilder result1;
@@ -514,7 +514,7 @@ TEST_F(ReplCoordTest, NodeReturnsOutOfDiskSpaceWhenInitiateCannotWriteConfigToDi
         Status(ErrorCodes::OutOfDiskSpace, "The test set this"));
     ASSERT_EQUALS(
         ErrorCodes::OutOfDiskSpace,
-        getReplCoord()->processReplSetInitiate(txn.get(),
+        getReplCoord()->processReplSetInitiate(opCtx.get(),
                                                BSON("_id"
                                                     << "mySet"
                                                     << "version"
@@ -602,7 +602,7 @@ TEST_F(ReplCoordTest, RollBackIDShouldIncreaseByOneWhenIncrementRollbackIDIsCall
 
 TEST_F(ReplCoordTest, NodeReturnsImmediatelyWhenAwaitReplicationIsRanAgainstAStandaloneNode) {
     init("");
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
     OpTimeWithTermOne time(100, 1);
 
@@ -613,7 +613,7 @@ TEST_F(ReplCoordTest, NodeReturnsImmediatelyWhenAwaitReplicationIsRanAgainstASta
     // Because we didn't set ReplSettings.replSet, it will think we're a standalone so
     // awaitReplication will always work.
     ReplicationCoordinator::StatusAndDuration statusAndDur =
-        getReplCoord()->awaitReplication(txn.get(), time, writeConcern);
+        getReplCoord()->awaitReplication(opCtx.get(), time, writeConcern);
     ASSERT_OK(statusAndDur.status);
 }
 
@@ -621,7 +621,7 @@ TEST_F(ReplCoordTest, NodeReturnsImmediatelyWhenAwaitReplicationIsRanAgainstAMas
     ReplSettings settings;
     settings.setMaster(true);
     init(settings);
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
     OpTimeWithTermOne time(100, 1);
 
@@ -631,7 +631,7 @@ TEST_F(ReplCoordTest, NodeReturnsImmediatelyWhenAwaitReplicationIsRanAgainstAMas
     writeConcern.wMode = WriteConcernOptions::kMajority;
     // w:majority always works on master/slave
     ReplicationCoordinator::StatusAndDuration statusAndDur =
-        getReplCoord()->awaitReplication(txn.get(), time, writeConcern);
+        getReplCoord()->awaitReplication(opCtx.get(), time, writeConcern);
     ASSERT_OK(statusAndDur.status);
 }
 
@@ -655,7 +655,7 @@ TEST_F(ReplCoordTest, NodeReturnsNotMasterWhenRunningAwaitReplicationAgainstASec
                                                   << 2))),
                        HostAndPort("node1", 12345));
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
     OpTimeWithTermOne time(100, 1);
 
@@ -666,7 +666,7 @@ TEST_F(ReplCoordTest, NodeReturnsNotMasterWhenRunningAwaitReplicationAgainstASec
 
     // Node should fail to awaitReplication when not primary.
     ReplicationCoordinator::StatusAndDuration statusAndDur =
-        getReplCoord()->awaitReplication(txn.get(), time, writeConcern);
+        getReplCoord()->awaitReplication(opCtx.get(), time, writeConcern);
     ASSERT_EQUALS(ErrorCodes::PrimarySteppedDown, statusAndDur.status);
 }
 
@@ -704,10 +704,10 @@ TEST_F(ReplCoordTest, NodeReturnsOkWhenRunningAwaitReplicationAgainstPrimaryWith
     simulateSuccessfulV1Election();
     ASSERT(getReplCoord()->getMemberState().primary());
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
     ReplicationCoordinator::StatusAndDuration statusAndDur =
-        getReplCoord()->awaitReplication(txn.get(), time, writeConcern);
+        getReplCoord()->awaitReplication(opCtx.get(), time, writeConcern);
     ASSERT_OK(statusAndDur.status);
 }
 
@@ -748,47 +748,47 @@ TEST_F(ReplCoordTest,
     writeConcern.wNumNodes = 1;
     writeConcern.syncMode = WriteConcernOptions::SyncMode::JOURNAL;
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
     // 1 node waiting for time 1
     ReplicationCoordinator::StatusAndDuration statusAndDur =
-        getReplCoord()->awaitReplication(txn.get(), time1, writeConcern);
+        getReplCoord()->awaitReplication(opCtx.get(), time1, writeConcern);
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
     getReplCoord()->setMyLastAppliedOpTime(time1);
     getReplCoord()->setMyLastDurableOpTime(time1);
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, writeConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, writeConcern);
     ASSERT_OK(statusAndDur.status);
 
     // 2 nodes waiting for time1
     writeConcern.wNumNodes = 2;
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, writeConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, writeConcern);
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
     // Applied is not durable and will not satisfy WriteConcern with SyncMode JOURNAL.
     ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 1, time1));
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, writeConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, writeConcern);
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
     ASSERT_OK(getReplCoord()->setLastDurableOptime_forTest(2, 1, time1));
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, writeConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, writeConcern);
     ASSERT_OK(statusAndDur.status);
 
     // 2 nodes waiting for time2
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, writeConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern);
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
     getReplCoord()->setMyLastAppliedOpTime(time2);
     getReplCoord()->setMyLastDurableOpTime(time2);
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, writeConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern);
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
     ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 2, time2));
     ASSERT_OK(getReplCoord()->setLastDurableOptime_forTest(2, 2, time2));
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, writeConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern);
     ASSERT_OK(statusAndDur.status);
 
     // 3 nodes waiting for time2
     writeConcern.wNumNodes = 3;
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, writeConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern);
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
     ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 3, time2));
     ASSERT_OK(getReplCoord()->setLastDurableOptime_forTest(2, 3, time2));
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, writeConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern);
     ASSERT_OK(statusAndDur.status);
 }
 
@@ -827,44 +827,44 @@ TEST_F(ReplCoordTest, NodeReturnsWriteConcernFailedUntilASufficientNumberOfNodes
     writeConcern.wTimeout = WriteConcernOptions::kNoWaiting;
     writeConcern.wNumNodes = 1;
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
 
     // 1 node waiting for time 1
     ReplicationCoordinator::StatusAndDuration statusAndDur =
-        getReplCoord()->awaitReplication(txn.get(), time1, writeConcern);
+        getReplCoord()->awaitReplication(opCtx.get(), time1, writeConcern);
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
     getReplCoord()->setMyLastAppliedOpTime(time1);
     getReplCoord()->setMyLastDurableOpTime(time1);
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, writeConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, writeConcern);
     ASSERT_OK(statusAndDur.status);
 
     // 2 nodes waiting for time1
     writeConcern.wNumNodes = 2;
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, writeConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, writeConcern);
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
     ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 1, time1));
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, writeConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, writeConcern);
     ASSERT_OK(statusAndDur.status);
 
     // 2 nodes waiting for time2
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, writeConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern);
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
     getReplCoord()->setMyLastAppliedOpTime(time2);
     getReplCoord()->setMyLastDurableOpTime(time2);
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, writeConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern);
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
     ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 2, time2));
     ASSERT_OK(getReplCoord()->setLastDurableOptime_forTest(2, 2, time2));
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, writeConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern);
     ASSERT_OK(statusAndDur.status);
 
     // 3 nodes waiting for time2
     writeConcern.wNumNodes = 3;
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, writeConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern);
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
     ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 3, time2));
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, writeConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern);
     ASSERT_OK(statusAndDur.status);
 }
 
@@ -872,7 +872,7 @@ TEST_F(ReplCoordTest,
        NodeReturnsUnknownReplWriteConcernWhenAwaitReplicationReceivesAnInvalidWriteConcernMode) {
     auto service = stdx::make_unique<ServiceContextNoop>();
     auto client = service->makeClient("test");
-    auto txn = client->makeOperationContext();
+    auto opCtx = client->makeOperationContext();
 
     assertStartSuccess(BSON("_id"
                             << "mySet"
@@ -904,7 +904,7 @@ TEST_F(ReplCoordTest,
     invalidWriteConcern.wMode = "fakemode";
 
     ReplicationCoordinator::StatusAndDuration statusAndDur =
-        getReplCoord()->awaitReplication(txn.get(), time1, invalidWriteConcern);
+        getReplCoord()->awaitReplication(opCtx.get(), time1, invalidWriteConcern);
     ASSERT_EQUALS(ErrorCodes::UnknownReplWriteConcern, statusAndDur.status);
 }
 
@@ -913,7 +913,7 @@ TEST_F(
     NodeReturnsWriteConcernFailedUntilASufficientSetOfNodesHaveTheWriteAndTheWriteIsInACommittedSnapshot) {
     auto service = stdx::make_unique<ServiceContextNoop>();
     auto client = service->makeClient("test");
-    auto txn = client->makeOperationContext();
+    auto opCtx = client->makeOperationContext();
 
     assertStartSuccess(
         BSON("_id"
@@ -988,11 +988,11 @@ TEST_F(
     getReplCoord()->setMyLastAppliedOpTime(time1);
     getReplCoord()->setMyLastDurableOpTime(time1);
     ReplicationCoordinator::StatusAndDuration statusAndDur =
-        getReplCoord()->awaitReplication(txn.get(), time1, majorityWriteConcern);
+        getReplCoord()->awaitReplication(opCtx.get(), time1, majorityWriteConcern);
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, multiDCWriteConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, multiDCWriteConcern);
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, multiRackWriteConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, multiRackWriteConcern);
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
 
     // Majority satisfied but not either custom mode
@@ -1000,56 +1000,57 @@ TEST_F(
     getReplCoord()->setLastDurableOptime_forTest(2, 1, time1);
     getReplCoord()->setLastAppliedOptime_forTest(2, 2, time1);
     getReplCoord()->setLastDurableOptime_forTest(2, 2, time1);
-    getReplCoord()->createSnapshot(txn.get(), time1, SnapshotName(1));
+    getReplCoord()->createSnapshot(opCtx.get(), time1, SnapshotName(1));
 
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, majorityWriteConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, majorityWriteConcern);
     ASSERT_OK(statusAndDur.status);
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, multiDCWriteConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, multiDCWriteConcern);
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, multiRackWriteConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, multiRackWriteConcern);
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
 
     // All modes satisfied
     getReplCoord()->setLastAppliedOptime_forTest(2, 3, time1);
     getReplCoord()->setLastDurableOptime_forTest(2, 3, time1);
 
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, majorityWriteConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, majorityWriteConcern);
     ASSERT_OK(statusAndDur.status);
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, multiDCWriteConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, multiDCWriteConcern);
     ASSERT_OK(statusAndDur.status);
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, multiRackWriteConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, multiRackWriteConcern);
     ASSERT_OK(statusAndDur.status);
 
     // Majority also waits for the committed snapshot to be newer than all snapshots reserved by
     // this operation. Custom modes not affected by this.
-    while (getReplCoord()->reserveSnapshotName(txn.get()) <= SnapshotName(1)) {
+    while (getReplCoord()->reserveSnapshotName(opCtx.get()) <= SnapshotName(1)) {
         // These unittests "cheat" and use SnapshotName(1) without advancing the counter. Reserve
         // another name if we didn't get a high enough one.
     }
 
     auto zeroOpTimeInCurrentTerm = OpTime(Timestamp(0, 0), 1);
-    ReplClientInfo::forClient(txn.get()->getClient()).setLastOp(zeroOpTimeInCurrentTerm);
+    ReplClientInfo::forClient(opCtx.get()->getClient()).setLastOp(zeroOpTimeInCurrentTerm);
     statusAndDur =
-        getReplCoord()->awaitReplicationOfLastOpForClient(txn.get(), majorityWriteConcern);
+        getReplCoord()->awaitReplicationOfLastOpForClient(opCtx.get(), majorityWriteConcern);
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
     statusAndDur =
-        getReplCoord()->awaitReplicationOfLastOpForClient(txn.get(), multiDCWriteConcern);
+        getReplCoord()->awaitReplicationOfLastOpForClient(opCtx.get(), multiDCWriteConcern);
     ASSERT_OK(statusAndDur.status);
     statusAndDur =
-        getReplCoord()->awaitReplicationOfLastOpForClient(txn.get(), multiRackWriteConcern);
+        getReplCoord()->awaitReplicationOfLastOpForClient(opCtx.get(), multiRackWriteConcern);
     ASSERT_OK(statusAndDur.status);
 
     // All modes satisfied
-    getReplCoord()->createSnapshot(txn.get(), time1, getReplCoord()->reserveSnapshotName(nullptr));
+    getReplCoord()->createSnapshot(
+        opCtx.get(), time1, getReplCoord()->reserveSnapshotName(nullptr));
 
     statusAndDur =
-        getReplCoord()->awaitReplicationOfLastOpForClient(txn.get(), majorityWriteConcern);
+        getReplCoord()->awaitReplicationOfLastOpForClient(opCtx.get(), majorityWriteConcern);
     ASSERT_OK(statusAndDur.status);
     statusAndDur =
-        getReplCoord()->awaitReplicationOfLastOpForClient(txn.get(), multiDCWriteConcern);
+        getReplCoord()->awaitReplicationOfLastOpForClient(opCtx.get(), multiDCWriteConcern);
     ASSERT_OK(statusAndDur.status);
     statusAndDur =
-        getReplCoord()->awaitReplicationOfLastOpForClient(txn.get(), multiRackWriteConcern);
+        getReplCoord()->awaitReplicationOfLastOpForClient(opCtx.get(), multiRackWriteConcern);
     ASSERT_OK(statusAndDur.status);
 
     // multiDC satisfied but not majority or multiRack
@@ -1058,11 +1059,11 @@ TEST_F(
     getReplCoord()->setLastAppliedOptime_forTest(2, 3, time2);
     getReplCoord()->setLastDurableOptime_forTest(2, 3, time2);
 
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, majorityWriteConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, majorityWriteConcern);
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, multiDCWriteConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, multiDCWriteConcern);
     ASSERT_OK(statusAndDur.status);
-    statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, multiRackWriteConcern);
+    statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, multiRackWriteConcern);
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
 }
 
@@ -1080,12 +1081,12 @@ public:
         : _replCoord(replCoord),
           _service(service),
           _client(service->makeClient("replAwaiter")),
-          _txn(_client->makeOperationContext()),
+          _opCtx(_client->makeOperationContext()),
           _finished(false),
           _result(ReplicationCoordinator::StatusAndDuration(Status::OK(), Milliseconds(0))) {}
 
     OperationContext* getOperationContext() {
-        return _txn.get();
+        return _opCtx.get();
     }
 
     void setOpTime(const OpTime& ot) {
@@ -1116,14 +1117,14 @@ public:
 
 private:
     void _awaitReplication() {
-        _result = _replCoord->awaitReplication(_txn.get(), _optime, _writeConcern);
+        _result = _replCoord->awaitReplication(_opCtx.get(), _optime, _writeConcern);
         _finished = true;
     }
 
     ReplicationCoordinatorImpl* _replCoord;
     ServiceContext* _service;
     ServiceContext::UniqueClient _client;
-    ServiceContext::UniqueOperationContext _txn;
+    ServiceContext::UniqueOperationContext _opCtx;
     bool _finished;
     OpTime _optime;
     WriteConcernOptions _writeConcern;
@@ -1286,8 +1287,8 @@ TEST_F(ReplCoordTest,
     ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 1, time1));
     ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 2, time1));
     {
-        auto txn = makeOperationContext();
-        shutdown(txn.get());
+        auto opCtx = makeOperationContext();
+        shutdown(opCtx.get());
     }
     ReplicationCoordinator::StatusAndDuration statusAndDur = awaiter.getResult();
     ASSERT_EQUALS(ErrorCodes::ShutdownInProgress, statusAndDur.status);
@@ -1320,7 +1321,7 @@ TEST_F(ReplCoordTest, NodeReturnsNotMasterWhenSteppingDownBeforeSatisfyingAWrite
     getReplCoord()->setMyLastDurableOpTime(OpTimeWithTermOne(100, 0));
     simulateSuccessfulV1Election();
 
-    const auto txn = makeOperationContext();
+    const auto opCtx = makeOperationContext();
     ReplicationAwaiter awaiter(getReplCoord(), getServiceContext());
 
     OpTimeWithTermOne time1(100, 1);
@@ -1336,7 +1337,7 @@ TEST_F(ReplCoordTest, NodeReturnsNotMasterWhenSteppingDownBeforeSatisfyingAWrite
     awaiter.start();
     ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 1, time1));
     ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 2, time1));
-    ASSERT_OK(getReplCoord()->stepDown(txn.get(), true, Milliseconds(0), Milliseconds(1000)));
+    ASSERT_OK(getReplCoord()->stepDown(opCtx.get(), true, Milliseconds(0), Milliseconds(1000)));
     ReplicationCoordinator::StatusAndDuration statusAndDur = awaiter.getResult();
     ASSERT_EQUALS(ErrorCodes::PrimarySteppedDown, statusAndDur.status);
     awaiter.reset();
@@ -1391,11 +1392,11 @@ protected:
         static SharedClientAndOperation make(ServiceContext* serviceContext) {
             SharedClientAndOperation result;
             result.client = serviceContext->makeClient("StepDownThread");
-            result.txn = result.client->makeOperationContext();
+            result.opCtx = result.client->makeOperationContext();
             return result;
         }
         std::shared_ptr<Client> client;
-        std::shared_ptr<OperationContext> txn;
+        std::shared_ptr<OperationContext> opCtx;
     };
 
     std::pair<SharedClientAndOperation, stdx::future<boost::optional<Status>>> stepDown_nonBlocking(
@@ -1405,7 +1406,7 @@ protected:
             [=](PromisedClientAndOperation operationPromise) -> boost::optional<Status> {
                 auto result = SharedClientAndOperation::make(getServiceContext());
                 operationPromise.set_value(result);
-                return getReplCoord()->stepDown(result.txn.get(), force, waitTime, stepDownTime);
+                return getReplCoord()->stepDown(result.opCtx.get(), force, waitTime, stepDownTime);
             });
         auto result = task.get_future();
         PromisedClientAndOperation operationPromise;
@@ -1443,9 +1444,9 @@ private:
 TEST_F(ReplCoordTest, NodeReturnsBadValueWhenUpdateTermIsRunAgainstANonReplNode) {
     init(ReplSettings());
     ASSERT_TRUE(ReplicationCoordinator::modeNone == getReplCoord()->getReplicationMode());
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
-    ASSERT_EQUALS(ErrorCodes::BadValue, getReplCoord()->updateTerm(txn.get(), 0).code());
+    ASSERT_EQUALS(ErrorCodes::BadValue, getReplCoord()->updateTerm(opCtx.get(), 0).code());
 }
 
 TEST_F(ReplCoordTest, NodeChangesTermAndStepsDownWhenAndOnlyWhenUpdateTermSuppliesAHigherTerm) {
@@ -1471,31 +1472,31 @@ TEST_F(ReplCoordTest, NodeChangesTermAndStepsDownWhenAndOnlyWhenUpdateTermSuppli
     ASSERT_TRUE(getReplCoord()->getMemberState().secondary());
 
     simulateSuccessfulV1Election();
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
 
     ASSERT_EQUALS(1, getReplCoord()->getTerm());
     ASSERT_TRUE(getReplCoord()->getMemberState().primary());
 
     // lower term, no change
-    ASSERT_OK(getReplCoord()->updateTerm(txn.get(), 0));
+    ASSERT_OK(getReplCoord()->updateTerm(opCtx.get(), 0));
     ASSERT_EQUALS(1, getReplCoord()->getTerm());
     ASSERT_TRUE(getReplCoord()->getMemberState().primary());
 
     // same term, no change
-    ASSERT_OK(getReplCoord()->updateTerm(txn.get(), 1));
+    ASSERT_OK(getReplCoord()->updateTerm(opCtx.get(), 1));
     ASSERT_EQUALS(1, getReplCoord()->getTerm());
     ASSERT_TRUE(getReplCoord()->getMemberState().primary());
 
     // higher term, step down and change term
     executor::TaskExecutor::CallbackHandle cbHandle;
-    ASSERT_EQUALS(ErrorCodes::StaleTerm, getReplCoord()->updateTerm(txn.get(), 2).code());
+    ASSERT_EQUALS(ErrorCodes::StaleTerm, getReplCoord()->updateTerm(opCtx.get(), 2).code());
     // Term hasn't been incremented yet, as we need another try to update it after stepdown.
     ASSERT_EQUALS(1, getReplCoord()->getTerm());
     ASSERT_TRUE(getReplCoord()->getMemberState().secondary());
 
     // Now update term should actually update the term, as stepdown is complete.
-    ASSERT_EQUALS(ErrorCodes::StaleTerm, getReplCoord()->updateTerm(txn.get(), 2).code());
+    ASSERT_EQUALS(ErrorCodes::StaleTerm, getReplCoord()->updateTerm(opCtx.get(), 2).code());
     ASSERT_EQUALS(2, getReplCoord()->getTerm());
 }
 
@@ -1576,7 +1577,7 @@ TEST_F(ReplCoordTest, ConcurrentStepDownShouldNotSignalTheSameFinishEventMoreTha
 }
 
 TEST_F(StepDownTest, NodeReturnsNotMasterWhenAskedToStepDownAsANonPrimaryNode) {
-    const auto txn = makeOperationContext();
+    const auto opCtx = makeOperationContext();
 
     OpTimeWithTermOne optime1(100, 1);
     // All nodes are caught up
@@ -1585,7 +1586,7 @@ TEST_F(StepDownTest, NodeReturnsNotMasterWhenAskedToStepDownAsANonPrimaryNode) {
     ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(1, 1, optime1));
     ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(1, 2, optime1));
 
-    Status status = getReplCoord()->stepDown(txn.get(), false, Milliseconds(0), Milliseconds(0));
+    Status status = getReplCoord()->stepDown(opCtx.get(), false, Milliseconds(0), Milliseconds(0));
     ASSERT_EQUALS(ErrorCodes::NotMaster, status);
     ASSERT_TRUE(getReplCoord()->getMemberState().secondary());
 }
@@ -1601,12 +1602,13 @@ TEST_F(StepDownTest,
 
     simulateSuccessfulV1Election();
 
-    const auto txn = makeOperationContext();
+    const auto opCtx = makeOperationContext();
 
     // Make sure stepDown cannot grab the global shared lock
-    Lock::GlobalWrite lk(txn->lockState());
+    Lock::GlobalWrite lk(opCtx->lockState());
 
-    Status status = getReplCoord()->stepDown(txn.get(), false, Milliseconds(0), Milliseconds(1000));
+    Status status =
+        getReplCoord()->stepDown(opCtx.get(), false, Milliseconds(0), Milliseconds(1000));
     ASSERT_EQUALS(ErrorCodes::ExceededTimeLimit, status);
     ASSERT_TRUE(getReplCoord()->getMemberState().primary());
 }
@@ -1710,10 +1712,10 @@ TEST_F(
     getNet()->runReadyNetworkOperations();
     exitNetwork();
 
-    const auto txn = makeOperationContext();
+    const auto opCtx = makeOperationContext();
 
     ASSERT_TRUE(getReplCoord()->getMemberState().primary());
-    auto status = getReplCoord()->stepDown(txn.get(), false, Milliseconds(0), Milliseconds(1000));
+    auto status = getReplCoord()->stepDown(opCtx.get(), false, Milliseconds(0), Milliseconds(1000));
     ASSERT_EQUALS(ErrorCodes::ExceededTimeLimit, status);
     ASSERT_TRUE(getReplCoord()->getMemberState().primary());
 }
@@ -1744,10 +1746,10 @@ TEST_F(StepDownTestFiveNode,
     getNet()->runReadyNetworkOperations();
     exitNetwork();
 
-    const auto txn = makeOperationContext();
+    const auto opCtx = makeOperationContext();
 
     ASSERT_TRUE(getReplCoord()->getMemberState().primary());
-    auto status = getReplCoord()->stepDown(txn.get(), false, Milliseconds(0), Milliseconds(1000));
+    auto status = getReplCoord()->stepDown(opCtx.get(), false, Milliseconds(0), Milliseconds(1000));
     ASSERT_EQUALS(ErrorCodes::ExceededTimeLimit, status);
     ASSERT_TRUE(getReplCoord()->getMemberState().primary());
 }
@@ -1779,10 +1781,10 @@ TEST_F(
     getNet()->runReadyNetworkOperations();
     exitNetwork();
 
-    const auto txn = makeOperationContext();
+    const auto opCtx = makeOperationContext();
 
     ASSERT_TRUE(getReplCoord()->getMemberState().primary());
-    ASSERT_OK(getReplCoord()->stepDown(txn.get(), false, Milliseconds(0), Milliseconds(1000)));
+    ASSERT_OK(getReplCoord()->stepDown(opCtx.get(), false, Milliseconds(0), Milliseconds(1000)));
     enterNetwork();  // So we can safely inspect the topology coordinator
     ASSERT_EQUALS(getNet()->now() + Seconds(1), getTopoCoord().getStepDownTime());
     ASSERT_TRUE(getTopoCoord().getMemberState().secondary());
@@ -1802,9 +1804,9 @@ TEST_F(ReplCoordTest, NodeBecomesPrimaryAgainWhenStepDownTimeoutExpiresInASingle
                                                      << "test1:1234"))),
                        HostAndPort("test1", 1234));
     runSingleNodeElection(makeOperationContext(), getReplCoord(), getNet());
-    const auto txn = makeOperationContext();
+    const auto opCtx = makeOperationContext();
 
-    ASSERT_OK(getReplCoord()->stepDown(txn.get(), true, Milliseconds(0), Milliseconds(1000)));
+    ASSERT_OK(getReplCoord()->stepDown(opCtx.get(), true, Milliseconds(0), Milliseconds(1000)));
     getNet()->enterNetwork();  // Must do this before inspecting the topocoord
     Date_t stepdownUntil = getNet()->now() + Seconds(1);
     ASSERT_EQUALS(stepdownUntil, getTopoCoord().getStepDownTime());
@@ -1833,10 +1835,10 @@ TEST_F(StepDownTest,
 
     simulateSuccessfulV1Election();
 
-    const auto txn = makeOperationContext();
+    const auto opCtx = makeOperationContext();
 
     // Try to stepDown but time out because no secondaries are caught up.
-    auto status = repl->stepDown(txn.get(), false, Milliseconds(0), Milliseconds(1000));
+    auto status = repl->stepDown(opCtx.get(), false, Milliseconds(0), Milliseconds(1000));
     ASSERT_EQUALS(ErrorCodes::ExceededTimeLimit, status);
     ASSERT_TRUE(repl->getMemberState().primary());
 
@@ -1851,7 +1853,7 @@ TEST_F(StepDownTest,
     }
     getNet()->exitNetwork();
     ASSERT_TRUE(repl->getMemberState().primary());
-    status = repl->stepDown(txn.get(), true, Milliseconds(0), Milliseconds(1000));
+    status = repl->stepDown(opCtx.get(), true, Milliseconds(0), Milliseconds(1000));
     ASSERT_OK(status);
     ASSERT_TRUE(repl->getMemberState().secondary());
 }
@@ -2004,7 +2006,7 @@ TEST_F(StepDownTest, NodeReturnsInterruptedWhenInterruptedDuringStepDown) {
 
     // stepDown where the secondary actually has to catch up before the stepDown can succeed.
     auto result = stepDown_nonBlocking(false, Seconds(10), Seconds(60));
-    killOperation(result.first.txn.get());
+    killOperation(result.first.opCtx.get());
     ASSERT_EQUALS(ErrorCodes::Interrupted, *result.second.get());
     ASSERT_TRUE(repl->getMemberState().primary());
 }
@@ -2347,11 +2349,11 @@ TEST_F(ReplCoordTest, DoNotAllowMaintenanceModeWhilePrimary) {
     ASSERT_EQUALS(ErrorCodes::NotSecondary, status);
     ASSERT_TRUE(getReplCoord()->getMemberState().primary());
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
 
     // Step down from primary.
-    getReplCoord()->updateTerm(txn.get(), getReplCoord()->getTerm() + 1);
+    getReplCoord()->updateTerm(opCtx.get(), getReplCoord()->getTerm() + 1);
     ASSERT_OK(getReplCoord()->waitForMemberState(MemberState::RS_SECONDARY, Seconds(1)));
 
     status = getReplCoord()->setMaintenanceMode(false);
@@ -2383,11 +2385,11 @@ TEST_F(ReplCoordTest, DoNotAllowSettingMaintenanceModeWhileConductingAnElection)
     // TODO this election shouldn't have to happen.
     simulateSuccessfulV1Election();
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
 
     // Step down from primary.
-    getReplCoord()->updateTerm(txn.get(), getReplCoord()->getTerm() + 1);
+    getReplCoord()->updateTerm(opCtx.get(), getReplCoord()->getTerm() + 1);
     getReplCoord()->waitForMemberState(MemberState::RS_SECONDARY, Milliseconds(10 * 1000));
 
     // Can't modify maintenance mode when running for election (before and after dry run).
@@ -2514,7 +2516,7 @@ TEST_F(ReplCoordTest, NodeDoesNotIncludeItselfWhenRunningGetHostsWrittenToInMast
     settings.setMaster(true);
     init(settings);
     HostAndPort clientHost("node2:12345");
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
 
     OID client = OID::gen();
@@ -2524,7 +2526,7 @@ TEST_F(ReplCoordTest, NodeDoesNotIncludeItselfWhenRunningGetHostsWrittenToInMast
     getExternalState()->setClientHostAndPort(clientHost);
     HandshakeArgs handshake;
     ASSERT_OK(handshake.initialize(BSON("handshake" << client)));
-    ASSERT_OK(getReplCoord()->processHandshake(txn.get(), handshake));
+    ASSERT_OK(getReplCoord()->processHandshake(opCtx.get(), handshake));
 
     getReplCoord()->setMyLastAppliedOpTime(time2);
     getReplCoord()->setMyLastDurableOpTime(time2);
@@ -2675,11 +2677,11 @@ TEST_F(ReplCoordTest, IsMasterWithCommittedSnapshot) {
     time_t majorityWriteDate = 100;
     OpTime majorityOpTime = OpTime(Timestamp(majorityWriteDate, 1), 1);
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
     getReplCoord()->setMyLastAppliedOpTime(opTime);
     getReplCoord()->setMyLastDurableOpTime(opTime);
-    getReplCoord()->createSnapshot(txn.get(), majorityOpTime, SnapshotName(1));
+    getReplCoord()->createSnapshot(opCtx.get(), majorityOpTime, SnapshotName(1));
     ASSERT_EQUALS(majorityOpTime, getReplCoord()->getCurrentCommittedSnapshotOpTime());
 
     IsMasterResponse response;
@@ -2695,8 +2697,8 @@ TEST_F(ReplCoordTest, LogAMessageWhenShutDownBeforeReplicationStartUpFinished) {
     init();
     startCapturingLogMessages();
     {
-        auto txn = makeOperationContext();
-        getReplCoord()->shutdown(txn.get());
+        auto opCtx = makeOperationContext();
+        getReplCoord()->shutdown(opCtx.get());
     }
     stopCapturingLogMessages();
     ASSERT_EQUALS(1, countLogLinesContaining("shutdown() called before startup() finished"));
@@ -2735,11 +2737,11 @@ TEST_F(ReplCoordTest, DoNotProcessSelfWhenUpdatePositionContainsInfoAboutSelf) {
     writeConcern.wTimeout = WriteConcernOptions::kNoWaiting;
     writeConcern.wNumNodes = 1;
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
 
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
-                  getReplCoord()->awaitReplication(txn.get(), time2, writeConcern).status);
+                  getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern).status);
 
     // receive updatePosition containing ourself, should not process the update for self
     UpdatePositionArgs args;
@@ -2757,7 +2759,7 @@ TEST_F(ReplCoordTest, DoNotProcessSelfWhenUpdatePositionContainsInfoAboutSelf) {
 
     ASSERT_OK(getReplCoord()->processReplSetUpdatePosition(args, 0));
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
-                  getReplCoord()->awaitReplication(txn.get(), time2, writeConcern).status);
+                  getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern).status);
 }
 
 TEST_F(ReplCoordTest, DoNotProcessSelfWhenOldUpdatePositionContainsInfoAboutSelf) {
@@ -2794,11 +2796,11 @@ TEST_F(ReplCoordTest, DoNotProcessSelfWhenOldUpdatePositionContainsInfoAboutSelf
     writeConcern.wTimeout = WriteConcernOptions::kNoWaiting;
     writeConcern.wNumNodes = 1;
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
 
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
-                  getReplCoord()->awaitReplication(txn.get(), time2, writeConcern).status);
+                  getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern).status);
 
     // receive updatePosition containing ourself, should not process the update for self
     OldUpdatePositionArgs args;
@@ -2814,7 +2816,7 @@ TEST_F(ReplCoordTest, DoNotProcessSelfWhenOldUpdatePositionContainsInfoAboutSelf
 
     ASSERT_OK(getReplCoord()->processReplSetUpdatePosition(args, 0));
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
-                  getReplCoord()->awaitReplication(txn.get(), time2, writeConcern).status);
+                  getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern).status);
 }
 
 TEST_F(ReplCoordTest, DoNotProcessUpdatePositionWhenItsConfigVersionIsIncorrect) {
@@ -2864,14 +2866,14 @@ TEST_F(ReplCoordTest, DoNotProcessUpdatePositionWhenItsConfigVersionIsIncorrect)
                                                       << UpdatePositionArgs::kAppliedOpTimeFieldName
                                                       << time2.toBSON())))));
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
 
     long long cfgver;
     ASSERT_EQUALS(ErrorCodes::InvalidReplicaSetConfig,
                   getReplCoord()->processReplSetUpdatePosition(args, &cfgver));
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
-                  getReplCoord()->awaitReplication(txn.get(), time2, writeConcern).status);
+                  getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern).status);
 }
 
 TEST_F(ReplCoordTest, DoNotProcessOldUpdatePositionWhenItsConfigVersionIsIncorrect) {
@@ -2920,14 +2922,14 @@ TEST_F(ReplCoordTest, DoNotProcessOldUpdatePositionWhenItsConfigVersionIsIncorre
                                                       << OldUpdatePositionArgs::kOpTimeFieldName
                                                       << time2.timestamp)))));
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
 
     long long cfgver;
     ASSERT_EQUALS(ErrorCodes::InvalidReplicaSetConfig,
                   getReplCoord()->processReplSetUpdatePosition(args, &cfgver));
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
-                  getReplCoord()->awaitReplication(txn.get(), time2, writeConcern).status);
+                  getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern).status);
 }
 
 TEST_F(ReplCoordTest, DoNotProcessUpdatePositionOfMembersWhoseIdsAreNotInTheConfig) {
@@ -2977,12 +2979,12 @@ TEST_F(ReplCoordTest, DoNotProcessUpdatePositionOfMembersWhoseIdsAreNotInTheConf
                                                       << UpdatePositionArgs::kAppliedOpTimeFieldName
                                                       << time2.toBSON())))));
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
 
     ASSERT_EQUALS(ErrorCodes::NodeNotFound, getReplCoord()->processReplSetUpdatePosition(args, 0));
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
-                  getReplCoord()->awaitReplication(txn.get(), time2, writeConcern).status);
+                  getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern).status);
 }
 
 TEST_F(ReplCoordTest, DoNotProcessOldUpdatePositionOfMembersWhoseIdsAreNotInTheConfig) {
@@ -3031,12 +3033,12 @@ TEST_F(ReplCoordTest, DoNotProcessOldUpdatePositionOfMembersWhoseIdsAreNotInTheC
                                                       << OldUpdatePositionArgs::kOpTimeFieldName
                                                       << time2.timestamp)))));
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
 
     ASSERT_EQUALS(ErrorCodes::NodeNotFound, getReplCoord()->processReplSetUpdatePosition(args, 0));
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
-                  getReplCoord()->awaitReplication(txn.get(), time2, writeConcern).status);
+                  getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern).status);
 }
 
 TEST_F(ReplCoordTest,
@@ -3095,19 +3097,19 @@ TEST_F(ReplCoordTest,
                                                    << OldUpdatePositionArgs::kOpTimeFieldName
                                                    << time2.timestamp)))));
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
 
     ASSERT_OK(getReplCoord()->processReplSetUpdatePosition(args, 0));
-    ASSERT_OK(getReplCoord()->awaitReplication(txn.get(), time2, writeConcern).status);
+    ASSERT_OK(getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern).status);
 
     writeConcern.wNumNodes = 3;
-    ASSERT_OK(getReplCoord()->awaitReplication(txn.get(), time2, writeConcern).status);
+    ASSERT_OK(getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern).status);
 }
 
 void doReplSetReconfig(ReplicationCoordinatorImpl* replCoord, Status* status) {
     auto client = getGlobalServiceContext()->makeClient("rsr");
-    auto txn = client->makeOperationContext();
+    auto opCtx = client->makeOperationContext();
 
     BSONObjBuilder garbage;
     ReplSetReconfigArgs args;
@@ -3125,7 +3127,7 @@ void doReplSetReconfig(ReplicationCoordinatorImpl* replCoord, Status* status) {
                                                          << "node2:12345")
                                            << BSON("_id" << 2 << "host"
                                                          << "node3:12345")));
-    *status = replCoord->processReplSetReconfig(txn.get(), args, &garbage);
+    *status = replCoord->processReplSetReconfig(opCtx.get(), args, &garbage);
 }
 
 TEST_F(ReplCoordTest, AwaitReplicationShouldResolveAsNormalDuringAReconfig) {
@@ -3205,7 +3207,7 @@ TEST_F(ReplCoordTest, AwaitReplicationShouldResolveAsNormalDuringAReconfig) {
 
 void doReplSetReconfigToFewer(ReplicationCoordinatorImpl* replCoord, Status* status) {
     auto client = getGlobalServiceContext()->makeClient("rsr");
-    auto txn = client->makeOperationContext();
+    auto opCtx = client->makeOperationContext();
 
     BSONObjBuilder garbage;
     ReplSetReconfigArgs args;
@@ -3219,7 +3221,7 @@ void doReplSetReconfigToFewer(ReplicationCoordinatorImpl* replCoord, Status* sta
                                                       << "node1:12345")
                                            << BSON("_id" << 2 << "host"
                                                          << "node3:12345")));
-    *status = replCoord->processReplSetReconfig(txn.get(), args, &garbage);
+    *status = replCoord->processReplSetReconfig(opCtx.get(), args, &garbage);
 }
 
 TEST_F(
@@ -3323,11 +3325,11 @@ TEST_F(ReplCoordTest,
     simulateSuccessfulV1Election();
 
     OpTime time(Timestamp(100, 2), 1);
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
     getReplCoord()->setMyLastAppliedOpTime(time);
     getReplCoord()->setMyLastDurableOpTime(time);
-    getReplCoord()->createSnapshot(txn.get(), time, SnapshotName(1));
+    getReplCoord()->createSnapshot(opCtx.get(), time, SnapshotName(1));
     ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 1, time));
 
 
@@ -3350,7 +3352,7 @@ TEST_F(ReplCoordTest,
     writeConcern.syncMode = WriteConcernOptions::SyncMode::NONE;
 
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
-                  getReplCoord()->awaitReplication(txn.get(), time, writeConcern2).status);
+                  getReplCoord()->awaitReplication(opCtx.get(), time, writeConcern2).status);
 
     // reconfig to three nodes
     Status status(ErrorCodes::InternalError, "Not Set");
@@ -3413,30 +3415,30 @@ TEST_F(ReplCoordTest,
     majorityWriteConcern.wMode = WriteConcernOptions::kMajority;
     majorityWriteConcern.syncMode = WriteConcernOptions::SyncMode::JOURNAL;
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
 
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
-                  getReplCoord()->awaitReplication(txn.get(), time, majorityWriteConcern).status);
+                  getReplCoord()->awaitReplication(opCtx.get(), time, majorityWriteConcern).status);
 
     ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 1, time));
     ASSERT_OK(getReplCoord()->setLastDurableOptime_forTest(2, 1, time));
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
-                  getReplCoord()->awaitReplication(txn.get(), time, majorityWriteConcern).status);
+                  getReplCoord()->awaitReplication(opCtx.get(), time, majorityWriteConcern).status);
 
     // this member does not vote and as a result should not count towards write concern
     ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 3, time));
     ASSERT_OK(getReplCoord()->setLastDurableOptime_forTest(2, 3, time));
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
-                  getReplCoord()->awaitReplication(txn.get(), time, majorityWriteConcern).status);
+                  getReplCoord()->awaitReplication(opCtx.get(), time, majorityWriteConcern).status);
 
     ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 2, time));
     ASSERT_OK(getReplCoord()->setLastDurableOptime_forTest(2, 2, time));
     ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
-                  getReplCoord()->awaitReplication(txn.get(), time, majorityWriteConcern).status);
+                  getReplCoord()->awaitReplication(opCtx.get(), time, majorityWriteConcern).status);
 
-    getReplCoord()->createSnapshot(txn.get(), time, SnapshotName(1));
-    ASSERT_OK(getReplCoord()->awaitReplication(txn.get(), time, majorityWriteConcern).status);
+    getReplCoord()->createSnapshot(opCtx.get(), time, SnapshotName(1));
+    ASSERT_OK(getReplCoord()->awaitReplication(opCtx.get(), time, majorityWriteConcern).status);
 }
 
 TEST_F(ReplCoordTest,
@@ -3527,12 +3529,13 @@ TEST_F(ReplCoordTest, NodeReturnsShutdownInProgressWhenWaitingUntilAnOpTimeDurin
     getReplCoord()->setMyLastAppliedOpTime(OpTimeWithTermOne(10, 0));
     getReplCoord()->setMyLastDurableOpTime(OpTimeWithTermOne(10, 0));
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
-    shutdown(txn.get());
+    shutdown(opCtx.get());
 
     auto status = getReplCoord()->waitUntilOpTimeForRead(
-        txn.get(), ReadConcernArgs(OpTimeWithTermOne(50, 0), ReadConcernLevel::kLocalReadConcern));
+        opCtx.get(),
+        ReadConcernArgs(OpTimeWithTermOne(50, 0), ReadConcernLevel::kLocalReadConcern));
     ASSERT_EQ(status, ErrorCodes::ShutdownInProgress);
 }
 
@@ -3551,11 +3554,12 @@ TEST_F(ReplCoordTest, NodeReturnsInterruptedWhenWaitingUntilAnOpTimeIsInterrupte
     getReplCoord()->setMyLastAppliedOpTime(OpTimeWithTermOne(10, 0));
     getReplCoord()->setMyLastDurableOpTime(OpTimeWithTermOne(10, 0));
 
-    const auto txn = makeOperationContext();
-    killOperation(txn.get());
+    const auto opCtx = makeOperationContext();
+    killOperation(opCtx.get());
 
     auto status = getReplCoord()->waitUntilOpTimeForRead(
-        txn.get(), ReadConcernArgs(OpTimeWithTermOne(50, 0), ReadConcernLevel::kLocalReadConcern));
+        opCtx.get(),
+        ReadConcernArgs(OpTimeWithTermOne(50, 0), ReadConcernLevel::kLocalReadConcern));
     ASSERT_EQ(status, ErrorCodes::Interrupted);
 }
 
@@ -3571,9 +3575,9 @@ TEST_F(ReplCoordTest, NodeReturnsOkImmediatelyWhenWaitingUntilOpTimePassesNoOpTi
                                                << 0))),
                        HostAndPort("node1", 12345));
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
-    ASSERT_OK(getReplCoord()->waitUntilOpTimeForRead(txn.get(), ReadConcernArgs()));
+    ASSERT_OK(getReplCoord()->waitUntilOpTimeForRead(opCtx.get(), ReadConcernArgs()));
 }
 
 TEST_F(ReplCoordTest, NodeReturnsOkImmediatelyWhenWaitingUntilOpTimePassesAnOpTimePriorToOurLast) {
@@ -3591,10 +3595,11 @@ TEST_F(ReplCoordTest, NodeReturnsOkImmediatelyWhenWaitingUntilOpTimePassesAnOpTi
     getReplCoord()->setMyLastAppliedOpTime(OpTimeWithTermOne(100, 0));
     getReplCoord()->setMyLastDurableOpTime(OpTimeWithTermOne(100, 0));
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
     ASSERT_OK(getReplCoord()->waitUntilOpTimeForRead(
-        txn.get(), ReadConcernArgs(OpTimeWithTermOne(50, 0), ReadConcernLevel::kLocalReadConcern)));
+        opCtx.get(),
+        ReadConcernArgs(OpTimeWithTermOne(50, 0), ReadConcernLevel::kLocalReadConcern)));
 }
 
 TEST_F(ReplCoordTest, NodeReturnsOkImmediatelyWhenWaitingUntilOpTimePassesAnOpTimeEqualToOurLast) {
@@ -3614,20 +3619,21 @@ TEST_F(ReplCoordTest, NodeReturnsOkImmediatelyWhenWaitingUntilOpTimePassesAnOpTi
     getReplCoord()->setMyLastAppliedOpTime(time);
     getReplCoord()->setMyLastDurableOpTime(time);
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
     ASSERT_OK(getReplCoord()->waitUntilOpTimeForRead(
-        txn.get(), ReadConcernArgs(time, ReadConcernLevel::kLocalReadConcern)));
+        opCtx.get(), ReadConcernArgs(time, ReadConcernLevel::kLocalReadConcern)));
 }
 
 TEST_F(ReplCoordTest,
        NodeReturnsNotAReplicaSetWhenWaitUntilOpTimeIsRunWithoutMajorityReadConcernEnabled) {
     init(ReplSettings());
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
     auto status = getReplCoord()->waitUntilOpTimeForRead(
-        txn.get(), ReadConcernArgs(OpTimeWithTermOne(50, 0), ReadConcernLevel::kLocalReadConcern));
+        opCtx.get(),
+        ReadConcernArgs(OpTimeWithTermOne(50, 0), ReadConcernLevel::kLocalReadConcern));
     ASSERT_EQ(status, ErrorCodes::NotAReplicaSet);
 }
 
@@ -3636,10 +3642,10 @@ TEST_F(ReplCoordTest, NodeReturnsNotAReplicaSetWhenWaitUntilOpTimeIsRunAgainstAS
     settings.setMajorityReadConcernEnabled(true);
     init(settings);
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
     auto status = getReplCoord()->waitUntilOpTimeForRead(
-        txn.get(),
+        opCtx.get(),
         ReadConcernArgs(OpTime(Timestamp(50, 0), 0), ReadConcernLevel::kMajorityReadConcern));
     ASSERT_EQ(status, ErrorCodes::NotAReplicaSet);
 }
@@ -3662,11 +3668,11 @@ TEST_F(ReplCoordTest, ReadAfterCommittedWhileShutdown) {
     getReplCoord()->setMyLastAppliedOpTime(OpTime(Timestamp(10, 0), 0));
     getReplCoord()->setMyLastDurableOpTime(OpTime(Timestamp(10, 0), 0));
 
-    auto txn = makeOperationContext();
-    shutdown(txn.get());
+    auto opCtx = makeOperationContext();
+    shutdown(opCtx.get());
 
     auto status = getReplCoord()->waitUntilOpTimeForRead(
-        txn.get(),
+        opCtx.get(),
         ReadConcernArgs(OpTime(Timestamp(50, 0), 0), ReadConcernLevel::kMajorityReadConcern));
     ASSERT_EQUALS(status, ErrorCodes::ShutdownInProgress);
 }
@@ -3683,13 +3689,13 @@ TEST_F(ReplCoordTest, ReadAfterCommittedInterrupted) {
                                                << 0))),
                        HostAndPort("node1", 12345));
     runSingleNodeElection(makeOperationContext(), getReplCoord(), getNet());
-    const auto txn = makeOperationContext();
+    const auto opCtx = makeOperationContext();
 
     getReplCoord()->setMyLastAppliedOpTime(OpTime(Timestamp(10, 0), 0));
     getReplCoord()->setMyLastDurableOpTime(OpTime(Timestamp(10, 0), 0));
-    killOperation(txn.get());
+    killOperation(opCtx.get());
     auto status = getReplCoord()->waitUntilOpTimeForRead(
-        txn.get(),
+        opCtx.get(),
         ReadConcernArgs(OpTime(Timestamp(50, 0), 0), ReadConcernLevel::kMajorityReadConcern));
     ASSERT_EQUALS(status, ErrorCodes::Interrupted);
 }
@@ -3707,13 +3713,13 @@ TEST_F(ReplCoordTest, ReadAfterCommittedGreaterOpTime) {
                        HostAndPort("node1", 12345));
     runSingleNodeElection(makeOperationContext(), getReplCoord(), getNet());
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
     getReplCoord()->setMyLastAppliedOpTime(OpTime(Timestamp(100, 0), 1));
     getReplCoord()->setMyLastDurableOpTime(OpTime(Timestamp(100, 0), 1));
-    getReplCoord()->createSnapshot(txn.get(), OpTime(Timestamp(100, 0), 1), SnapshotName(1));
+    getReplCoord()->createSnapshot(opCtx.get(), OpTime(Timestamp(100, 0), 1), SnapshotName(1));
 
     ASSERT_OK(getReplCoord()->waitUntilOpTimeForRead(
-        txn.get(),
+        opCtx.get(),
         ReadConcernArgs(OpTime(Timestamp(50, 0), 1), ReadConcernLevel::kMajorityReadConcern)));
 }
 
@@ -3729,15 +3735,15 @@ TEST_F(ReplCoordTest, ReadAfterCommittedEqualOpTime) {
                                                << 0))),
                        HostAndPort("node1", 12345));
     runSingleNodeElection(makeOperationContext(), getReplCoord(), getNet());
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
     OpTime time(Timestamp(100, 0), 1);
     getReplCoord()->setMyLastAppliedOpTime(time);
     getReplCoord()->setMyLastDurableOpTime(time);
-    getReplCoord()->createSnapshot(txn.get(), time, SnapshotName(1));
+    getReplCoord()->createSnapshot(opCtx.get(), time, SnapshotName(1));
 
     ASSERT_OK(getReplCoord()->waitUntilOpTimeForRead(
-        txn.get(), ReadConcernArgs(time, ReadConcernLevel::kMajorityReadConcern)));
+        opCtx.get(), ReadConcernArgs(time, ReadConcernLevel::kMajorityReadConcern)));
 }
 
 TEST_F(ReplCoordTest, ReadAfterCommittedDeferredGreaterOpTime) {
@@ -3762,10 +3768,10 @@ TEST_F(ReplCoordTest, ReadAfterCommittedDeferredGreaterOpTime) {
         getReplCoord()->createSnapshot(nullptr, committedOpTime, SnapshotName(1));
     });
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
     ASSERT_OK(getReplCoord()->waitUntilOpTimeForRead(
-        txn.get(),
+        opCtx.get(),
         ReadConcernArgs(OpTime(Timestamp(100, 0), 1), ReadConcernLevel::kMajorityReadConcern)));
 }
 
@@ -3793,10 +3799,10 @@ TEST_F(ReplCoordTest, ReadAfterCommittedDeferredEqualOpTime) {
         getReplCoord()->createSnapshot(nullptr, opTimeToWait, SnapshotName(1));
     });
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
     ASSERT_OK(getReplCoord()->waitUntilOpTimeForRead(
-        txn.get(), ReadConcernArgs(opTimeToWait, ReadConcernLevel::kMajorityReadConcern)));
+        opCtx.get(), ReadConcernArgs(opTimeToWait, ReadConcernLevel::kMajorityReadConcern)));
     pseudoLogOp.get();
 }
 
@@ -3880,13 +3886,13 @@ TEST_F(ReplCoordTest, UpdateLastCommittedOpTimeWhenTheLastCommittedOpTimeIsNewer
                        HostAndPort("node1", 12345));
     getReplCoord()->setFollowerMode(MemberState::RS_SECONDARY);
     ASSERT_EQUALS(OpTime(Timestamp(0, 0), 0), getReplCoord()->getLastCommittedOpTime());
-    auto txn = makeOperationContext();
-    getReplCoord()->updateTerm(txn.get(), 1);
+    auto opCtx = makeOperationContext();
+    getReplCoord()->updateTerm(opCtx.get(), 1);
     ASSERT_EQUALS(1, getReplCoord()->getTerm());
 
     OpTime time(Timestamp(10, 0), 1);
     OpTime oldTime(Timestamp(9, 0), 1);
-    getReplCoord()->createSnapshot(txn.get(), time, SnapshotName(1));
+    getReplCoord()->createSnapshot(opCtx.get(), time, SnapshotName(1));
 
     // higher OpTime, should change
     getReplCoord()->advanceCommitPoint(time);
@@ -3922,8 +3928,8 @@ TEST_F(ReplCoordTest, UpdateTermWhenTheTermFromMetadataIsNewerButNeverUpdateCurr
                             << 1),
                        HostAndPort("node1", 12345));
     ASSERT_EQUALS(OpTime(Timestamp(0, 0), 0), getReplCoord()->getLastCommittedOpTime());
-    auto txn = makeOperationContext();
-    getReplCoord()->updateTerm(txn.get(), 1);
+    auto opCtx = makeOperationContext();
+    getReplCoord()->updateTerm(opCtx.get(), 1);
     ASSERT_EQUALS(1, getReplCoord()->getTerm());
 
     // higher term, should change
@@ -4001,8 +4007,8 @@ TEST_F(ReplCoordTest,
                             << 1),
                        HostAndPort("node1", 12345));
     ASSERT_EQUALS(OpTime(Timestamp(0, 0), 0), getReplCoord()->getLastCommittedOpTime());
-    auto txn = makeOperationContext();
-    getReplCoord()->updateTerm(txn.get(), 1);
+    auto opCtx = makeOperationContext();
+    getReplCoord()->updateTerm(opCtx.get(), 1);
     ASSERT_EQUALS(1, getReplCoord()->getTerm());
 
     auto replCoord = getReplCoord();
@@ -4129,8 +4135,8 @@ TEST_F(ReplCoordTest, TermAndLastCommittedOpTimeUpdatedFromHeartbeatWhenArbiter)
                             << 1),
                        HostAndPort("node1", 12345));
     ASSERT_EQUALS(OpTime(Timestamp(0, 0), 0), getReplCoord()->getLastCommittedOpTime());
-    auto txn = makeOperationContext();
-    getReplCoord()->updateTerm(txn.get(), 1);
+    auto opCtx = makeOperationContext();
+    getReplCoord()->updateTerm(opCtx.get(), 1);
     ASSERT_EQUALS(1, getReplCoord()->getTerm());
 
     auto replCoord = getReplCoord();
@@ -4555,11 +4561,11 @@ TEST_F(ReplCoordTest, AdvanceCommittedSnapshotToMostRecentSnapshotPriorToOpTimeW
     OpTime time4(Timestamp(100, 4), 1);
     OpTime time5(Timestamp(100, 5), 1);
     OpTime time6(Timestamp(100, 6), 1);
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
-    getReplCoord()->createSnapshot(txn.get(), time1, SnapshotName(1));
-    getReplCoord()->createSnapshot(txn.get(), time2, SnapshotName(2));
-    getReplCoord()->createSnapshot(txn.get(), time5, SnapshotName(3));
+    getReplCoord()->createSnapshot(opCtx.get(), time1, SnapshotName(1));
+    getReplCoord()->createSnapshot(opCtx.get(), time2, SnapshotName(2));
+    getReplCoord()->createSnapshot(opCtx.get(), time5, SnapshotName(3));
 
     // ensure current snapshot follows price is right rules (closest but not greater than)
     getReplCoord()->setMyLastAppliedOpTime(time3);
@@ -4589,11 +4595,11 @@ TEST_F(ReplCoordTest, DoNotAdvanceCommittedSnapshotWhenAnOpTimeIsNewerThanOurLat
     OpTime time4(Timestamp(100, 4), 1);
     OpTime time5(Timestamp(100, 5), 1);
     OpTime time6(Timestamp(100, 6), 1);
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
-    getReplCoord()->createSnapshot(txn.get(), time1, SnapshotName(1));
-    getReplCoord()->createSnapshot(txn.get(), time2, SnapshotName(2));
-    getReplCoord()->createSnapshot(txn.get(), time5, SnapshotName(3));
+    getReplCoord()->createSnapshot(opCtx.get(), time1, SnapshotName(1));
+    getReplCoord()->createSnapshot(opCtx.get(), time2, SnapshotName(2));
+    getReplCoord()->createSnapshot(opCtx.get(), time5, SnapshotName(3));
 
     // ensure current snapshot will not advance beyond existing snapshots
     getReplCoord()->setMyLastAppliedOpTime(time6);
@@ -4621,18 +4627,18 @@ TEST_F(ReplCoordTest,
     OpTime time4(Timestamp(100, 4), 1);
     OpTime time5(Timestamp(100, 5), 1);
     OpTime time6(Timestamp(100, 6), 1);
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
-    getReplCoord()->createSnapshot(txn.get(), time1, SnapshotName(1));
-    getReplCoord()->createSnapshot(txn.get(), time2, SnapshotName(2));
-    getReplCoord()->createSnapshot(txn.get(), time5, SnapshotName(3));
+    getReplCoord()->createSnapshot(opCtx.get(), time1, SnapshotName(1));
+    getReplCoord()->createSnapshot(opCtx.get(), time2, SnapshotName(2));
+    getReplCoord()->createSnapshot(opCtx.get(), time5, SnapshotName(3));
 
     getReplCoord()->setMyLastAppliedOpTime(time6);
     getReplCoord()->setMyLastDurableOpTime(time6);
     ASSERT_EQUALS(time5, getReplCoord()->getCurrentCommittedSnapshotOpTime());
 
     // ensure current snapshot updates on new snapshot if we are that far
-    getReplCoord()->createSnapshot(txn.get(), time6, SnapshotName(4));
+    getReplCoord()->createSnapshot(opCtx.get(), time6, SnapshotName(4));
     ASSERT_EQUALS(time6, getReplCoord()->getCurrentCommittedSnapshotOpTime());
 }
 
@@ -4655,11 +4661,11 @@ TEST_F(ReplCoordTest, ZeroCommittedSnapshotWhenAllSnapshotsAreDropped) {
     OpTime time4(Timestamp(100, 4), 1);
     OpTime time5(Timestamp(100, 5), 1);
     OpTime time6(Timestamp(100, 6), 1);
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
-    getReplCoord()->createSnapshot(txn.get(), time1, SnapshotName(1));
-    getReplCoord()->createSnapshot(txn.get(), time2, SnapshotName(2));
-    getReplCoord()->createSnapshot(txn.get(), time5, SnapshotName(3));
+    getReplCoord()->createSnapshot(opCtx.get(), time1, SnapshotName(1));
+    getReplCoord()->createSnapshot(opCtx.get(), time2, SnapshotName(2));
+    getReplCoord()->createSnapshot(opCtx.get(), time5, SnapshotName(3));
 
     // ensure dropping all snapshots should reset the current committed snapshot
     getReplCoord()->dropAllSnapshots();
@@ -4681,9 +4687,9 @@ TEST_F(ReplCoordTest, DoNotAdvanceCommittedSnapshotWhenAppliedOpTimeChanges) {
 
     OpTime time1(Timestamp(100, 1), 1);
     OpTime time2(Timestamp(100, 2), 1);
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
-    getReplCoord()->createSnapshot(txn.get(), time1, SnapshotName(1));
+    getReplCoord()->createSnapshot(opCtx.get(), time1, SnapshotName(1));
 
     getReplCoord()->setMyLastAppliedOpTime(time1);
     ASSERT_EQUALS(OpTime(), getReplCoord()->getCurrentCommittedSnapshotOpTime());
@@ -4842,13 +4848,13 @@ TEST_F(ReplCoordTest, NewStyleUpdatePositionCmdHasMetadata) {
     OpTime optime(Timestamp(100, 2), 0);
     getReplCoord()->setMyLastAppliedOpTime(optime);
     getReplCoord()->setMyLastDurableOpTime(optime);
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
     // Set last committed optime via metadata.
     rpc::ReplSetMetadata syncSourceMetadata(optime.getTerm(), optime, optime, 1, OID(), -1, 1);
     getReplCoord()->processReplSetMetadata(syncSourceMetadata);
     getReplCoord()->advanceCommitPoint(optime);
-    getReplCoord()->createSnapshot(txn.get(), optime, SnapshotName(1));
+    getReplCoord()->createSnapshot(opCtx.get(), optime, SnapshotName(1));
 
     BSONObj cmd = unittest::assertGet(getReplCoord()->prepareReplSetUpdatePositionCommand(
         ReplicationCoordinator::ReplSetUpdatePositionCommandStyle::kNewStyle));
@@ -5070,8 +5076,8 @@ TEST_F(ReplCoordTest, WaitForDrainFinish) {
 
     ASSERT_EQUALS(ErrorCodes::BadValue, replCoord->waitForDrainFinish(Milliseconds(-1)));
 
-    const auto txn = makeOperationContext();
-    replCoord->signalDrainComplete(txn.get(), replCoord->getTerm());
+    const auto opCtx = makeOperationContext();
+    replCoord->signalDrainComplete(opCtx.get(), replCoord->getTerm());
     ASSERT_OK(replCoord->waitForDrainFinish(timeout));
 
     // Zero timeout is fine.
@@ -5346,7 +5352,7 @@ TEST_F(ReplCoordTest, NodeStoresElectionVotes) {
     getReplCoord()->setMyLastDurableOpTime(time);
     simulateSuccessfulV1Election();
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
     ReplSetRequestVotesArgs args;
     ASSERT_OK(args.initialize(BSON("replSetRequestVotes" << 1 << "setName"
@@ -5363,11 +5369,11 @@ TEST_F(ReplCoordTest, NodeStoresElectionVotes) {
                                                          << time.asOpTime().toBSON())));
     ReplSetRequestVotesResponse response;
 
-    ASSERT_OK(getReplCoord()->processReplSetRequestVotes(txn.get(), args, &response));
+    ASSERT_OK(getReplCoord()->processReplSetRequestVotes(opCtx.get(), args, &response));
     ASSERT_EQUALS("", response.getReason());
     ASSERT_TRUE(response.getVoteGranted());
 
-    auto lastVote = getExternalState()->loadLocalLastVoteDocument(txn.get());
+    auto lastVote = getExternalState()->loadLocalLastVoteDocument(opCtx.get());
     ASSERT_OK(lastVote.getStatus());
 
     // This is not a dry-run election so the last vote should include the new term and candidate.
@@ -5400,7 +5406,7 @@ TEST_F(ReplCoordTest, NodeDoesNotStoreDryRunVotes) {
     getReplCoord()->setMyLastDurableOpTime(time);
     simulateSuccessfulV1Election();
 
-    auto txn = makeOperationContext();
+    auto opCtx = makeOperationContext();
 
     ReplSetRequestVotesArgs args;
     ASSERT_OK(args.initialize(BSON("replSetRequestVotes" << 1 << "setName"
@@ -5417,11 +5423,11 @@ TEST_F(ReplCoordTest, NodeDoesNotStoreDryRunVotes) {
                                                          << time.asOpTime().toBSON())));
     ReplSetRequestVotesResponse response;
 
-    ASSERT_OK(getReplCoord()->processReplSetRequestVotes(txn.get(), args, &response));
+    ASSERT_OK(getReplCoord()->processReplSetRequestVotes(opCtx.get(), args, &response));
     ASSERT_EQUALS("", response.getReason());
     ASSERT_TRUE(response.getVoteGranted());
 
-    auto lastVote = getExternalState()->loadLocalLastVoteDocument(txn.get());
+    auto lastVote = getExternalState()->loadLocalLastVoteDocument(opCtx.get());
     ASSERT_OK(lastVote.getStatus());
 
     // This is a dry-run election so the last vote should not be updated with the new term and
diff --git a/src/mongo/db/repl/replication_coordinator_mock.cpp b/src/mongo/db/repl/replication_coordinator_mock.cpp
index e72083ef012..27d62c0af1e 100644
--- a/src/mongo/db/repl/replication_coordinator_mock.cpp
+++ b/src/mongo/db/repl/replication_coordinator_mock.cpp
@@ -50,7 +50,7 @@ ReplicationCoordinatorMock::ReplicationCoordinatorMock(ServiceContext* service,
 
 ReplicationCoordinatorMock::~ReplicationCoordinatorMock() {}
 
-void ReplicationCoordinatorMock::startup(OperationContext* txn) {
+void ReplicationCoordinatorMock::startup(OperationContext* opCtx) {
     // TODO
 }
 
@@ -97,18 +97,18 @@ Seconds ReplicationCoordinatorMock::getSlaveDelaySecs() const {
 void ReplicationCoordinatorMock::clearSyncSourceBlacklist() {}
 
 ReplicationCoordinator::StatusAndDuration ReplicationCoordinatorMock::awaitReplication(
-    OperationContext* txn, const OpTime& opTime, const WriteConcernOptions& writeConcern) {
+    OperationContext* opCtx, const OpTime& opTime, const WriteConcernOptions& writeConcern) {
     // TODO
     return StatusAndDuration(Status::OK(), Milliseconds(0));
 }
 
 ReplicationCoordinator::StatusAndDuration
 ReplicationCoordinatorMock::awaitReplicationOfLastOpForClient(
-    OperationContext* txn, const WriteConcernOptions& writeConcern) {
+    OperationContext* opCtx, const WriteConcernOptions& writeConcern) {
     return StatusAndDuration(Status::OK(), Milliseconds(0));
 }
 
-Status ReplicationCoordinatorMock::stepDown(OperationContext* txn,
+Status ReplicationCoordinatorMock::stepDown(OperationContext* opCtx,
                                             bool force,
                                             const Milliseconds& waitTime,
                                             const Milliseconds& stepdownTime) {
@@ -120,7 +120,7 @@ bool ReplicationCoordinatorMock::isMasterForReportingPurposes() {
     return true;
 }
 
-bool ReplicationCoordinatorMock::canAcceptWritesForDatabase(OperationContext* txn,
+bool ReplicationCoordinatorMock::canAcceptWritesForDatabase(OperationContext* opCtx,
                                                             StringData dbName) {
     // Return true if we allow writes explicitly even when not in primary state, as in sharding
     // unit tests, so that the op observers can fire but the tests don't have to set all the states
@@ -131,38 +131,38 @@ bool ReplicationCoordinatorMock::canAcceptWritesForDatabase(OperationContext* tx
     return dbName == "local" || _memberState.primary() || _settings.isMaster();
 }
 
-bool ReplicationCoordinatorMock::canAcceptWritesForDatabase_UNSAFE(OperationContext* txn,
+bool ReplicationCoordinatorMock::canAcceptWritesForDatabase_UNSAFE(OperationContext* opCtx,
                                                                    StringData dbName) {
-    return canAcceptWritesForDatabase(txn, dbName);
+    return canAcceptWritesForDatabase(opCtx, dbName);
 }
 
-bool ReplicationCoordinatorMock::canAcceptWritesFor(OperationContext* txn,
+bool ReplicationCoordinatorMock::canAcceptWritesFor(OperationContext* opCtx,
                                                     const NamespaceString& ns) {
     // TODO
-    return canAcceptWritesForDatabase(txn, ns.db());
+    return canAcceptWritesForDatabase(opCtx, ns.db());
 }
 
-bool ReplicationCoordinatorMock::canAcceptWritesFor_UNSAFE(OperationContext* txn,
+bool ReplicationCoordinatorMock::canAcceptWritesFor_UNSAFE(OperationContext* opCtx,
                                                            const NamespaceString& ns) {
-    return canAcceptWritesFor(txn, ns);
+    return canAcceptWritesFor(opCtx, ns);
 }
 
-Status ReplicationCoordinatorMock::checkCanServeReadsFor(OperationContext* txn,
+Status ReplicationCoordinatorMock::checkCanServeReadsFor(OperationContext* opCtx,
                                                          const NamespaceString& ns,
                                                          bool slaveOk) {
     // TODO
     return Status::OK();
 }
 
-Status ReplicationCoordinatorMock::checkCanServeReadsFor_UNSAFE(OperationContext* txn,
+Status ReplicationCoordinatorMock::checkCanServeReadsFor_UNSAFE(OperationContext* opCtx,
                                                                 const NamespaceString& ns,
                                                                 bool slaveOk) {
-    return checkCanServeReadsFor(txn, ns, slaveOk);
+    return checkCanServeReadsFor(opCtx, ns, slaveOk);
 }
 
-bool ReplicationCoordinatorMock::shouldRelaxIndexConstraints(OperationContext* txn,
+bool ReplicationCoordinatorMock::shouldRelaxIndexConstraints(OperationContext* opCtx,
                                                              const NamespaceString& ns) {
-    return !canAcceptWritesFor(txn, ns);
+    return !canAcceptWritesFor(opCtx, ns);
 }
 
 Status ReplicationCoordinatorMock::setLastOptimeForSlave(const OID& rid, const Timestamp& ts) {
@@ -205,7 +205,7 @@ OpTime ReplicationCoordinatorMock::getMyLastDurableOpTime() const {
     return _myLastDurableOpTime;
 }
 
-Status ReplicationCoordinatorMock::waitUntilOpTimeForRead(OperationContext* txn,
+Status ReplicationCoordinatorMock::waitUntilOpTimeForRead(OperationContext* opCtx,
                                                           const ReadConcernArgs& settings) {
     return Status::OK();
 }
@@ -242,7 +242,7 @@ Status ReplicationCoordinatorMock::waitForDrainFinish(Milliseconds timeout) {
 
 void ReplicationCoordinatorMock::signalUpstreamUpdater() {}
 
-Status ReplicationCoordinatorMock::resyncData(OperationContext* txn, bool waitUntilCompleted) {
+Status ReplicationCoordinatorMock::resyncData(OperationContext* opCtx, bool waitUntilCompleted) {
     return Status::OK();
 }
 
@@ -297,7 +297,7 @@ bool ReplicationCoordinatorMock::getMaintenanceMode() {
     return false;
 }
 
-Status ReplicationCoordinatorMock::processReplSetSyncFrom(OperationContext* txn,
+Status ReplicationCoordinatorMock::processReplSetSyncFrom(OperationContext* opCtx,
                                                           const HostAndPort& target,
                                                           BSONObjBuilder* resultObj) {
     // TODO
@@ -314,13 +314,13 @@ Status ReplicationCoordinatorMock::processHeartbeat(const ReplSetHeartbeatArgs&
     return Status::OK();
 }
 
-Status ReplicationCoordinatorMock::processReplSetReconfig(OperationContext* txn,
+Status ReplicationCoordinatorMock::processReplSetReconfig(OperationContext* opCtx,
                                                           const ReplSetReconfigArgs& args,
                                                           BSONObjBuilder* resultObj) {
     return Status::OK();
 }
 
-Status ReplicationCoordinatorMock::processReplSetInitiate(OperationContext* txn,
+Status ReplicationCoordinatorMock::processReplSetInitiate(OperationContext* opCtx,
                                                           const BSONObj& configObj,
                                                           BSONObjBuilder* resultObj) {
     return Status::OK();
@@ -355,7 +355,7 @@ Status ReplicationCoordinatorMock::processReplSetUpdatePosition(const UpdatePosi
     return Status::OK();
 }
 
-Status ReplicationCoordinatorMock::processHandshake(OperationContext* txn,
+Status ReplicationCoordinatorMock::processHandshake(OperationContext* opCtx,
                                                     const HandshakeArgs& handshake) {
     return Status::OK();
 }
@@ -394,7 +394,7 @@ HostAndPort ReplicationCoordinatorMock::chooseNewSyncSource(const OpTime& lastOp
 
 void ReplicationCoordinatorMock::blacklistSyncSource(const HostAndPort& host, Date_t until) {}
 
-void ReplicationCoordinatorMock::resetLastOpTimesFromOplog(OperationContext* txn) {
+void ReplicationCoordinatorMock::resetLastOpTimesFromOplog(OperationContext* opCtx) {
     invariant(false);
 }
 
@@ -410,7 +410,7 @@ OpTime ReplicationCoordinatorMock::getLastCommittedOpTime() const {
 }
 
 Status ReplicationCoordinatorMock::processReplSetRequestVotes(
-    OperationContext* txn,
+    OperationContext* opCtx,
     const ReplSetRequestVotesArgs& args,
     ReplSetRequestVotesResponse* response) {
     return Status::OK();
@@ -439,17 +439,17 @@ long long ReplicationCoordinatorMock::getTerm() {
     return OpTime::kInitialTerm;
 }
 
-Status ReplicationCoordinatorMock::updateTerm(OperationContext* txn, long long term) {
+Status ReplicationCoordinatorMock::updateTerm(OperationContext* opCtx, long long term) {
     return Status::OK();
 }
 
-SnapshotName ReplicationCoordinatorMock::reserveSnapshotName(OperationContext* txn) {
+SnapshotName ReplicationCoordinatorMock::reserveSnapshotName(OperationContext* opCtx) {
     return SnapshotName(_snapshotNameGenerator.addAndFetch(1));
 }
 
 void ReplicationCoordinatorMock::forceSnapshotCreation() {}
 
-void ReplicationCoordinatorMock::createSnapshot(OperationContext* txn,
+void ReplicationCoordinatorMock::createSnapshot(OperationContext* opCtx,
                                                 OpTime timeOfSnapshot,
                                                 SnapshotName name){};
 
@@ -459,7 +459,7 @@ OpTime ReplicationCoordinatorMock::getCurrentCommittedSnapshotOpTime() const {
     return OpTime();
 }
 
-void ReplicationCoordinatorMock::waitUntilSnapshotCommitted(OperationContext* txn,
+void ReplicationCoordinatorMock::waitUntilSnapshotCommitted(OperationContext* opCtx,
                                                             const SnapshotName& untilSnapshot) {}
 
 size_t ReplicationCoordinatorMock::getNumUncommittedSnapshots() {
diff --git a/src/mongo/db/repl/replication_coordinator_mock.h b/src/mongo/db/repl/replication_coordinator_mock.h
index 4b3fd99d3ce..0e9109b1665 100644
--- a/src/mongo/db/repl/replication_coordinator_mock.h
+++ b/src/mongo/db/repl/replication_coordinator_mock.h
@@ -53,9 +53,9 @@ public:
     ReplicationCoordinatorMock(ServiceContext* service, const ReplSettings& settings);
     virtual ~ReplicationCoordinatorMock();
 
-    virtual void startup(OperationContext* txn);
+    virtual void startup(OperationContext* opCtx);
 
-    virtual void shutdown(OperationContext* txn);
+    virtual void shutdown(OperationContext* opCtx);
 
     virtual ReplicationExecutor* getExecutor() override {
         return nullptr;
@@ -78,36 +78,36 @@ public:
     virtual void clearSyncSourceBlacklist();
 
     virtual ReplicationCoordinator::StatusAndDuration awaitReplication(
-        OperationContext* txn, const OpTime& opTime, const WriteConcernOptions& writeConcern);
+        OperationContext* opCtx, const OpTime& opTime, const WriteConcernOptions& writeConcern);
 
     virtual ReplicationCoordinator::StatusAndDuration awaitReplicationOfLastOpForClient(
-        OperationContext* txn, const WriteConcernOptions& writeConcern);
+        OperationContext* opCtx, const WriteConcernOptions& writeConcern);
 
-    virtual Status stepDown(OperationContext* txn,
+    virtual Status stepDown(OperationContext* opCtx,
                             bool force,
                             const Milliseconds& waitTime,
                             const Milliseconds& stepdownTime);
 
     virtual bool isMasterForReportingPurposes();
 
-    virtual bool canAcceptWritesForDatabase(OperationContext* txn, StringData dbName);
+    virtual bool canAcceptWritesForDatabase(OperationContext* opCtx, StringData dbName);
 
-    virtual bool canAcceptWritesForDatabase_UNSAFE(OperationContext* txn, StringData dbName);
+    virtual bool canAcceptWritesForDatabase_UNSAFE(OperationContext* opCtx, StringData dbName);
 
-    bool canAcceptWritesFor(OperationContext* txn, const NamespaceString& ns) override;
+    bool canAcceptWritesFor(OperationContext* opCtx, const NamespaceString& ns) override;
 
-    bool canAcceptWritesFor_UNSAFE(OperationContext* txn, const NamespaceString& ns) override;
+    bool canAcceptWritesFor_UNSAFE(OperationContext* opCtx, const NamespaceString& ns) override;
 
     virtual Status checkIfWriteConcernCanBeSatisfied(const WriteConcernOptions& writeConcern) const;
 
-    virtual Status checkCanServeReadsFor(OperationContext* txn,
+    virtual Status checkCanServeReadsFor(OperationContext* opCtx,
                                          const NamespaceString& ns,
                                          bool slaveOk);
-    virtual Status checkCanServeReadsFor_UNSAFE(OperationContext* txn,
+    virtual Status checkCanServeReadsFor_UNSAFE(OperationContext* opCtx,
                                                 const NamespaceString& ns,
                                                 bool slaveOk);
 
-    virtual bool shouldRelaxIndexConstraints(OperationContext* txn, const NamespaceString& ns);
+    virtual bool shouldRelaxIndexConstraints(OperationContext* opCtx, const NamespaceString& ns);
 
     virtual Status setLastOptimeForSlave(const OID& rid, const Timestamp& ts);
 
@@ -124,7 +124,7 @@ public:
     virtual OpTime getMyLastAppliedOpTime() const;
     virtual OpTime getMyLastDurableOpTime() const;
 
-    virtual Status waitUntilOpTimeForRead(OperationContext* txn,
+    virtual Status waitUntilOpTimeForRead(OperationContext* opCtx,
                                           const ReadConcernArgs& settings) override;
 
     virtual OID getElectionId();
@@ -143,7 +143,7 @@ public:
 
     virtual void signalUpstreamUpdater();
 
-    virtual Status resyncData(OperationContext* txn, bool waitUntilCompleted) override;
+    virtual Status resyncData(OperationContext* opCtx, bool waitUntilCompleted) override;
 
     virtual StatusWith<BSONObj> prepareReplSetUpdatePositionCommand(
         ReplSetUpdatePositionCommandStyle commandStyle) const override;
@@ -170,7 +170,7 @@ public:
 
     virtual bool getMaintenanceMode();
 
-    virtual Status processReplSetSyncFrom(OperationContext* txn,
+    virtual Status processReplSetSyncFrom(OperationContext* opCtx,
                                           const HostAndPort& target,
                                           BSONObjBuilder* resultObj);
 
@@ -179,11 +179,11 @@ public:
     virtual Status processHeartbeat(const ReplSetHeartbeatArgs& args,
                                     ReplSetHeartbeatResponse* response);
 
-    virtual Status processReplSetReconfig(OperationContext* txn,
+    virtual Status processReplSetReconfig(OperationContext* opCtx,
                                           const ReplSetReconfigArgs& args,
                                           BSONObjBuilder* resultObj);
 
-    virtual Status processReplSetInitiate(OperationContext* txn,
+    virtual Status processReplSetInitiate(OperationContext* opCtx,
                                           const BSONObj& configObj,
                                           BSONObjBuilder* resultObj);
 
@@ -200,7 +200,7 @@ public:
     virtual Status processReplSetUpdatePosition(const UpdatePositionArgs& updates,
                                                 long long* configVersion);
 
-    virtual Status processHandshake(OperationContext* txn, const HandshakeArgs& handshake);
+    virtual Status processHandshake(OperationContext* opCtx, const HandshakeArgs& handshake);
 
     virtual bool buildsIndexes();
 
@@ -216,7 +216,7 @@ public:
 
     virtual void blacklistSyncSource(const HostAndPort& host, Date_t until);
 
-    virtual void resetLastOpTimesFromOplog(OperationContext* txn);
+    virtual void resetLastOpTimesFromOplog(OperationContext* opCtx);
 
     virtual bool shouldChangeSyncSource(const HostAndPort& currentSource,
                                         const rpc::ReplSetMetadata& replMetadata,
@@ -224,7 +224,7 @@ public:
 
     virtual OpTime getLastCommittedOpTime() const;
 
-    virtual Status processReplSetRequestVotes(OperationContext* txn,
+    virtual Status processReplSetRequestVotes(OperationContext* opCtx,
                                               const ReplSetRequestVotesArgs& args,
                                               ReplSetRequestVotesResponse* response);
 
@@ -243,13 +243,13 @@ public:
 
     virtual long long getTerm();
 
-    virtual Status updateTerm(OperationContext* txn, long long term);
+    virtual Status updateTerm(OperationContext* opCtx, long long term);
 
-    virtual SnapshotName reserveSnapshotName(OperationContext* txn);
+    virtual SnapshotName reserveSnapshotName(OperationContext* opCtx);
 
     virtual void forceSnapshotCreation() override;
 
-    virtual void createSnapshot(OperationContext* txn,
+    virtual void createSnapshot(OperationContext* opCtx,
                                 OpTime timeOfSnapshot,
                                 SnapshotName name) override;
 
@@ -257,7 +257,7 @@ public:
 
     virtual OpTime getCurrentCommittedSnapshotOpTime() const override;
 
-    virtual void waitUntilSnapshotCommitted(OperationContext* txn,
+    virtual void waitUntilSnapshotCommitted(OperationContext* opCtx,
                                             const SnapshotName& untilSnapshot) override;
 
     virtual size_t getNumUncommittedSnapshots() override;
diff --git a/src/mongo/db/repl/replication_coordinator_test_fixture.cpp b/src/mongo/db/repl/replication_coordinator_test_fixture.cpp
index 43dff9b4c06..945455d4512 100644
--- a/src/mongo/db/repl/replication_coordinator_test_fixture.cpp
+++ b/src/mongo/db/repl/replication_coordinator_test_fixture.cpp
@@ -89,8 +89,8 @@ void ReplCoordTest::tearDown() {
         _externalState->setStoreLocalConfigDocumentToHang(false);
     }
     if (_callShutdown) {
-        auto txn = makeOperationContext();
-        shutdown(txn.get());
+        auto opCtx = makeOperationContext();
+        shutdown(opCtx.get());
     }
 }
 
@@ -165,8 +165,8 @@ void ReplCoordTest::start() {
         init();
     }
 
-    const auto txn = makeOperationContext();
-    _repl->startup(txn.get());
+    const auto opCtx = makeOperationContext();
+    _repl->startup(opCtx.get());
     _repl->waitForStartUpComplete_forTest();
     _callShutdown = true;
 }
@@ -362,8 +362,8 @@ void ReplCoordTest::simulateSuccessfulV1ElectionAt(Date_t electionTime) {
     ASSERT_FALSE(imResponse.isMaster()) << imResponse.toBSON().toString();
     ASSERT_TRUE(imResponse.isSecondary()) << imResponse.toBSON().toString();
     {
-        auto txn = makeOperationContext();
-        replCoord->signalDrainComplete(txn.get(), replCoord->getTerm());
+        auto opCtx = makeOperationContext();
+        replCoord->signalDrainComplete(opCtx.get(), replCoord->getTerm());
     }
     ASSERT(replCoord->getApplierState() == ReplicationCoordinator::ApplierState::Stopped);
     replCoord->fillIsMasterForReplSet(&imResponse);
@@ -425,8 +425,8 @@ void ReplCoordTest::simulateSuccessfulElection() {
     ASSERT_FALSE(imResponse.isMaster()) << imResponse.toBSON().toString();
     ASSERT_TRUE(imResponse.isSecondary()) << imResponse.toBSON().toString();
     {
-        auto txn = makeOperationContext();
-        replCoord->signalDrainComplete(txn.get(), replCoord->getTerm());
+        auto opCtx = makeOperationContext();
+        replCoord->signalDrainComplete(opCtx.get(), replCoord->getTerm());
     }
     replCoord->fillIsMasterForReplSet(&imResponse);
     ASSERT_TRUE(imResponse.isMaster()) << imResponse.toBSON().toString();
@@ -435,10 +435,10 @@ void ReplCoordTest::simulateSuccessfulElection() {
     ASSERT(replCoord->getMemberState().primary()) << replCoord->getMemberState().toString();
 }
 
-void ReplCoordTest::shutdown(OperationContext* txn) {
+void ReplCoordTest::shutdown(OperationContext* opCtx) {
     invariant(_callShutdown);
     _net->exitNetwork();
-    _repl->shutdown(txn);
+    _repl->shutdown(opCtx);
     _callShutdown = false;
 }
 
diff --git a/src/mongo/db/repl/replication_coordinator_test_fixture.h b/src/mongo/db/repl/replication_coordinator_test_fixture.h
index b9b05e46172..5ffab24a8ef 100644
--- a/src/mongo/db/repl/replication_coordinator_test_fixture.h
+++ b/src/mongo/db/repl/replication_coordinator_test_fixture.h
@@ -233,7 +233,7 @@ protected:
     /**
      * Shuts down the objects under test.
      */
-    void shutdown(OperationContext* txn);
+    void shutdown(OperationContext* opCtx);
 
     /**
      * Receive the heartbeat request from replication coordinator and reply with a response.
diff --git a/src/mongo/db/repl/replication_executor.cpp b/src/mongo/db/repl/replication_executor.cpp
index f4070ac5d9e..3f9f0c5836b 100644
--- a/src/mongo/db/repl/replication_executor.cpp
+++ b/src/mongo/db/repl/replication_executor.cpp
@@ -404,8 +404,8 @@ StatusWith<ReplicationExecutor::CallbackHandle> ReplicationExecutor::scheduleDBW
                                handle.getValue(),
                                &_dbWorkInProgressQueue,
                                nullptr);
-        auto task = [doOp](OperationContext* txn, const Status& status) {
-            makeNoExcept(stdx::bind(doOp, txn, status))();
+        auto task = [doOp](OperationContext* opCtx, const Status& status) {
+            makeNoExcept(stdx::bind(doOp, opCtx, status))();
             return TaskRunner::NextAction::kDisposeOperationContext;
         };
         if (mode == MODE_NONE && nss.ns().empty()) {
@@ -418,7 +418,7 @@ StatusWith<ReplicationExecutor::CallbackHandle> ReplicationExecutor::scheduleDBW
     return handle;
 }
 
-void ReplicationExecutor::_doOperation(OperationContext* txn,
+void ReplicationExecutor::_doOperation(OperationContext* opCtx,
                                        const Status& taskRunnerStatus,
                                        const CallbackHandle& cbHandle,
                                        WorkQueue* workQueue,
@@ -442,7 +442,7 @@ void ReplicationExecutor::_doOperation(OperationContext* txn,
                          (callback->_isCanceled || !taskRunnerStatus.isOK()
                               ? Status(ErrorCodes::CallbackCanceled, "Callback canceled")
                               : Status::OK()),
-                         txn));
+                         opCtx));
     }
     lk.lock();
     signalEvent_inlock(callback->_finishedEvent);
@@ -461,8 +461,8 @@ ReplicationExecutor::scheduleWorkWithGlobalExclusiveLock(const CallbackFn& work)
                                &_exclusiveLockInProgressQueue,
                                &_terribleExLockSyncMutex);
         _dblockExclusiveLockTaskRunner.schedule(DatabaseTask::makeGlobalExclusiveLockTask(
-            [doOp](OperationContext* txn, const Status& status) {
-                makeNoExcept(stdx::bind(doOp, txn, status))();
+            [doOp](OperationContext* opCtx, const Status& status) {
+                makeNoExcept(stdx::bind(doOp, opCtx, status))();
                 return TaskRunner::NextAction::kDisposeOperationContext;
             }));
     }
diff --git a/src/mongo/db/repl/replication_executor.h b/src/mongo/db/repl/replication_executor.h
index 26f8e522317..c5e20a8ac68 100644
--- a/src/mongo/db/repl/replication_executor.h
+++ b/src/mongo/db/repl/replication_executor.h
@@ -280,7 +280,7 @@ private:
      * Executes the callback referenced by "cbHandle", and moves the underlying
      * WorkQueue::iterator from "workQueue" into the _freeQueue.
      *
-     * "txn" is a pointer to the OperationContext.
+     * "opCtx" is a pointer to the OperationContext.
      *
      * "status" is the callback status from the task runner. Only possible values are
      * Status::OK and ErrorCodes::CallbackCanceled (when task runner is canceled).
@@ -288,7 +288,7 @@ private:
      * If "terribleExLockSyncMutex" is not null, serializes execution of "cbHandle" with the
      * execution of other callbacks.
      */
-    void _doOperation(OperationContext* txn,
+    void _doOperation(OperationContext* opCtx,
                       const Status& taskRunnerStatus,
                       const CallbackHandle& cbHandle,
                       WorkQueue* workQueue,
diff --git a/src/mongo/db/repl/replication_executor_test.cpp b/src/mongo/db/repl/replication_executor_test.cpp
index e630a4a2e30..831259951b4 100644
--- a/src/mongo/db/repl/replication_executor_test.cpp
+++ b/src/mongo/db/repl/replication_executor_test.cpp
@@ -72,12 +72,12 @@ TEST_F(ReplicationExecutorTest, ScheduleDBWorkAndExclusiveWorkConcurrently) {
     NamespaceString nss("mydb", "mycoll");
     ReplicationExecutor& executor = getReplExecutor();
     Status status1 = getDetectableErrorStatus();
-    OperationContext* txn = nullptr;
+    OperationContext* opCtx = nullptr;
     using CallbackData = ReplicationExecutor::CallbackArgs;
     ASSERT_OK(executor
                   .scheduleDBWork([&](const CallbackData& cbData) {
                       status1 = cbData.status;
-                      txn = cbData.txn;
+                      opCtx = cbData.opCtx;
                       barrier.countDownAndWait();
                       if (cbData.status != ErrorCodes::CallbackCanceled)
                           cbData.executor->shutdown();
@@ -90,23 +90,23 @@ TEST_F(ReplicationExecutorTest, ScheduleDBWorkAndExclusiveWorkConcurrently) {
     executor.startup();
     executor.join();
     ASSERT_OK(status1);
-    ASSERT(txn);
+    ASSERT(opCtx);
 }
 
 TEST_F(ReplicationExecutorTest, ScheduleDBWorkWithCollectionLock) {
     NamespaceString nss("mydb", "mycoll");
     ReplicationExecutor& executor = getReplExecutor();
     Status status1 = getDetectableErrorStatus();
-    OperationContext* txn = nullptr;
+    OperationContext* opCtx = nullptr;
     bool collectionIsLocked = false;
     using CallbackData = ReplicationExecutor::CallbackArgs;
     ASSERT_OK(executor
                   .scheduleDBWork(
                       [&](const CallbackData& cbData) {
                           status1 = cbData.status;
-                          txn = cbData.txn;
-                          collectionIsLocked = txn
-                              ? txn->lockState()->isCollectionLockedForMode(nss.ns(), MODE_X)
+                          opCtx = cbData.opCtx;
+                          collectionIsLocked = opCtx
+                              ? opCtx->lockState()->isCollectionLockedForMode(nss.ns(), MODE_X)
                               : false;
                           if (cbData.status != ErrorCodes::CallbackCanceled)
                               cbData.executor->shutdown();
@@ -117,21 +117,21 @@ TEST_F(ReplicationExecutorTest, ScheduleDBWorkWithCollectionLock) {
     executor.startup();
     executor.join();
     ASSERT_OK(status1);
-    ASSERT(txn);
+    ASSERT(opCtx);
     ASSERT_TRUE(collectionIsLocked);
 }
 
 TEST_F(ReplicationExecutorTest, ScheduleExclusiveLockOperation) {
     ReplicationExecutor& executor = getReplExecutor();
     Status status1 = getDetectableErrorStatus();
-    OperationContext* txn = nullptr;
+    OperationContext* opCtx = nullptr;
     bool lockIsW = false;
     using CallbackData = ReplicationExecutor::CallbackArgs;
     ASSERT_OK(executor
                   .scheduleWorkWithGlobalExclusiveLock([&](const CallbackData& cbData) {
                       status1 = cbData.status;
-                      txn = cbData.txn;
-                      lockIsW = txn ? txn->lockState()->isW() : false;
+                      opCtx = cbData.opCtx;
+                      lockIsW = opCtx ? opCtx->lockState()->isW() : false;
                       if (cbData.status != ErrorCodes::CallbackCanceled)
                           cbData.executor->shutdown();
                   })
@@ -139,7 +139,7 @@ TEST_F(ReplicationExecutorTest, ScheduleExclusiveLockOperation) {
     executor.startup();
     executor.join();
     ASSERT_OK(status1);
-    ASSERT(txn);
+    ASSERT(opCtx);
     ASSERT_TRUE(lockIsW);
 }
 
diff --git a/src/mongo/db/repl/replication_info.cpp b/src/mongo/db/repl/replication_info.cpp
index c75c7b38880..e0a49f5849f 100644
--- a/src/mongo/db/repl/replication_info.cpp
+++ b/src/mongo/db/repl/replication_info.cpp
@@ -66,7 +66,7 @@ using std::stringstream;
 
 namespace repl {
 
-void appendReplicationInfo(OperationContext* txn, BSONObjBuilder& result, int level) {
+void appendReplicationInfo(OperationContext* opCtx, BSONObjBuilder& result, int level) {
     ReplicationCoordinator* replCoord = getGlobalReplicationCoordinator();
     if (replCoord->getSettings().usingReplSets()) {
         IsMasterResponse isMasterResponse;
@@ -95,9 +95,9 @@ void appendReplicationInfo(OperationContext* txn, BSONObjBuilder& result, int le
         list<BSONObj> src;
         {
             const NamespaceString localSources{"local.sources"};
-            AutoGetCollectionForRead ctx(txn, localSources);
+            AutoGetCollectionForRead ctx(opCtx, localSources);
             unique_ptr<PlanExecutor> exec(InternalPlanner::collectionScan(
-                txn, localSources.ns(), ctx.getCollection(), PlanExecutor::YIELD_MANUAL));
+                opCtx, localSources.ns(), ctx.getCollection(), PlanExecutor::YIELD_MANUAL));
             BSONObj obj;
             PlanExecutor::ExecState state;
             while (PlanExecutor::ADVANCED == (state = exec->getNext(&obj, NULL))) {
@@ -124,7 +124,7 @@ void appendReplicationInfo(OperationContext* txn, BSONObjBuilder& result, int le
             }
 
             if (level > 1) {
-                wassert(!txn->lockState()->isLocked());
+                wassert(!opCtx->lockState()->isLocked());
                 // note: there is no so-style timeout on this connection; perhaps we should have
                 // one.
                 ScopedDbConnection conn(s["host"].valuestr());
@@ -159,7 +159,7 @@ public:
         return true;
     }
 
-    BSONObj generateSection(OperationContext* txn, const BSONElement& configElement) const {
+    BSONObj generateSection(OperationContext* opCtx, const BSONElement& configElement) const {
         if (!getGlobalReplicationCoordinator()->isReplEnabled()) {
             return BSONObj();
         }
@@ -167,7 +167,7 @@ public:
         int level = configElement.numberInt();
 
         BSONObjBuilder result;
-        appendReplicationInfo(txn, result, level);
+        appendReplicationInfo(opCtx, result, level);
         getGlobalReplicationCoordinator()->processReplSetGetRBID(&result);
 
         return result.obj();
@@ -182,7 +182,7 @@ public:
         return false;
     }
 
-    BSONObj generateSection(OperationContext* txn, const BSONElement& configElement) const {
+    BSONObj generateSection(OperationContext* opCtx, const BSONElement& configElement) const {
         ReplicationCoordinator* replCoord = getGlobalReplicationCoordinator();
         if (!replCoord->isReplEnabled()) {
             return BSONObj();
@@ -199,7 +199,7 @@ public:
         BSONObj o;
         uassert(17347,
                 "Problem reading earliest entry from oplog",
-                Helpers::getSingleton(txn, oplogNS.c_str(), o));
+                Helpers::getSingleton(opCtx, oplogNS.c_str(), o));
         result.append("earliestOptime", o["ts"].timestamp());
         return result.obj();
     }
@@ -225,7 +225,7 @@ public:
                                        const BSONObj& cmdObj,
                                        std::vector<Privilege>* out) {}  // No auth required
     CmdIsMaster() : Command("isMaster", true, "ismaster") {}
-    virtual bool run(OperationContext* txn,
+    virtual bool run(OperationContext* opCtx,
                      const string&,
                      BSONObj& cmdObj,
                      int,
@@ -235,20 +235,20 @@ public:
            authenticated.
         */
         if (cmdObj["forShell"].trueValue()) {
-            LastError::get(txn->getClient()).disable();
+            LastError::get(opCtx->getClient()).disable();
         }
 
         // Tag connections to avoid closing them on stepdown.
         auto hangUpElement = cmdObj["hangUpOnStepDown"];
         if (!hangUpElement.eoo() && !hangUpElement.trueValue()) {
-            auto session = txn->getClient()->session();
+            auto session = opCtx->getClient()->session();
             if (session) {
                 session->replaceTags(session->getTags() |
                                      executor::NetworkInterface::kMessagingPortKeepOpen);
             }
         }
 
-        auto& clientMetadataIsMasterState = ClientMetadataIsMasterState::get(txn->getClient());
+        auto& clientMetadataIsMasterState = ClientMetadataIsMasterState::get(opCtx->getClient());
         bool seenIsMaster = clientMetadataIsMasterState.hasSeenIsMaster();
         if (!seenIsMaster) {
             clientMetadataIsMasterState.setSeenIsMaster();
@@ -271,13 +271,13 @@ public:
 
             invariant(swParseClientMetadata.getValue());
 
-            swParseClientMetadata.getValue().get().logClientMetadata(txn->getClient());
+            swParseClientMetadata.getValue().get().logClientMetadata(opCtx->getClient());
 
             clientMetadataIsMasterState.setClientMetadata(
-                txn->getClient(), std::move(swParseClientMetadata.getValue()));
+                opCtx->getClient(), std::move(swParseClientMetadata.getValue()));
         }
 
-        appendReplicationInfo(txn, result, 0);
+        appendReplicationInfo(opCtx, result, 0);
 
         if (serverGlobalParams.clusterRole == ClusterRole::ConfigServer) {
             // If we have feature compatibility version 3.4, use a config server mode that 3.2
@@ -302,10 +302,10 @@ public:
                                                   "automationServiceDescriptor",
                                                   static_cast<ServerParameter*>(nullptr));
         if (parameter)
-            parameter->append(txn, result, "automationServiceDescriptor");
+            parameter->append(opCtx, result, "automationServiceDescriptor");
 
-        if (txn->getClient()->session()) {
-            MessageCompressorManager::forSession(txn->getClient()->session())
+        if (opCtx->getClient()->session()) {
+            MessageCompressorManager::forSession(opCtx->getClient()->session())
                 .serverNegotiate(cmdObj, &result);
         }
 
diff --git a/src/mongo/db/repl/resync.cpp b/src/mongo/db/repl/resync.cpp
index e45022440a3..848700d215a 100644
--- a/src/mongo/db/repl/resync.cpp
+++ b/src/mongo/db/repl/resync.cpp
@@ -72,7 +72,7 @@ public:
     }
 
     CmdResync() : Command(kResyncFieldName) {}
-    virtual bool run(OperationContext* txn,
+    virtual bool run(OperationContext* opCtx,
                      const string& dbname,
                      BSONObj& cmdObj,
                      int,
@@ -100,16 +100,16 @@ public:
                 return appendCommandStatus(
                     result, Status(ErrorCodes::NotSecondary, "primaries cannot resync"));
             }
-            uassertStatusOKWithLocation(replCoord->resyncData(txn, waitForResync), "resync", 0);
+            uassertStatusOKWithLocation(replCoord->resyncData(opCtx, waitForResync), "resync", 0);
             return true;
         }
 
         // Master/Slave resync.
-        ScopedTransaction transaction(txn, MODE_X);
-        Lock::GlobalWrite globalWriteLock(txn->lockState());
+        ScopedTransaction transaction(opCtx, MODE_X);
+        Lock::GlobalWrite globalWriteLock(opCtx->lockState());
         // below this comment pertains only to master/slave replication
         if (cmdObj.getBoolField("force")) {
-            if (!waitForSyncToFinish(txn, errmsg))
+            if (!waitForSyncToFinish(opCtx, errmsg))
                 return false;
             replAllDead = "resync forced";
         }
@@ -118,16 +118,16 @@ public:
             errmsg = "not dead, no need to resync";
             return false;
         }
-        if (!waitForSyncToFinish(txn, errmsg))
+        if (!waitForSyncToFinish(opCtx, errmsg))
             return false;
 
-        ReplSource::forceResyncDead(txn, "client");
+        ReplSource::forceResyncDead(opCtx, "client");
         result.append("info", "triggered resync for all sources");
 
         return true;
     }
 
-    bool waitForSyncToFinish(OperationContext* txn, string& errmsg) const {
+    bool waitForSyncToFinish(OperationContext* opCtx, string& errmsg) const {
         // Wait for slave thread to finish syncing, so sources will be be
         // reloaded with new saved state on next pass.
         Timer t;
@@ -135,7 +135,7 @@ public:
             if (syncing.load() == 0 || t.millis() > 30000)
                 break;
             {
-                Lock::TempRelease t(txn->lockState());
+                Lock::TempRelease t(opCtx->lockState());
                 relinquishSyncingSome.store(1);
                 sleepmillis(1);
             }
diff --git a/src/mongo/db/repl/rollback_source.h b/src/mongo/db/repl/rollback_source.h
index 3e8d6f55578..4e068d336ce 100644
--- a/src/mongo/db/repl/rollback_source.h
+++ b/src/mongo/db/repl/rollback_source.h
@@ -76,7 +76,7 @@ public:
     /**
      * Clones a single collection from the sync source.
      */
-    virtual void copyCollectionFromRemote(OperationContext* txn,
+    virtual void copyCollectionFromRemote(OperationContext* opCtx,
                                           const NamespaceString& nss) const = 0;
 
     /**
diff --git a/src/mongo/db/repl/rollback_source_impl.cpp b/src/mongo/db/repl/rollback_source_impl.cpp
index 27513953dca..226edcc0a63 100644
--- a/src/mongo/db/repl/rollback_source_impl.cpp
+++ b/src/mongo/db/repl/rollback_source_impl.cpp
@@ -68,7 +68,7 @@ BSONObj RollbackSourceImpl::findOne(const NamespaceString& nss, const BSONObj& f
     return _getConnection()->findOne(nss.toString(), filter, NULL, QueryOption_SlaveOk).getOwned();
 }
 
-void RollbackSourceImpl::copyCollectionFromRemote(OperationContext* txn,
+void RollbackSourceImpl::copyCollectionFromRemote(OperationContext* opCtx,
                                                   const NamespaceString& nss) const {
     std::string errmsg;
     std::unique_ptr<DBClientConnection> tmpConn(new DBClientConnection());
@@ -82,7 +82,7 @@ void RollbackSourceImpl::copyCollectionFromRemote(OperationContext* txn,
     uassert(15909,
             str::stream() << "replSet rollback error resyncing collection " << nss.ns() << ' '
                           << errmsg,
-            cloner.copyCollection(txn, nss.ns(), BSONObj(), errmsg, true));
+            cloner.copyCollection(opCtx, nss.ns(), BSONObj(), errmsg, true));
 }
 
 StatusWith<BSONObj> RollbackSourceImpl::getCollectionInfo(const NamespaceString& nss) const {
diff --git a/src/mongo/db/repl/rollback_source_impl.h b/src/mongo/db/repl/rollback_source_impl.h
index fe4b7a8aad1..55f9237949b 100644
--- a/src/mongo/db/repl/rollback_source_impl.h
+++ b/src/mongo/db/repl/rollback_source_impl.h
@@ -64,7 +64,8 @@ public:
 
     BSONObj findOne(const NamespaceString& nss, const BSONObj& filter) const override;
 
-    void copyCollectionFromRemote(OperationContext* txn, const NamespaceString& nss) const override;
+    void copyCollectionFromRemote(OperationContext* opCtx,
+                                  const NamespaceString& nss) const override;
 
     StatusWith<BSONObj> getCollectionInfo(const NamespaceString& nss) const override;
 
diff --git a/src/mongo/db/repl/rs_initialsync.cpp b/src/mongo/db/repl/rs_initialsync.cpp
index 073afcc73ec..a6a5cf78baf 100644
--- a/src/mongo/db/repl/rs_initialsync.cpp
+++ b/src/mongo/db/repl/rs_initialsync.cpp
@@ -84,16 +84,16 @@ MONGO_EXPORT_SERVER_PARAMETER(num3Dot2InitialSyncAttempts, int, 10);
  * Also resets the bgsync thread so that it reconnects its sync source after the oplog has been
  * truncated.
  */
-void truncateAndResetOplog(OperationContext* txn,
+void truncateAndResetOplog(OperationContext* opCtx,
                            ReplicationCoordinator* replCoord,
                            BackgroundSync* bgsync) {
 
     // Add field to minvalid document to tell us to restart initial sync if we crash
-    StorageInterface::get(txn)->setInitialSyncFlag(txn);
+    StorageInterface::get(opCtx)->setInitialSyncFlag(opCtx);
 
-    AutoGetDb autoDb(txn, "local", MODE_X);
+    AutoGetDb autoDb(opCtx, "local", MODE_X);
     massert(28585, "no local database found", autoDb.getDb());
-    invariant(txn->lockState()->isCollectionLockedForMode(rsOplogName, MODE_X));
+    invariant(opCtx->lockState()->isCollectionLockedForMode(rsOplogName, MODE_X));
     // Note: the following order is important.
     // The bgsync thread uses an empty optime as a sentinel to know to wait
     // for initial sync; thus, we must
@@ -104,7 +104,7 @@ void truncateAndResetOplog(OperationContext* txn,
     replCoord->resetMyLastOpTimes();
     bgsync->stop(true);
     bgsync->startProducerIfStopped();
-    bgsync->clearBuffer(txn);
+    bgsync->clearBuffer(opCtx);
 
     replCoord->clearSyncSourceBlacklist();
 
@@ -112,15 +112,15 @@ void truncateAndResetOplog(OperationContext* txn,
     Collection* collection = autoDb.getDb()->getCollection(rsOplogName);
     fassert(28565, collection);
     MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
-        WriteUnitOfWork wunit(txn);
-        Status status = collection->truncate(txn);
+        WriteUnitOfWork wunit(opCtx);
+        Status status = collection->truncate(opCtx);
         fassert(28564, status);
         wunit.commit();
     }
-    MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "truncate", collection->ns().ns());
+    MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "truncate", collection->ns().ns());
 }
 
-bool _initialSyncClone(OperationContext* txn,
+bool _initialSyncClone(OperationContext* opCtx,
                        Cloner& cloner,
                        const std::string& host,
                        const std::string& db,
@@ -144,10 +144,10 @@ bool _initialSyncClone(OperationContext* txn,
     options.createCollections = false;
 
     // Make database stable
-    ScopedTransaction transaction(txn, MODE_IX);
-    Lock::DBLock dbWrite(txn->lockState(), db, MODE_X);
+    ScopedTransaction transaction(opCtx, MODE_IX);
+    Lock::DBLock dbWrite(opCtx->lockState(), db, MODE_X);
 
-    Status status = cloner.copyDb(txn, db, host, options, nullptr, collections);
+    Status status = cloner.copyDb(opCtx, db, host, options, nullptr, collections);
     if (!status.isOK()) {
         log() << "initial sync: error while " << (dataPass ? "cloning " : "indexing ") << db
               << ".  " << redact(status);
@@ -155,7 +155,7 @@ bool _initialSyncClone(OperationContext* txn,
     }
 
     if (dataPass && (db == "admin")) {
-        fassertNoTrace(28619, checkAdminDatabase(txn, dbHolder().get(txn, db)));
+        fassertNoTrace(28619, checkAdminDatabase(opCtx, dbHolder().get(opCtx, db)));
     }
     return true;
 }
@@ -167,7 +167,7 @@ bool _initialSyncClone(OperationContext* txn,
  * @param r      the oplog reader.
  * @return if applying the oplog succeeded.
  */
-bool _initialSyncApplyOplog(OperationContext* txn,
+bool _initialSyncApplyOplog(OperationContext* opCtx,
                             repl::InitialSync* syncer,
                             OplogReader* r,
                             BackgroundSync* bgsync) {
@@ -178,7 +178,7 @@ bool _initialSyncApplyOplog(OperationContext* txn,
     if (MONGO_FAIL_POINT(failInitSyncWithBufferedEntriesLeft)) {
         log() << "adding fake oplog entry to buffer.";
         bgsync->pushTestOpToBuffer(
-            txn,
+            opCtx,
             BSON("ts" << startOpTime.getTimestamp() << "t" << startOpTime.getTerm() << "v" << 1
                       << "op"
                       << "n"));
@@ -222,7 +222,7 @@ bool _initialSyncApplyOplog(OperationContext* txn,
     // apply till stopOpTime
     try {
         LOG(2) << "Applying oplog entries from " << startOpTime << " until " << stopOpTime;
-        syncer->oplogApplication(txn, stopOpTime);
+        syncer->oplogApplication(opCtx, stopOpTime);
 
         if (globalInShutdownDeprecated()) {
             return false;
@@ -262,15 +262,15 @@ bool _initialSyncApplyOplog(OperationContext* txn,
  * ErrorCode::InitialSyncOplogSourceMissing if the node fails to find an sync source, Status::OK
  * if everything worked, and ErrorCode::InitialSyncFailure for all other error cases.
  */
-Status _initialSync(OperationContext* txn, BackgroundSync* bgsync) {
+Status _initialSync(OperationContext* opCtx, BackgroundSync* bgsync) {
     log() << "initial sync pending";
 
-    txn->setReplicatedWrites(false);
-    DisableDocumentValidation validationDisabler(txn);
+    opCtx->setReplicatedWrites(false);
+    DisableDocumentValidation validationDisabler(opCtx);
     ReplicationCoordinator* replCoord(getGlobalReplicationCoordinator());
 
     // reset state for initial sync
-    truncateAndResetOplog(txn, replCoord, bgsync);
+    truncateAndResetOplog(opCtx, replCoord, bgsync);
 
     OplogReader r;
 
@@ -278,7 +278,7 @@ Status _initialSync(OperationContext* txn, BackgroundSync* bgsync) {
     while (r.getHost().empty()) {
         // We must prime the sync source selector so that it considers all candidates regardless
         // of oplog position, by passing in null OpTime as the last op fetched time.
-        r.connectToSyncSource(txn, OpTime(), OpTime(), replCoord);
+        r.connectToSyncSource(opCtx, OpTime(), OpTime(), replCoord);
 
         if (r.getHost().empty()) {
             std::string msg =
@@ -306,7 +306,7 @@ Status _initialSync(OperationContext* txn, BackgroundSync* bgsync) {
     }
 
     log() << "initial sync drop all databases";
-    dropAllDatabasesExceptLocal(txn);
+    dropAllDatabasesExceptLocal(opCtx);
 
     if (MONGO_FAIL_POINT(initialSyncHangBeforeCopyingDatabases)) {
         log() << "initial sync - initialSyncHangBeforeCopyingDatabases fail point enabled. "
@@ -360,17 +360,17 @@ Status _initialSync(OperationContext* txn, BackgroundSync* bgsync) {
             createCollectionParams.push_back(params);
         }
 
-        ScopedTransaction transaction(txn, MODE_IX);
-        Lock::DBLock dbWrite(txn->lockState(), db, MODE_X);
+        ScopedTransaction transaction(opCtx, MODE_IX);
+        Lock::DBLock dbWrite(opCtx->lockState(), db, MODE_X);
 
-        auto createStatus = cloner.createCollectionsForDb(txn, createCollectionParams, db);
+        auto createStatus = cloner.createCollectionsForDb(opCtx, createCollectionParams, db);
         if (!createStatus.isOK()) {
             return createStatus;
         }
         collectionsPerDb.emplace(db, std::move(collections));
     }
     for (auto&& dbCollsPair : collectionsPerDb) {
-        if (!_initialSyncClone(txn,
+        if (!_initialSyncClone(opCtx,
                                cloner,
                                r.conn()->getServerAddress(),
                                dbCollsPair.first,
@@ -385,15 +385,15 @@ Status _initialSync(OperationContext* txn, BackgroundSync* bgsync) {
     // prime oplog, but don't need to actually apply the op as the cloned data already reflects it.
     fassertStatusOK(
         40142,
-        StorageInterface::get(txn)->insertDocument(txn, NamespaceString(rsOplogName), lastOp));
+        StorageInterface::get(opCtx)->insertDocument(opCtx, NamespaceString(rsOplogName), lastOp));
     OpTime lastOptime = OplogEntry(lastOp).getOpTime();
-    ReplClientInfo::forClient(txn->getClient()).setLastOp(lastOptime);
+    ReplClientInfo::forClient(opCtx->getClient()).setLastOp(lastOptime);
     replCoord->setMyLastAppliedOpTime(lastOptime);
     setNewTimestamp(replCoord->getServiceContext(), lastOptime.getTimestamp());
 
     std::string msg = "oplog sync 1 of 3";
     log() << msg;
-    if (!_initialSyncApplyOplog(txn, &init, &r, bgsync)) {
+    if (!_initialSyncApplyOplog(opCtx, &init, &r, bgsync)) {
         return Status(ErrorCodes::InitialSyncFailure,
                       str::stream() << "initial sync failed: " << msg);
     }
@@ -404,7 +404,7 @@ Status _initialSync(OperationContext* txn, BackgroundSync* bgsync) {
     // TODO: replace with "tail" instance below, since we don't need to retry/reclone missing docs.
     msg = "oplog sync 2 of 3";
     log() << msg;
-    if (!_initialSyncApplyOplog(txn, &init, &r, bgsync)) {
+    if (!_initialSyncApplyOplog(opCtx, &init, &r, bgsync)) {
         return Status(ErrorCodes::InitialSyncFailure,
                       str::stream() << "initial sync failed: " << msg);
     }
@@ -413,7 +413,7 @@ Status _initialSync(OperationContext* txn, BackgroundSync* bgsync) {
     msg = "initial sync building indexes";
     log() << msg;
     for (auto&& dbCollsPair : collectionsPerDb) {
-        if (!_initialSyncClone(txn,
+        if (!_initialSyncClone(opCtx,
                                cloner,
                                r.conn()->getServerAddress(),
                                dbCollsPair.first,
@@ -431,14 +431,14 @@ Status _initialSync(OperationContext* txn, BackgroundSync* bgsync) {
     log() << msg;
 
     InitialSync tail(bgsync, multiSyncApply);  // Use the non-initial sync apply code
-    if (!_initialSyncApplyOplog(txn, &tail, &r, bgsync)) {
+    if (!_initialSyncApplyOplog(opCtx, &tail, &r, bgsync)) {
         return Status(ErrorCodes::InitialSyncFailure,
                       str::stream() << "initial sync failed: " << msg);
     }
 
     // ---------
 
-    Status status = getGlobalAuthorizationManager()->initialize(txn);
+    Status status = getGlobalAuthorizationManager()->initialize(opCtx);
     if (!status.isOK()) {
         warning() << "Failed to reinitialize auth data after initial sync. " << status;
         return status;
@@ -448,7 +448,7 @@ Status _initialSync(OperationContext* txn, BackgroundSync* bgsync) {
 
     // Initial sync is now complete.
     // Clear the initial sync flag -- cannot be done under a db lock, or recursive.
-    StorageInterface::get(txn)->clearInitialSyncFlag(txn);
+    StorageInterface::get(opCtx)->clearInitialSyncFlag(opCtx);
 
     // Clear maint. mode.
     while (replCoord->getMaintenanceMode()) {
@@ -463,20 +463,20 @@ stdx::mutex _initialSyncMutex;
 const auto kInitialSyncRetrySleepDuration = Seconds{5};
 }  // namespace
 
-Status checkAdminDatabase(OperationContext* txn, Database* adminDb) {
-    // Assumes txn holds MODE_X or MODE_S lock on "admin" database.
+Status checkAdminDatabase(OperationContext* opCtx, Database* adminDb) {
+    // Assumes opCtx holds MODE_X or MODE_S lock on "admin" database.
     if (!adminDb) {
         return Status::OK();
     }
     Collection* const usersCollection =
         adminDb->getCollection(AuthorizationManager::usersCollectionNamespace);
     const bool hasUsers =
-        usersCollection && !Helpers::findOne(txn, usersCollection, BSONObj(), false).isNull();
+        usersCollection && !Helpers::findOne(opCtx, usersCollection, BSONObj(), false).isNull();
     Collection* const adminVersionCollection =
         adminDb->getCollection(AuthorizationManager::versionCollectionNamespace);
     BSONObj authSchemaVersionDocument;
     if (!adminVersionCollection ||
-        !Helpers::findOne(txn,
+        !Helpers::findOne(opCtx,
                           adminVersionCollection,
                           AuthorizationManager::versionDocumentQuery,
                           authSchemaVersionDocument)) {
@@ -518,7 +518,7 @@ Status checkAdminDatabase(OperationContext* txn, Database* adminDb) {
     return Status::OK();
 }
 
-void syncDoInitialSync(OperationContext* txn,
+void syncDoInitialSync(OperationContext* opCtx,
                        ReplicationCoordinatorExternalState* replicationCoordinatorExternalState) {
     stdx::unique_lock<stdx::mutex> lk(_initialSyncMutex, stdx::defer_lock);
     if (!lk.try_lock()) {
@@ -530,21 +530,21 @@ void syncDoInitialSync(OperationContext* txn,
         log() << "Starting replication fetcher thread for initial sync";
         bgsync = stdx::make_unique<BackgroundSync>(
             replicationCoordinatorExternalState,
-            replicationCoordinatorExternalState->makeInitialSyncOplogBuffer(txn));
-        bgsync->startup(txn);
-        createOplog(txn);
+            replicationCoordinatorExternalState->makeInitialSyncOplogBuffer(opCtx));
+        bgsync->startup(opCtx);
+        createOplog(opCtx);
     }
-    ON_BLOCK_EXIT([txn, &bgsync]() {
+    ON_BLOCK_EXIT([opCtx, &bgsync]() {
         log() << "Stopping replication fetcher thread for initial sync";
-        bgsync->shutdown(txn);
-        bgsync->join(txn);
+        bgsync->shutdown(opCtx);
+        bgsync->join(opCtx);
     });
 
     int failedAttempts = 0;
     while (failedAttempts < num3Dot2InitialSyncAttempts.load()) {
         try {
             // leave loop when successful
-            Status status = _initialSync(txn, bgsync.get());
+            Status status = _initialSync(opCtx, bgsync.get());
             if (status.isOK()) {
                 break;
             } else {
diff --git a/src/mongo/db/repl/rs_initialsync.h b/src/mongo/db/repl/rs_initialsync.h
index a7206ac5c2e..d621eb17954 100644
--- a/src/mongo/db/repl/rs_initialsync.h
+++ b/src/mongo/db/repl/rs_initialsync.h
@@ -41,13 +41,13 @@ class ReplicationCoordinatorExternalState;
  * Begins an initial sync of a node.  This drops all data, chooses a sync source,
  * and runs the cloner from that sync source.  The node's state is not changed.
  */
-void syncDoInitialSync(OperationContext* txn,
+void syncDoInitialSync(OperationContext* opCtx,
                        ReplicationCoordinatorExternalState* replicationCoordinatorExternalState);
 
 /**
  * Checks that the "admin" database contains a supported version of the auth data schema.
  */
-Status checkAdminDatabase(OperationContext* txn, Database* adminDb);
+Status checkAdminDatabase(OperationContext* opCtx, Database* adminDb);
 
 }  // namespace repl
 }  // namespace mongo
diff --git a/src/mongo/db/repl/rs_rollback.cpp b/src/mongo/db/repl/rs_rollback.cpp
index dc5894cafc8..dbfb3a51284 100644
--- a/src/mongo/db/repl/rs_rollback.cpp
+++ b/src/mongo/db/repl/rs_rollback.cpp
@@ -335,7 +335,7 @@ namespace {
  * information from the upstream node. If any information is fetched from the upstream node after we
  * have written locally, the function must be called again.
  */
-void checkRbidAndUpdateMinValid(OperationContext* txn,
+void checkRbidAndUpdateMinValid(OperationContext* opCtx,
                                 const int rbid,
                                 const RollbackSource& rollbackSource) {
     // It is important that the steps are performed in order to avoid racing with upstream rollbacks
@@ -357,8 +357,8 @@ void checkRbidAndUpdateMinValid(OperationContext* txn,
     // online until we get to that point in freshness.
     OpTime minValid = fassertStatusOK(28774, OpTime::parseFromOplogEntry(newMinValidDoc));
     log() << "Setting minvalid to " << minValid;
-    StorageInterface::get(txn)->setAppliedThrough(txn, {});  // Use top of oplog.
-    StorageInterface::get(txn)->setMinValid(txn, minValid);
+    StorageInterface::get(opCtx)->setAppliedThrough(opCtx, {});  // Use top of oplog.
+    StorageInterface::get(opCtx)->setMinValid(opCtx, minValid);
 
     if (MONGO_FAIL_POINT(rollbackHangThenFailAfterWritingMinValid)) {
         // This log output is used in js tests so please leave it.
@@ -373,7 +373,7 @@ void checkRbidAndUpdateMinValid(OperationContext* txn,
     }
 }
 
-void syncFixUp(OperationContext* txn,
+void syncFixUp(OperationContext* opCtx,
                const FixUpInfo& fixUpInfo,
                const RollbackSource& rollbackSource,
                ReplicationCoordinator* replCoord) {
@@ -415,7 +415,7 @@ void syncFixUp(OperationContext* txn,
     }
 
     log() << "rollback 3.5";
-    checkRbidAndUpdateMinValid(txn, fixUpInfo.rbid, rollbackSource);
+    checkRbidAndUpdateMinValid(opCtx, fixUpInfo.rbid, rollbackSource);
 
     // update them
     log() << "rollback 4 n:" << goodVersions.size();
@@ -435,25 +435,25 @@ void syncFixUp(OperationContext* txn,
 
 
             {
-                ScopedTransaction transaction(txn, MODE_IX);
-                Lock::DBLock dbLock(txn->lockState(), nss.db(), MODE_X);
-                Database* db = dbHolder().openDb(txn, nss.db().toString());
+                ScopedTransaction transaction(opCtx, MODE_IX);
+                Lock::DBLock dbLock(opCtx->lockState(), nss.db(), MODE_X);
+                Database* db = dbHolder().openDb(opCtx, nss.db().toString());
                 invariant(db);
-                WriteUnitOfWork wunit(txn);
-                fassertStatusOK(40359, db->dropCollectionEvenIfSystem(txn, nss));
+                WriteUnitOfWork wunit(opCtx);
+                fassertStatusOK(40359, db->dropCollectionEvenIfSystem(opCtx, nss));
                 wunit.commit();
             }
 
-            rollbackSource.copyCollectionFromRemote(txn, nss);
+            rollbackSource.copyCollectionFromRemote(opCtx, nss);
         }
 
         for (const string& ns : fixUpInfo.collectionsToResyncMetadata) {
             log() << "rollback 4.1.2 coll metadata resync " << ns;
 
             const NamespaceString nss(ns);
-            ScopedTransaction transaction(txn, MODE_IX);
-            Lock::DBLock dbLock(txn->lockState(), nss.db(), MODE_X);
-            auto db = dbHolder().openDb(txn, nss.db().toString());
+            ScopedTransaction transaction(opCtx, MODE_IX);
+            Lock::DBLock dbLock(opCtx->lockState(), nss.db(), MODE_X);
+            auto db = dbHolder().openDb(opCtx, nss.db().toString());
             invariant(db);
             auto collection = db->getCollection(ns);
             invariant(collection);
@@ -490,23 +490,23 @@ void syncFixUp(OperationContext* txn,
                 // Use default options.
             }
 
-            WriteUnitOfWork wuow(txn);
-            if (options.flagsSet || cce->getCollectionOptions(txn).flagsSet) {
-                cce->updateFlags(txn, options.flags);
+            WriteUnitOfWork wuow(opCtx);
+            if (options.flagsSet || cce->getCollectionOptions(opCtx).flagsSet) {
+                cce->updateFlags(opCtx, options.flags);
             }
 
-            auto status = collection->setValidator(txn, options.validator);
+            auto status = collection->setValidator(opCtx, options.validator);
             if (!status.isOK()) {
                 throw RSFatalException(str::stream() << "Failed to set validator: "
                                                      << status.toString());
             }
-            status = collection->setValidationAction(txn, options.validationAction);
+            status = collection->setValidationAction(opCtx, options.validationAction);
             if (!status.isOK()) {
                 throw RSFatalException(str::stream() << "Failed to set validationAction: "
                                                      << status.toString());
             }
 
-            status = collection->setValidationLevel(txn, options.validationLevel);
+            status = collection->setValidationLevel(opCtx, options.validationLevel);
             if (!status.isOK()) {
                 throw RSFatalException(str::stream() << "Failed to set validationLevel: "
                                                      << status.toString());
@@ -518,7 +518,7 @@ void syncFixUp(OperationContext* txn,
         // we did more reading from primary, so check it again for a rollback (which would mess
         // us up), and make minValid newer.
         log() << "rollback 4.2";
-        checkRbidAndUpdateMinValid(txn, fixUpInfo.rbid, rollbackSource);
+        checkRbidAndUpdateMinValid(opCtx, fixUpInfo.rbid, rollbackSource);
     }
 
     log() << "rollback 4.6";
@@ -530,16 +530,16 @@ void syncFixUp(OperationContext* txn,
 
         invariant(!fixUpInfo.indexesToDrop.count(*it));
 
-        ScopedTransaction transaction(txn, MODE_IX);
+        ScopedTransaction transaction(opCtx, MODE_IX);
         const NamespaceString nss(*it);
-        Lock::DBLock dbLock(txn->lockState(), nss.db(), MODE_X);
-        Database* db = dbHolder().get(txn, nsToDatabaseSubstring(*it));
+        Lock::DBLock dbLock(opCtx->lockState(), nss.db(), MODE_X);
+        Database* db = dbHolder().get(opCtx, nsToDatabaseSubstring(*it));
         if (db) {
             Helpers::RemoveSaver removeSaver("rollback", "", *it);
 
             // perform a collection scan and write all documents in the collection to disk
             std::unique_ptr<PlanExecutor> exec(InternalPlanner::collectionScan(
-                txn, *it, db->getCollection(*it), PlanExecutor::YIELD_AUTO));
+                opCtx, *it, db->getCollection(*it), PlanExecutor::YIELD_AUTO));
             BSONObj curObj;
             PlanExecutor::ExecState execState;
             while (PlanExecutor::ADVANCED == (execState = exec->getNext(&curObj, NULL))) {
@@ -564,8 +564,8 @@ void syncFixUp(OperationContext* txn,
                 throw RSFatalException();
             }
 
-            WriteUnitOfWork wunit(txn);
-            fassertStatusOK(40360, db->dropCollectionEvenIfSystem(txn, nss));
+            WriteUnitOfWork wunit(opCtx);
+            fassertStatusOK(40360, db->dropCollectionEvenIfSystem(opCtx, nss));
             wunit.commit();
         }
     }
@@ -576,9 +576,9 @@ void syncFixUp(OperationContext* txn,
         const string& indexName = it->second;
         log() << "rollback drop index: collection: " << nss.toString() << ". index: " << indexName;
 
-        ScopedTransaction transaction(txn, MODE_IX);
-        Lock::DBLock dbLock(txn->lockState(), nss.db(), MODE_X);
-        auto db = dbHolder().get(txn, nss.db());
+        ScopedTransaction transaction(opCtx, MODE_IX);
+        Lock::DBLock dbLock(opCtx->lockState(), nss.db(), MODE_X);
+        auto db = dbHolder().get(opCtx, nss.db());
         if (!db) {
             continue;
         }
@@ -592,14 +592,14 @@ void syncFixUp(OperationContext* txn,
         }
         bool includeUnfinishedIndexes = false;
         auto indexDescriptor =
-            indexCatalog->findIndexByName(txn, indexName, includeUnfinishedIndexes);
+            indexCatalog->findIndexByName(opCtx, indexName, includeUnfinishedIndexes);
         if (!indexDescriptor) {
             warning() << "rollback failed to drop index " << indexName << " in " << nss.toString()
                       << ": index not found";
             continue;
         }
-        WriteUnitOfWork wunit(txn);
-        auto status = indexCatalog->dropIndex(txn, indexDescriptor);
+        WriteUnitOfWork wunit(opCtx);
+        auto status = indexCatalog->dropIndex(opCtx, indexDescriptor);
         if (!status.isOK()) {
             severe() << "rollback failed to drop index " << indexName << " in " << nss.toString()
                      << ": " << status;
@@ -637,9 +637,9 @@ void syncFixUp(OperationContext* txn,
 
                 // TODO: Lots of overhead in context. This can be faster.
                 const NamespaceString docNss(doc.ns);
-                ScopedTransaction transaction(txn, MODE_IX);
-                Lock::DBLock docDbLock(txn->lockState(), docNss.db(), MODE_X);
-                OldClientContext ctx(txn, doc.ns);
+                ScopedTransaction transaction(opCtx, MODE_IX);
+                Lock::DBLock docDbLock(opCtx->lockState(), docNss.db(), MODE_X);
+                OldClientContext ctx(opCtx, doc.ns);
 
                 Collection* collection = ctx.db()->getCollection(doc.ns);
 
@@ -651,7 +651,7 @@ void syncFixUp(OperationContext* txn,
                 // createCollection command and regardless, the document no longer exists.
                 if (collection && removeSaver) {
                     BSONObj obj;
-                    bool found = Helpers::findOne(txn, collection, pattern, obj, false);
+                    bool found = Helpers::findOne(opCtx, collection, pattern, obj, false);
                     if (found) {
                         auto status = removeSaver->goingToDelete(obj);
                         if (!status.isOK()) {
@@ -680,9 +680,9 @@ void syncFixUp(OperationContext* txn,
                                 // TODO: IIRC cappedTruncateAfter does not handle completely
                                 // empty.
                                 // this will crazy slow if no _id index.
-                                const auto clock = txn->getServiceContext()->getFastClockSource();
+                                const auto clock = opCtx->getServiceContext()->getFastClockSource();
                                 const auto findOneStart = clock->now();
-                                RecordId loc = Helpers::findOne(txn, collection, pattern, false);
+                                RecordId loc = Helpers::findOne(opCtx, collection, pattern, false);
                                 if (clock->now() - findOneStart > Milliseconds(200))
                                     warning() << "roll back slow no _id index for " << doc.ns
                                               << " perhaps?";
@@ -690,17 +690,17 @@ void syncFixUp(OperationContext* txn,
                                 // RecordId loc = Helpers::findById(nsd, pattern);
                                 if (!loc.isNull()) {
                                     try {
-                                        collection->cappedTruncateAfter(txn, loc, true);
+                                        collection->cappedTruncateAfter(opCtx, loc, true);
                                     } catch (const DBException& e) {
                                         if (e.getCode() == 13415) {
                                             // hack: need to just make cappedTruncate do this...
                                             MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
-                                                WriteUnitOfWork wunit(txn);
-                                                uassertStatusOK(collection->truncate(txn));
+                                                WriteUnitOfWork wunit(opCtx);
+                                                uassertStatusOK(collection->truncate(opCtx));
                                                 wunit.commit();
                                             }
                                             MONGO_WRITE_CONFLICT_RETRY_LOOP_END(
-                                                txn, "truncate", collection->ns().ns());
+                                                opCtx, "truncate", collection->ns().ns());
                                         } else {
                                             throw e;
                                         }
@@ -717,7 +717,7 @@ void syncFixUp(OperationContext* txn,
                                           << ": " << redact(e);
                             }
                         } else {
-                            deleteObjects(txn,
+                            deleteObjects(opCtx,
                                           collection,
                                           doc.ns,
                                           pattern,
@@ -740,7 +740,7 @@ void syncFixUp(OperationContext* txn,
                     UpdateLifecycleImpl updateLifecycle(requestNs);
                     request.setLifecycle(&updateLifecycle);
 
-                    update(txn, ctx.db(), request);
+                    update(opCtx, ctx.db(), request);
                 }
             } catch (const DBException& e) {
                 log() << "exception in rollback ns:" << doc.ns << ' ' << pattern.toString() << ' '
@@ -757,10 +757,10 @@ void syncFixUp(OperationContext* txn,
     LOG(2) << "rollback truncate oplog after " << fixUpInfo.commonPoint.toString();
     {
         const NamespaceString oplogNss(rsOplogName);
-        ScopedTransaction transaction(txn, MODE_IX);
-        Lock::DBLock oplogDbLock(txn->lockState(), oplogNss.db(), MODE_IX);
-        Lock::CollectionLock oplogCollectionLoc(txn->lockState(), oplogNss.ns(), MODE_X);
-        OldClientContext ctx(txn, rsOplogName);
+        ScopedTransaction transaction(opCtx, MODE_IX);
+        Lock::DBLock oplogDbLock(opCtx->lockState(), oplogNss.db(), MODE_IX);
+        Lock::CollectionLock oplogCollectionLoc(opCtx->lockState(), oplogNss.ns(), MODE_X);
+        OldClientContext ctx(opCtx, rsOplogName);
         Collection* oplogCollection = ctx.db()->getCollection(rsOplogName);
         if (!oplogCollection) {
             fassertFailedWithStatusNoTrace(13423,
@@ -768,10 +768,10 @@ void syncFixUp(OperationContext* txn,
                                                   str::stream() << "Can't find " << rsOplogName));
         }
         // TODO: fatal error if this throws?
-        oplogCollection->cappedTruncateAfter(txn, fixUpInfo.commonPointOurDiskloc, false);
+        oplogCollection->cappedTruncateAfter(opCtx, fixUpInfo.commonPointOurDiskloc, false);
     }
 
-    Status status = getGlobalAuthorizationManager()->initialize(txn);
+    Status status = getGlobalAuthorizationManager()->initialize(opCtx);
     if (!status.isOK()) {
         severe() << "Failed to reinitialize auth data after rollback: " << status;
         fassertFailedNoTrace(40366);
@@ -779,16 +779,16 @@ void syncFixUp(OperationContext* txn,
 
     // Reload the lastAppliedOpTime and lastDurableOpTime value in the replcoord and the
     // lastAppliedHash value in bgsync to reflect our new last op.
-    replCoord->resetLastOpTimesFromOplog(txn);
+    replCoord->resetLastOpTimesFromOplog(opCtx);
     log() << "rollback done";
 }
 
-Status _syncRollback(OperationContext* txn,
+Status _syncRollback(OperationContext* opCtx,
                      const OplogInterface& localOplog,
                      const RollbackSource& rollbackSource,
                      boost::optional<int> requiredRBID,
                      ReplicationCoordinator* replCoord) {
-    invariant(!txn->lockState()->isLocked());
+    invariant(!opCtx->lockState()->isLocked());
 
     FixUpInfo how;
     log() << "rollback 1";
@@ -833,7 +833,7 @@ Status _syncRollback(OperationContext* txn,
     log() << "rollback 3 fixup";
     try {
         ON_BLOCK_EXIT([&] { replCoord->incrementRollbackID(); });
-        syncFixUp(txn, how, rollbackSource, replCoord);
+        syncFixUp(opCtx, how, rollbackSource, replCoord);
     } catch (const RSFatalException& e) {
         return Status(ErrorCodes::UnrecoverableRollbackError, e.what(), 18753);
     }
@@ -853,19 +853,19 @@ Status _syncRollback(OperationContext* txn,
 
 }  // namespace
 
-Status syncRollback(OperationContext* txn,
+Status syncRollback(OperationContext* opCtx,
                     const OplogInterface& localOplog,
                     const RollbackSource& rollbackSource,
                     boost::optional<int> requiredRBID,
                     ReplicationCoordinator* replCoord) {
-    invariant(txn);
+    invariant(opCtx);
     invariant(replCoord);
 
     log() << "beginning rollback" << rsLog;
 
-    DisableDocumentValidation validationDisabler(txn);
-    UnreplicatedWritesBlock replicationDisabler(txn);
-    Status status = _syncRollback(txn, localOplog, rollbackSource, requiredRBID, replCoord);
+    DisableDocumentValidation validationDisabler(opCtx);
+    UnreplicatedWritesBlock replicationDisabler(opCtx);
+    Status status = _syncRollback(opCtx, localOplog, rollbackSource, requiredRBID, replCoord);
 
     log() << "rollback finished" << rsLog;
     return status;
diff --git a/src/mongo/db/repl/rs_rollback.h b/src/mongo/db/repl/rs_rollback.h
index 8ee7dd04367..58dd4a27d4f 100644
--- a/src/mongo/db/repl/rs_rollback.h
+++ b/src/mongo/db/repl/rs_rollback.h
@@ -59,7 +59,7 @@ class RollbackSource;
  * This function runs a command on the sync source to detect if the sync source rolls back
  * while our rollback is in progress.
  *
- * @param txn Used to read and write from this node's databases
+ * @param opCtx Used to read and write from this node's databases
  * @param localOplog reads the oplog on this server.
  * @param rollbackSource interface for sync source:
  *            provides oplog; and
@@ -73,7 +73,7 @@ class RollbackSource;
  * fatally. All other errors should be considered recoverable regardless of whether reported as a
  * status or exception.
  */
-Status syncRollback(OperationContext* txn,
+Status syncRollback(OperationContext* opCtx,
                     const OplogInterface& localOplog,
                     const RollbackSource& rollbackSource,
                     boost::optional<int> requiredRBID,
diff --git a/src/mongo/db/repl/rs_rollback_test.cpp b/src/mongo/db/repl/rs_rollback_test.cpp
index 988fe98face..22e7a677fea 100644
--- a/src/mongo/db/repl/rs_rollback_test.cpp
+++ b/src/mongo/db/repl/rs_rollback_test.cpp
@@ -79,7 +79,7 @@ class ReplicationCoordinatorRollbackMock : public ReplicationCoordinatorMock {
 public:
     ReplicationCoordinatorRollbackMock(ServiceContext* service)
         : ReplicationCoordinatorMock(service, createReplSettings()) {}
-    void resetLastOpTimesFromOplog(OperationContext* txn) override {}
+    void resetLastOpTimesFromOplog(OperationContext* opCtx) override {}
 };
 
 
@@ -90,7 +90,8 @@ public:
     const OplogInterface& getOplog() const override;
     BSONObj getLastOperation() const override;
     BSONObj findOne(const NamespaceString& nss, const BSONObj& filter) const override;
-    void copyCollectionFromRemote(OperationContext* txn, const NamespaceString& nss) const override;
+    void copyCollectionFromRemote(OperationContext* opCtx,
+                                  const NamespaceString& nss) const override;
     StatusWith<BSONObj> getCollectionInfo(const NamespaceString& nss) const override;
 
 private:
@@ -119,7 +120,7 @@ BSONObj RollbackSourceMock::findOne(const NamespaceString& nss, const BSONObj& f
     return BSONObj();
 }
 
-void RollbackSourceMock::copyCollectionFromRemote(OperationContext* txn,
+void RollbackSourceMock::copyCollectionFromRemote(OperationContext* opCtx,
                                                   const NamespaceString& nss) const {}
 
 StatusWith<BSONObj> RollbackSourceMock::getCollectionInfo(const NamespaceString& nss) const {
@@ -128,7 +129,7 @@ StatusWith<BSONObj> RollbackSourceMock::getCollectionInfo(const NamespaceString&
 
 class RSRollbackTest : public ServiceContextMongoDTest {
 protected:
-    ServiceContext::UniqueOperationContext _txn;
+    ServiceContext::UniqueOperationContext _opCtx;
 
     // Owned by service context
     ReplicationCoordinator* _coordinator;
@@ -140,8 +141,8 @@ private:
 
 void RSRollbackTest::setUp() {
     ServiceContextMongoDTest::setUp();
-    _txn = cc().makeOperationContext();
-    _coordinator = new ReplicationCoordinatorRollbackMock(_txn->getServiceContext());
+    _opCtx = cc().makeOperationContext();
+    _coordinator = new ReplicationCoordinatorRollbackMock(_opCtx->getServiceContext());
 
     auto serviceContext = getServiceContext();
     ReplicationCoordinator::set(serviceContext,
@@ -149,22 +150,22 @@ void RSRollbackTest::setUp() {
     StorageInterface::set(serviceContext, stdx::make_unique<StorageInterfaceMock>());
 
     setOplogCollectionName();
-    repl::StorageInterface::get(_txn.get())->setAppliedThrough(_txn.get(), OpTime{});
-    repl::StorageInterface::get(_txn.get())->setMinValid(_txn.get(), OpTime{});
+    repl::StorageInterface::get(_opCtx.get())->setAppliedThrough(_opCtx.get(), OpTime{});
+    repl::StorageInterface::get(_opCtx.get())->setMinValid(_opCtx.get(), OpTime{});
 }
 
 void RSRollbackTest::tearDown() {
-    _txn.reset();
+    _opCtx.reset();
     ServiceContextMongoDTest::tearDown();
     setGlobalReplicationCoordinator(nullptr);
 }
 
 TEST_F(RSRollbackTest, InconsistentMinValid) {
-    repl::StorageInterface::get(_txn.get())
-        ->setAppliedThrough(_txn.get(), OpTime(Timestamp(Seconds(0), 0), 0));
-    repl::StorageInterface::get(_txn.get())
-        ->setMinValid(_txn.get(), OpTime(Timestamp(Seconds(1), 0), 0));
-    auto status = syncRollback(_txn.get(),
+    repl::StorageInterface::get(_opCtx.get())
+        ->setAppliedThrough(_opCtx.get(), OpTime(Timestamp(Seconds(0), 0), 0));
+    repl::StorageInterface::get(_opCtx.get())
+        ->setMinValid(_opCtx.get(), OpTime(Timestamp(Seconds(1), 0), 0));
+    auto status = syncRollback(_opCtx.get(),
                                OplogInterfaceMock(kEmptyMockOperations),
                                RollbackSourceMock(std::unique_ptr<OplogInterface>(
                                    new OplogInterfaceMock(kEmptyMockOperations))),
@@ -180,7 +181,7 @@ TEST_F(RSRollbackTest, OplogStartMissing) {
         std::make_pair(BSON("ts" << ts.getTimestamp() << "h" << ts.getTerm()), RecordId());
     ASSERT_EQUALS(
         ErrorCodes::OplogStartMissing,
-        syncRollback(_txn.get(),
+        syncRollback(_opCtx.get(),
                      OplogInterfaceMock(kEmptyMockOperations),
                      RollbackSourceMock(std::unique_ptr<OplogInterface>(new OplogInterfaceMock({
                          operation,
@@ -194,7 +195,7 @@ TEST_F(RSRollbackTest, NoRemoteOpLog) {
     OpTime ts(Timestamp(Seconds(1), 0), 0);
     auto operation =
         std::make_pair(BSON("ts" << ts.getTimestamp() << "h" << ts.getTerm()), RecordId());
-    auto status = syncRollback(_txn.get(),
+    auto status = syncRollback(_opCtx.get(),
                                OplogInterfaceMock({operation}),
                                RollbackSourceMock(std::unique_ptr<OplogInterface>(
                                    new OplogInterfaceMock(kEmptyMockOperations))),
@@ -216,7 +217,7 @@ TEST_F(RSRollbackTest, RemoteGetRollbackIdThrows) {
             uassert(ErrorCodes::UnknownError, "getRollbackId() failed", false);
         }
     };
-    ASSERT_THROWS_CODE(syncRollback(_txn.get(),
+    ASSERT_THROWS_CODE(syncRollback(_opCtx.get(),
                                     OplogInterfaceMock({operation}),
                                     RollbackSourceLocal(std::unique_ptr<OplogInterface>(
                                         new OplogInterfaceMock(kEmptyMockOperations))),
@@ -239,7 +240,7 @@ TEST_F(RSRollbackTest, RemoteGetRollbackIdDiffersFromRequiredRBID) {
         }
     };
 
-    ASSERT_THROWS_CODE(syncRollback(_txn.get(),
+    ASSERT_THROWS_CODE(syncRollback(_opCtx.get(),
                                     OplogInterfaceMock({operation}),
                                     RollbackSourceLocal(std::unique_ptr<OplogInterface>(
                                         new OplogInterfaceMock(kEmptyMockOperations))),
@@ -250,12 +251,12 @@ TEST_F(RSRollbackTest, RemoteGetRollbackIdDiffersFromRequiredRBID) {
 }
 
 TEST_F(RSRollbackTest, BothOplogsAtCommonPoint) {
-    createOplog(_txn.get());
+    createOplog(_opCtx.get());
     OpTime ts(Timestamp(Seconds(1), 0), 1);
     auto operation =
         std::make_pair(BSON("ts" << ts.getTimestamp() << "h" << ts.getTerm()), RecordId(1));
     ASSERT_OK(
-        syncRollback(_txn.get(),
+        syncRollback(_opCtx.get(),
                      OplogInterfaceMock({operation}),
                      RollbackSourceMock(std::unique_ptr<OplogInterface>(new OplogInterfaceMock({
                          operation,
@@ -268,24 +269,24 @@ TEST_F(RSRollbackTest, BothOplogsAtCommonPoint) {
  * Create test collection.
  * Returns collection.
  */
-Collection* _createCollection(OperationContext* txn,
+Collection* _createCollection(OperationContext* opCtx,
                               const NamespaceString& nss,
                               const CollectionOptions& options) {
-    Lock::DBLock dbLock(txn->lockState(), nss.db(), MODE_X);
-    mongo::WriteUnitOfWork wuow(txn);
-    auto db = dbHolder().openDb(txn, nss.db());
+    Lock::DBLock dbLock(opCtx->lockState(), nss.db(), MODE_X);
+    mongo::WriteUnitOfWork wuow(opCtx);
+    auto db = dbHolder().openDb(opCtx, nss.db());
     ASSERT_TRUE(db);
-    db->dropCollection(txn, nss.ns());
-    auto coll = db->createCollection(txn, nss.ns(), options);
+    db->dropCollection(opCtx, nss.ns());
+    auto coll = db->createCollection(opCtx, nss.ns(), options);
     ASSERT_TRUE(coll);
     wuow.commit();
     return coll;
 }
 
-Collection* _createCollection(OperationContext* txn,
+Collection* _createCollection(OperationContext* opCtx,
                               const std::string& nss,
                               const CollectionOptions& options) {
-    return _createCollection(txn, NamespaceString(nss), options);
+    return _createCollection(opCtx, NamespaceString(nss), options);
 }
 
 /**
@@ -293,7 +294,7 @@ Collection* _createCollection(OperationContext* txn,
  * Returns number of records in collection after rolling back delete operation.
  * If collection does not exist after rolling back, returns -1.
  */
-int _testRollbackDelete(OperationContext* txn,
+int _testRollbackDelete(OperationContext* opCtx,
                         ReplicationCoordinator* coordinator,
                         const BSONObj& documentAtSource) {
     auto commonOperation =
@@ -325,54 +326,54 @@ int _testRollbackDelete(OperationContext* txn,
                                        std::unique_ptr<OplogInterface>(new OplogInterfaceMock({
                                            commonOperation,
                                        })));
-    ASSERT_OK(syncRollback(txn,
+    ASSERT_OK(syncRollback(opCtx,
                            OplogInterfaceMock({deleteOperation, commonOperation}),
                            rollbackSource,
                            {},
                            coordinator));
     ASSERT_TRUE(rollbackSource.called);
 
-    Lock::DBLock dbLock(txn->lockState(), "test", MODE_S);
-    Lock::CollectionLock collLock(txn->lockState(), "test.t", MODE_S);
-    auto db = dbHolder().get(txn, "test");
+    Lock::DBLock dbLock(opCtx->lockState(), "test", MODE_S);
+    Lock::CollectionLock collLock(opCtx->lockState(), "test.t", MODE_S);
+    auto db = dbHolder().get(opCtx, "test");
     ASSERT_TRUE(db);
     auto collection = db->getCollection("test.t");
     if (!collection) {
         return -1;
     }
-    return collection->getRecordStore()->numRecords(txn);
+    return collection->getRecordStore()->numRecords(opCtx);
 }
 
 TEST_F(RSRollbackTest, RollbackDeleteNoDocumentAtSourceCollectionDoesNotExist) {
-    createOplog(_txn.get());
-    ASSERT_EQUALS(-1, _testRollbackDelete(_txn.get(), _coordinator, BSONObj()));
+    createOplog(_opCtx.get());
+    ASSERT_EQUALS(-1, _testRollbackDelete(_opCtx.get(), _coordinator, BSONObj()));
 }
 
 TEST_F(RSRollbackTest, RollbackDeleteNoDocumentAtSourceCollectionExistsNonCapped) {
-    createOplog(_txn.get());
-    _createCollection(_txn.get(), "test.t", CollectionOptions());
-    _testRollbackDelete(_txn.get(), _coordinator, BSONObj());
-    ASSERT_EQUALS(0, _testRollbackDelete(_txn.get(), _coordinator, BSONObj()));
+    createOplog(_opCtx.get());
+    _createCollection(_opCtx.get(), "test.t", CollectionOptions());
+    _testRollbackDelete(_opCtx.get(), _coordinator, BSONObj());
+    ASSERT_EQUALS(0, _testRollbackDelete(_opCtx.get(), _coordinator, BSONObj()));
 }
 
 TEST_F(RSRollbackTest, RollbackDeleteNoDocumentAtSourceCollectionExistsCapped) {
-    createOplog(_txn.get());
+    createOplog(_opCtx.get());
     CollectionOptions options;
     options.capped = true;
-    _createCollection(_txn.get(), "test.t", options);
-    ASSERT_EQUALS(0, _testRollbackDelete(_txn.get(), _coordinator, BSONObj()));
+    _createCollection(_opCtx.get(), "test.t", options);
+    ASSERT_EQUALS(0, _testRollbackDelete(_opCtx.get(), _coordinator, BSONObj()));
 }
 
 TEST_F(RSRollbackTest, RollbackDeleteRestoreDocument) {
-    createOplog(_txn.get());
-    _createCollection(_txn.get(), "test.t", CollectionOptions());
+    createOplog(_opCtx.get());
+    _createCollection(_opCtx.get(), "test.t", CollectionOptions());
     BSONObj doc = BSON("_id" << 0 << "a" << 1);
-    _testRollbackDelete(_txn.get(), _coordinator, doc);
-    ASSERT_EQUALS(1, _testRollbackDelete(_txn.get(), _coordinator, doc));
+    _testRollbackDelete(_opCtx.get(), _coordinator, doc);
+    ASSERT_EQUALS(1, _testRollbackDelete(_opCtx.get(), _coordinator, doc));
 }
 
 TEST_F(RSRollbackTest, RollbackInsertDocumentWithNoId) {
-    createOplog(_txn.get());
+    createOplog(_opCtx.get());
     auto commonOperation =
         std::make_pair(BSON("ts" << Timestamp(Seconds(1), 0) << "h" << 1LL), RecordId(1));
     auto insertDocumentOperation =
@@ -400,7 +401,7 @@ TEST_F(RSRollbackTest, RollbackInsertDocumentWithNoId) {
         commonOperation,
     })));
     startCapturingLogMessages();
-    auto status = syncRollback(_txn.get(),
+    auto status = syncRollback(_opCtx.get(),
                                OplogInterfaceMock({insertDocumentOperation, commonOperation}),
                                rollbackSource,
                                {},
@@ -413,8 +414,8 @@ TEST_F(RSRollbackTest, RollbackInsertDocumentWithNoId) {
 }
 
 TEST_F(RSRollbackTest, RollbackCreateIndexCommand) {
-    createOplog(_txn.get());
-    auto collection = _createCollection(_txn.get(), "test.t", CollectionOptions());
+    createOplog(_opCtx.get());
+    auto collection = _createCollection(_opCtx.get(), "test.t", CollectionOptions());
     auto indexSpec = BSON("ns"
                           << "test.t"
                           << "key"
@@ -424,15 +425,15 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommand) {
                           << "v"
                           << static_cast<int>(kIndexVersion));
     {
-        Lock::DBLock dbLock(_txn->lockState(), "test", MODE_X);
-        MultiIndexBlock indexer(_txn.get(), collection);
+        Lock::DBLock dbLock(_opCtx->lockState(), "test", MODE_X);
+        MultiIndexBlock indexer(_opCtx.get(), collection);
         ASSERT_OK(indexer.init(indexSpec).getStatus());
-        WriteUnitOfWork wunit(_txn.get());
+        WriteUnitOfWork wunit(_opCtx.get());
         indexer.commit();
         wunit.commit();
         auto indexCatalog = collection->getIndexCatalog();
         ASSERT(indexCatalog);
-        ASSERT_EQUALS(2, indexCatalog->numIndexesReady(_txn.get()));
+        ASSERT_EQUALS(2, indexCatalog->numIndexesReady(_opCtx.get()));
     }
     auto commonOperation =
         std::make_pair(BSON("ts" << Timestamp(Seconds(1), 0) << "h" << 1LL), RecordId(1));
@@ -448,7 +449,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommand) {
     public:
         RollbackSourceLocal(std::unique_ptr<OplogInterface> oplog)
             : RollbackSourceMock(std::move(oplog)), called(false) {}
-        void copyCollectionFromRemote(OperationContext* txn,
+        void copyCollectionFromRemote(OperationContext* opCtx,
                                       const NamespaceString& nss) const override {
             called = true;
         }
@@ -464,7 +465,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommand) {
     // This can happen when an index is re-created with different options.
     startCapturingLogMessages();
     ASSERT_OK(syncRollback(
-        _txn.get(),
+        _opCtx.get(),
         OplogInterfaceMock({insertDocumentOperation, insertDocumentOperation, commonOperation}),
         rollbackSource,
         {},
@@ -474,16 +475,16 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommand) {
                   countLogLinesContaining("rollback drop index: collection: test.t. index: a_1"));
     ASSERT_FALSE(rollbackSource.called);
     {
-        Lock::DBLock dbLock(_txn->lockState(), "test", MODE_S);
+        Lock::DBLock dbLock(_opCtx->lockState(), "test", MODE_S);
         auto indexCatalog = collection->getIndexCatalog();
         ASSERT(indexCatalog);
-        ASSERT_EQUALS(1, indexCatalog->numIndexesReady(_txn.get()));
+        ASSERT_EQUALS(1, indexCatalog->numIndexesReady(_opCtx.get()));
     }
 }
 
 TEST_F(RSRollbackTest, RollbackCreateIndexCommandIndexNotInCatalog) {
-    createOplog(_txn.get());
-    auto collection = _createCollection(_txn.get(), "test.t", CollectionOptions());
+    createOplog(_opCtx.get());
+    auto collection = _createCollection(_opCtx.get(), "test.t", CollectionOptions());
     auto indexSpec = BSON("ns"
                           << "test.t"
                           << "key"
@@ -492,10 +493,10 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandIndexNotInCatalog) {
                           << "a_1");
     // Skip index creation to trigger warning during rollback.
     {
-        Lock::DBLock dbLock(_txn->lockState(), "test", MODE_S);
+        Lock::DBLock dbLock(_opCtx->lockState(), "test", MODE_S);
         auto indexCatalog = collection->getIndexCatalog();
         ASSERT(indexCatalog);
-        ASSERT_EQUALS(1, indexCatalog->numIndexesReady(_txn.get()));
+        ASSERT_EQUALS(1, indexCatalog->numIndexesReady(_opCtx.get()));
     }
     auto commonOperation =
         std::make_pair(BSON("ts" << Timestamp(Seconds(1), 0) << "h" << 1LL), RecordId(1));
@@ -511,7 +512,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandIndexNotInCatalog) {
     public:
         RollbackSourceLocal(std::unique_ptr<OplogInterface> oplog)
             : RollbackSourceMock(std::move(oplog)), called(false) {}
-        void copyCollectionFromRemote(OperationContext* txn,
+        void copyCollectionFromRemote(OperationContext* opCtx,
                                       const NamespaceString& nss) const override {
             called = true;
         }
@@ -524,7 +525,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandIndexNotInCatalog) {
         commonOperation,
     })));
     startCapturingLogMessages();
-    ASSERT_OK(syncRollback(_txn.get(),
+    ASSERT_OK(syncRollback(_opCtx.get(),
                            OplogInterfaceMock({insertDocumentOperation, commonOperation}),
                            rollbackSource,
                            {},
@@ -535,15 +536,15 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandIndexNotInCatalog) {
     ASSERT_EQUALS(1, countLogLinesContaining("rollback failed to drop index a_1 in test.t"));
     ASSERT_FALSE(rollbackSource.called);
     {
-        Lock::DBLock dbLock(_txn->lockState(), "test", MODE_S);
+        Lock::DBLock dbLock(_opCtx->lockState(), "test", MODE_S);
         auto indexCatalog = collection->getIndexCatalog();
         ASSERT(indexCatalog);
-        ASSERT_EQUALS(1, indexCatalog->numIndexesReady(_txn.get()));
+        ASSERT_EQUALS(1, indexCatalog->numIndexesReady(_opCtx.get()));
     }
 }
 
 TEST_F(RSRollbackTest, RollbackCreateIndexCommandMissingNamespace) {
-    createOplog(_txn.get());
+    createOplog(_opCtx.get());
     auto commonOperation =
         std::make_pair(BSON("ts" << Timestamp(Seconds(1), 0) << "h" << 1LL), RecordId(1));
     auto insertDocumentOperation =
@@ -559,7 +560,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandMissingNamespace) {
     public:
         RollbackSourceLocal(std::unique_ptr<OplogInterface> oplog)
             : RollbackSourceMock(std::move(oplog)), called(false) {}
-        void copyCollectionFromRemote(OperationContext* txn,
+        void copyCollectionFromRemote(OperationContext* opCtx,
                                       const NamespaceString& nss) const override {
             called = true;
         }
@@ -572,7 +573,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandMissingNamespace) {
         commonOperation,
     })));
     startCapturingLogMessages();
-    auto status = syncRollback(_txn.get(),
+    auto status = syncRollback(_opCtx.get(),
                                OplogInterfaceMock({insertDocumentOperation, commonOperation}),
                                rollbackSource,
                                {},
@@ -586,7 +587,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandMissingNamespace) {
 }
 
 TEST_F(RSRollbackTest, RollbackCreateIndexCommandInvalidNamespace) {
-    createOplog(_txn.get());
+    createOplog(_opCtx.get());
     auto commonOperation =
         std::make_pair(BSON("ts" << Timestamp(Seconds(1), 0) << "h" << 1LL), RecordId(1));
     auto insertDocumentOperation =
@@ -606,7 +607,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandInvalidNamespace) {
     public:
         RollbackSourceLocal(std::unique_ptr<OplogInterface> oplog)
             : RollbackSourceMock(std::move(oplog)), called(false) {}
-        void copyCollectionFromRemote(OperationContext* txn,
+        void copyCollectionFromRemote(OperationContext* opCtx,
                                       const NamespaceString& nss) const override {
             called = true;
         }
@@ -619,7 +620,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandInvalidNamespace) {
         commonOperation,
     })));
     startCapturingLogMessages();
-    auto status = syncRollback(_txn.get(),
+    auto status = syncRollback(_opCtx.get(),
                                OplogInterfaceMock({insertDocumentOperation, commonOperation}),
                                rollbackSource,
                                {},
@@ -633,7 +634,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandInvalidNamespace) {
 }
 
 TEST_F(RSRollbackTest, RollbackCreateIndexCommandMissingIndexName) {
-    createOplog(_txn.get());
+    createOplog(_opCtx.get());
     auto commonOperation =
         std::make_pair(BSON("ts" << Timestamp(Seconds(1), 0) << "h" << 1LL), RecordId(1));
     auto insertDocumentOperation =
@@ -651,7 +652,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandMissingIndexName) {
     public:
         RollbackSourceLocal(std::unique_ptr<OplogInterface> oplog)
             : RollbackSourceMock(std::move(oplog)), called(false) {}
-        void copyCollectionFromRemote(OperationContext* txn,
+        void copyCollectionFromRemote(OperationContext* opCtx,
                                       const NamespaceString& nss) const override {
             called = true;
         }
@@ -664,7 +665,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandMissingIndexName) {
         commonOperation,
     })));
     startCapturingLogMessages();
-    auto status = syncRollback(_txn.get(),
+    auto status = syncRollback(_opCtx.get(),
                                OplogInterfaceMock({insertDocumentOperation, commonOperation}),
                                rollbackSource,
                                {},
@@ -677,7 +678,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandMissingIndexName) {
 }
 
 TEST_F(RSRollbackTest, RollbackUnknownCommand) {
-    createOplog(_txn.get());
+    createOplog(_opCtx.get());
     auto commonOperation =
         std::make_pair(BSON("ts" << Timestamp(Seconds(1), 0) << "h" << 1LL), RecordId(1));
     auto unknownCommandOperation =
@@ -690,15 +691,15 @@ TEST_F(RSRollbackTest, RollbackUnknownCommand) {
                                          << "t")),
                        RecordId(2));
     {
-        Lock::DBLock dbLock(_txn->lockState(), "test", MODE_X);
-        mongo::WriteUnitOfWork wuow(_txn.get());
-        auto db = dbHolder().openDb(_txn.get(), "test");
+        Lock::DBLock dbLock(_opCtx->lockState(), "test", MODE_X);
+        mongo::WriteUnitOfWork wuow(_opCtx.get());
+        auto db = dbHolder().openDb(_opCtx.get(), "test");
         ASSERT_TRUE(db);
-        ASSERT_TRUE(db->getOrCreateCollection(_txn.get(), "test.t"));
+        ASSERT_TRUE(db->getOrCreateCollection(_opCtx.get(), "test.t"));
         wuow.commit();
     }
     auto status =
-        syncRollback(_txn.get(),
+        syncRollback(_opCtx.get(),
                      OplogInterfaceMock({unknownCommandOperation, commonOperation}),
                      RollbackSourceMock(std::unique_ptr<OplogInterface>(new OplogInterfaceMock({
                          commonOperation,
@@ -710,7 +711,7 @@ TEST_F(RSRollbackTest, RollbackUnknownCommand) {
 }
 
 TEST_F(RSRollbackTest, RollbackDropCollectionCommand) {
-    createOplog(_txn.get());
+    createOplog(_opCtx.get());
     auto commonOperation =
         std::make_pair(BSON("ts" << Timestamp(Seconds(1), 0) << "h" << 1LL), RecordId(1));
     auto dropCollectionOperation =
@@ -726,7 +727,7 @@ TEST_F(RSRollbackTest, RollbackDropCollectionCommand) {
     public:
         RollbackSourceLocal(std::unique_ptr<OplogInterface> oplog)
             : RollbackSourceMock(std::move(oplog)), called(false) {}
-        void copyCollectionFromRemote(OperationContext* txn,
+        void copyCollectionFromRemote(OperationContext* opCtx,
                                       const NamespaceString& nss) const override {
             called = true;
         }
@@ -735,8 +736,8 @@ TEST_F(RSRollbackTest, RollbackDropCollectionCommand) {
     RollbackSourceLocal rollbackSource(std::unique_ptr<OplogInterface>(new OplogInterfaceMock({
         commonOperation,
     })));
-    _createCollection(_txn.get(), "test.t", CollectionOptions());
-    ASSERT_OK(syncRollback(_txn.get(),
+    _createCollection(_opCtx.get(), "test.t", CollectionOptions());
+    ASSERT_OK(syncRollback(_opCtx.get(),
                            OplogInterfaceMock({dropCollectionOperation, commonOperation}),
                            rollbackSource,
                            {},
@@ -745,7 +746,7 @@ TEST_F(RSRollbackTest, RollbackDropCollectionCommand) {
 }
 
 TEST_F(RSRollbackTest, RollbackDropCollectionCommandFailsIfRBIDChangesWhileSyncingCollection) {
-    createOplog(_txn.get());
+    createOplog(_opCtx.get());
     auto commonOperation =
         std::make_pair(BSON("ts" << Timestamp(Seconds(1), 0) << "h" << 1LL), RecordId(1));
     auto dropCollectionOperation =
@@ -763,7 +764,7 @@ TEST_F(RSRollbackTest, RollbackDropCollectionCommandFailsIfRBIDChangesWhileSynci
         int getRollbackId() const override {
             return copyCollectionCalled ? 1 : 0;
         }
-        void copyCollectionFromRemote(OperationContext* txn,
+        void copyCollectionFromRemote(OperationContext* opCtx,
                                       const NamespaceString& nss) const override {
             copyCollectionCalled = true;
         }
@@ -773,8 +774,8 @@ TEST_F(RSRollbackTest, RollbackDropCollectionCommandFailsIfRBIDChangesWhileSynci
         commonOperation,
     })));
 
-    _createCollection(_txn.get(), "test.t", CollectionOptions());
-    ASSERT_THROWS_CODE(syncRollback(_txn.get(),
+    _createCollection(_opCtx.get(), "test.t", CollectionOptions());
+    ASSERT_THROWS_CODE(syncRollback(_opCtx.get(),
                                     OplogInterfaceMock({dropCollectionOperation, commonOperation}),
                                     rollbackSource,
                                     {0},
@@ -815,22 +816,22 @@ OpTime getOpTimeFromOplogEntry(const BSONObj& entry) {
 }
 
 TEST_F(RSRollbackTest, RollbackApplyOpsCommand) {
-    createOplog(_txn.get());
+    createOplog(_opCtx.get());
 
     {
-        AutoGetOrCreateDb autoDb(_txn.get(), "test", MODE_X);
-        mongo::WriteUnitOfWork wuow(_txn.get());
+        AutoGetOrCreateDb autoDb(_opCtx.get(), "test", MODE_X);
+        mongo::WriteUnitOfWork wuow(_opCtx.get());
         auto coll = autoDb.getDb()->getCollection("test.t");
         if (!coll) {
-            coll = autoDb.getDb()->createCollection(_txn.get(), "test.t");
+            coll = autoDb.getDb()->createCollection(_opCtx.get(), "test.t");
         }
         ASSERT(coll);
         OpDebug* const nullOpDebug = nullptr;
         ASSERT_OK(
-            coll->insertDocument(_txn.get(), BSON("_id" << 1 << "v" << 2), nullOpDebug, false));
+            coll->insertDocument(_opCtx.get(), BSON("_id" << 1 << "v" << 2), nullOpDebug, false));
         ASSERT_OK(
-            coll->insertDocument(_txn.get(), BSON("_id" << 2 << "v" << 4), nullOpDebug, false));
-        ASSERT_OK(coll->insertDocument(_txn.get(), BSON("_id" << 4), nullOpDebug, false));
+            coll->insertDocument(_opCtx.get(), BSON("_id" << 2 << "v" << 4), nullOpDebug, false));
+        ASSERT_OK(coll->insertDocument(_opCtx.get(), BSON("_id" << 4), nullOpDebug, false));
         wuow.commit();
     }
     const auto commonOperation =
@@ -897,8 +898,8 @@ TEST_F(RSRollbackTest, RollbackApplyOpsCommand) {
         mutable std::multiset<int> searchedIds;
     } rollbackSource(std::unique_ptr<OplogInterface>(new OplogInterfaceMock({commonOperation})));
 
-    _createCollection(_txn.get(), "test.t", CollectionOptions());
-    ASSERT_OK(syncRollback(_txn.get(),
+    _createCollection(_opCtx.get(), "test.t", CollectionOptions());
+    ASSERT_OK(syncRollback(_opCtx.get(),
                            OplogInterfaceMock({applyOpsOperation, commonOperation}),
                            rollbackSource,
                            {},
@@ -909,20 +910,20 @@ TEST_F(RSRollbackTest, RollbackApplyOpsCommand) {
     ASSERT_EQUALS(1U, rollbackSource.searchedIds.count(3));
     ASSERT_EQUALS(1U, rollbackSource.searchedIds.count(4));
 
-    AutoGetCollectionForRead acr(_txn.get(), NamespaceString("test.t"));
+    AutoGetCollectionForRead acr(_opCtx.get(), NamespaceString("test.t"));
     BSONObj result;
-    ASSERT(Helpers::findOne(_txn.get(), acr.getCollection(), BSON("_id" << 1), result));
+    ASSERT(Helpers::findOne(_opCtx.get(), acr.getCollection(), BSON("_id" << 1), result));
     ASSERT_EQUALS(1, result["v"].numberInt()) << result;
-    ASSERT(Helpers::findOne(_txn.get(), acr.getCollection(), BSON("_id" << 2), result));
+    ASSERT(Helpers::findOne(_opCtx.get(), acr.getCollection(), BSON("_id" << 2), result));
     ASSERT_EQUALS(3, result["v"].numberInt()) << result;
-    ASSERT(Helpers::findOne(_txn.get(), acr.getCollection(), BSON("_id" << 3), result));
+    ASSERT(Helpers::findOne(_opCtx.get(), acr.getCollection(), BSON("_id" << 3), result));
     ASSERT_EQUALS(5, result["v"].numberInt()) << result;
-    ASSERT_FALSE(Helpers::findOne(_txn.get(), acr.getCollection(), BSON("_id" << 4), result))
+    ASSERT_FALSE(Helpers::findOne(_opCtx.get(), acr.getCollection(), BSON("_id" << 4), result))
         << result;
 }
 
 TEST_F(RSRollbackTest, RollbackCreateCollectionCommand) {
-    createOplog(_txn.get());
+    createOplog(_opCtx.get());
     auto commonOperation =
         std::make_pair(BSON("ts" << Timestamp(Seconds(1), 0) << "h" << 1LL), RecordId(1));
     auto createCollectionOperation =
@@ -937,22 +938,22 @@ TEST_F(RSRollbackTest, RollbackCreateCollectionCommand) {
     RollbackSourceMock rollbackSource(std::unique_ptr<OplogInterface>(new OplogInterfaceMock({
         commonOperation,
     })));
-    _createCollection(_txn.get(), "test.t", CollectionOptions());
-    ASSERT_OK(syncRollback(_txn.get(),
+    _createCollection(_opCtx.get(), "test.t", CollectionOptions());
+    ASSERT_OK(syncRollback(_opCtx.get(),
                            OplogInterfaceMock({createCollectionOperation, commonOperation}),
                            rollbackSource,
                            {},
                            _coordinator));
     {
-        Lock::DBLock dbLock(_txn->lockState(), "test", MODE_S);
-        auto db = dbHolder().get(_txn.get(), "test");
+        Lock::DBLock dbLock(_opCtx->lockState(), "test", MODE_S);
+        auto db = dbHolder().get(_opCtx.get(), "test");
         ASSERT_TRUE(db);
         ASSERT_FALSE(db->getCollection("test.t"));
     }
 }
 
 TEST_F(RSRollbackTest, RollbackCollectionModificationCommand) {
-    createOplog(_txn.get());
+    createOplog(_opCtx.get());
     auto commonOperation =
         std::make_pair(BSON("ts" << Timestamp(Seconds(1), 0) << "h" << 1LL), RecordId(1));
     auto collectionModificationOperation =
@@ -979,9 +980,9 @@ TEST_F(RSRollbackTest, RollbackCollectionModificationCommand) {
     RollbackSourceLocal rollbackSource(std::unique_ptr<OplogInterface>(new OplogInterfaceMock({
         commonOperation,
     })));
-    _createCollection(_txn.get(), "test.t", CollectionOptions());
+    _createCollection(_opCtx.get(), "test.t", CollectionOptions());
     startCapturingLogMessages();
-    ASSERT_OK(syncRollback(_txn.get(),
+    ASSERT_OK(syncRollback(_opCtx.get(),
                            OplogInterfaceMock({collectionModificationOperation, commonOperation}),
                            rollbackSource,
                            {},
@@ -995,7 +996,7 @@ TEST_F(RSRollbackTest, RollbackCollectionModificationCommand) {
 }
 
 TEST_F(RSRollbackTest, RollbackCollectionModificationCommandInvalidCollectionOptions) {
-    createOplog(_txn.get());
+    createOplog(_opCtx.get());
     auto commonOperation =
         std::make_pair(BSON("ts" << Timestamp(Seconds(1), 0) << "h" << 1LL), RecordId(1));
     auto collectionModificationOperation =
@@ -1020,9 +1021,9 @@ TEST_F(RSRollbackTest, RollbackCollectionModificationCommandInvalidCollectionOpt
     RollbackSourceLocal rollbackSource(std::unique_ptr<OplogInterface>(new OplogInterfaceMock({
         commonOperation,
     })));
-    _createCollection(_txn.get(), "test.t", CollectionOptions());
+    _createCollection(_opCtx.get(), "test.t", CollectionOptions());
     auto status =
-        syncRollback(_txn.get(),
+        syncRollback(_opCtx.get(),
                      OplogInterfaceMock({collectionModificationOperation, commonOperation}),
                      rollbackSource,
                      {},
diff --git a/src/mongo/db/repl/storage_interface.cpp b/src/mongo/db/repl/storage_interface.cpp
index b9a1c25df45..5f9deb71a85 100644
--- a/src/mongo/db/repl/storage_interface.cpp
+++ b/src/mongo/db/repl/storage_interface.cpp
@@ -51,8 +51,8 @@ StorageInterface* StorageInterface::get(ServiceContext& service) {
     return getStorageInterface(service).get();
 }
 
-StorageInterface* StorageInterface::get(OperationContext* txn) {
-    return get(txn->getClient()->getServiceContext());
+StorageInterface* StorageInterface::get(OperationContext* opCtx) {
+    return get(opCtx->getClient()->getServiceContext());
 }
 
 
diff --git a/src/mongo/db/repl/storage_interface.h b/src/mongo/db/repl/storage_interface.h
index ae4f6f7eabf..2e87f23537d 100644
--- a/src/mongo/db/repl/storage_interface.h
+++ b/src/mongo/db/repl/storage_interface.h
@@ -91,7 +91,7 @@ public:
     // Operation Context binding.
     static StorageInterface* get(ServiceContext* service);
     static StorageInterface* get(ServiceContext& service);
-    static StorageInterface* get(OperationContext* txn);
+    static StorageInterface* get(OperationContext* opCtx);
     static void set(ServiceContext* service, std::unique_ptr<StorageInterface> storageInterface);
 
     // Constructor and Destructor.
@@ -105,7 +105,7 @@ public:
     /**
      * Returns true if initial sync was started but has not not completed.
      */
-    virtual bool getInitialSyncFlag(OperationContext* txn) const = 0;
+    virtual bool getInitialSyncFlag(OperationContext* opCtx) const = 0;
 
     /**
      * Sets the the initial sync flag to record that initial sync has not completed.
@@ -113,7 +113,7 @@ public:
      * This operation is durable and waits for durable writes (which will block on
      *journaling/checkpointing).
      */
-    virtual void setInitialSyncFlag(OperationContext* txn) = 0;
+    virtual void setInitialSyncFlag(OperationContext* opCtx) = 0;
 
     /**
      * Clears the the initial sync flag to record that initial sync has completed.
@@ -121,34 +121,34 @@ public:
      * This operation is durable and waits for durable writes (which will block on
      *journaling/checkpointing).
      */
-    virtual void clearInitialSyncFlag(OperationContext* txn) = 0;
+    virtual void clearInitialSyncFlag(OperationContext* opCtx) = 0;
 
     /**
      * The minValid value is the earliest (minimum) Timestamp that must be applied in order to
      * consider the dataset consistent.
      */
-    virtual void setMinValid(OperationContext* txn, const OpTime& minValid) = 0;
-    virtual OpTime getMinValid(OperationContext* txn) const = 0;
+    virtual void setMinValid(OperationContext* opCtx, const OpTime& minValid) = 0;
+    virtual OpTime getMinValid(OperationContext* opCtx) const = 0;
 
     /**
      * Sets minValid only if it is not already higher than endOpTime.
      * Warning, this compares the term and timestamp independently. Do not use if the current
      * minValid could be from the other fork of a rollback.
      */
-    virtual void setMinValidToAtLeast(OperationContext* txn, const OpTime& endOpTime) = 0;
+    virtual void setMinValidToAtLeast(OperationContext* opCtx, const OpTime& endOpTime) = 0;
 
     /**
      * On startup all oplog entries with a value >= the oplog delete from point should be deleted.
      * If null, no documents should be deleted.
      */
-    virtual void setOplogDeleteFromPoint(OperationContext* txn, const Timestamp& timestamp) = 0;
-    virtual Timestamp getOplogDeleteFromPoint(OperationContext* txn) = 0;
+    virtual void setOplogDeleteFromPoint(OperationContext* opCtx, const Timestamp& timestamp) = 0;
+    virtual Timestamp getOplogDeleteFromPoint(OperationContext* opCtx) = 0;
 
     /**
      * The applied through point is a persistent record of where we've applied through. If null, the
      * applied through point is the top of the oplog.
      */
-    virtual void setAppliedThrough(OperationContext* txn, const OpTime& optime) = 0;
+    virtual void setAppliedThrough(OperationContext* opCtx, const OpTime& optime) = 0;
 
     /**
      * You should probably be calling ReplicationCoordinator::getLastAppliedOpTime() instead.
@@ -156,7 +156,7 @@ public:
      * This reads the value from storage which isn't always updated when the ReplicationCoordinator
      * is.
      */
-    virtual OpTime getAppliedThrough(OperationContext* txn) = 0;
+    virtual OpTime getAppliedThrough(OperationContext* opCtx) = 0;
 
 
     // Collection creation and population for initial sync.
@@ -177,7 +177,7 @@ public:
      * NOTE: If the collection doesn't exist, it will not be created, and instead
      * an error is returned.
      */
-    virtual Status insertDocument(OperationContext* txn,
+    virtual Status insertDocument(OperationContext* opCtx,
                                   const NamespaceString& nss,
                                   const BSONObj& doc) = 0;
 
@@ -185,14 +185,14 @@ public:
      * Inserts the given documents into the collection.
      * It is an error to call this function with an empty set of documents.
      */
-    virtual Status insertDocuments(OperationContext* txn,
+    virtual Status insertDocuments(OperationContext* opCtx,
                                    const NamespaceString& nss,
                                    const std::vector<BSONObj>& docs) = 0;
 
     /**
      * Creates the initial oplog, errors if it exists.
      */
-    virtual Status createOplog(OperationContext* txn, const NamespaceString& nss) = 0;
+    virtual Status createOplog(OperationContext* opCtx, const NamespaceString& nss) = 0;
 
     /**
      * Returns the configured maximum size of the oplog.
@@ -200,30 +200,30 @@ public:
      * Implementations are allowed to be "fuzzy" and delete documents when the actual size is
      * slightly above or below this, so callers should not rely on its exact value.
      */
-    virtual StatusWith<size_t> getOplogMaxSize(OperationContext* txn,
+    virtual StatusWith<size_t> getOplogMaxSize(OperationContext* opCtx,
                                                const NamespaceString& nss) = 0;
 
     /**
      * Creates a collection.
      */
-    virtual Status createCollection(OperationContext* txn,
+    virtual Status createCollection(OperationContext* opCtx,
                                     const NamespaceString& nss,
                                     const CollectionOptions& options) = 0;
 
     /**
      * Drops a collection, like the oplog.
      */
-    virtual Status dropCollection(OperationContext* txn, const NamespaceString& nss) = 0;
+    virtual Status dropCollection(OperationContext* opCtx, const NamespaceString& nss) = 0;
 
     /**
      * Drops all databases except "local".
      */
-    virtual Status dropReplicatedDatabases(OperationContext* txn) = 0;
+    virtual Status dropReplicatedDatabases(OperationContext* opCtx) = 0;
 
     /**
      * Validates that the admin database is valid during initial sync.
      */
-    virtual Status isAdminDbValid(OperationContext* txn) = 0;
+    virtual Status isAdminDbValid(OperationContext* opCtx) = 0;
 
     /**
      * Finds at most "limit" documents returned by a collection or index scan on the collection in
@@ -242,7 +242,7 @@ public:
         kForward = 1,
         kBackward = -1,
     };
-    virtual StatusWith<std::vector<BSONObj>> findDocuments(OperationContext* txn,
+    virtual StatusWith<std::vector<BSONObj>> findDocuments(OperationContext* opCtx,
                                                            const NamespaceString& nss,
                                                            boost::optional<StringData> indexName,
                                                            ScanDirection scanDirection,
@@ -257,7 +257,7 @@ public:
      * will be kept open once this function returns.
      * If "indexName" is null, a collection scan is used to locate the document.
      */
-    virtual StatusWith<std::vector<BSONObj>> deleteDocuments(OperationContext* txn,
+    virtual StatusWith<std::vector<BSONObj>> deleteDocuments(OperationContext* opCtx,
                                                              const NamespaceString& nss,
                                                              boost::optional<StringData> indexName,
                                                              ScanDirection scanDirection,
diff --git a/src/mongo/db/repl/storage_interface_impl.cpp b/src/mongo/db/repl/storage_interface_impl.cpp
index ce03ab1629c..ff5aa7d4260 100644
--- a/src/mongo/db/repl/storage_interface_impl.cpp
+++ b/src/mongo/db/repl/storage_interface_impl.cpp
@@ -102,67 +102,67 @@ NamespaceString StorageInterfaceImpl::getMinValidNss() const {
     return _minValidNss;
 }
 
-BSONObj StorageInterfaceImpl::getMinValidDocument(OperationContext* txn) const {
+BSONObj StorageInterfaceImpl::getMinValidDocument(OperationContext* opCtx) const {
     MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
-        ScopedTransaction transaction(txn, MODE_IS);
-        Lock::DBLock dblk(txn->lockState(), _minValidNss.db(), MODE_IS);
-        Lock::CollectionLock lk(txn->lockState(), _minValidNss.ns(), MODE_IS);
+        ScopedTransaction transaction(opCtx, MODE_IS);
+        Lock::DBLock dblk(opCtx->lockState(), _minValidNss.db(), MODE_IS);
+        Lock::CollectionLock lk(opCtx->lockState(), _minValidNss.ns(), MODE_IS);
         BSONObj doc;
-        bool found = Helpers::getSingleton(txn, _minValidNss.ns().c_str(), doc);
+        bool found = Helpers::getSingleton(opCtx, _minValidNss.ns().c_str(), doc);
         invariant(found || doc.isEmpty());
         return doc;
     }
     MONGO_WRITE_CONFLICT_RETRY_LOOP_END(
-        txn, "StorageInterfaceImpl::getMinValidDocument", _minValidNss.ns());
+        opCtx, "StorageInterfaceImpl::getMinValidDocument", _minValidNss.ns());
 
     MONGO_UNREACHABLE;
 }
 
-void StorageInterfaceImpl::updateMinValidDocument(OperationContext* txn,
+void StorageInterfaceImpl::updateMinValidDocument(OperationContext* opCtx,
                                                   const BSONObj& updateSpec) {
     MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
-        ScopedTransaction transaction(txn, MODE_IX);
+        ScopedTransaction transaction(opCtx, MODE_IX);
         // For now this needs to be MODE_X because it sometimes creates the collection.
-        Lock::DBLock dblk(txn->lockState(), _minValidNss.db(), MODE_X);
-        Helpers::putSingleton(txn, _minValidNss.ns().c_str(), updateSpec);
+        Lock::DBLock dblk(opCtx->lockState(), _minValidNss.db(), MODE_X);
+        Helpers::putSingleton(opCtx, _minValidNss.ns().c_str(), updateSpec);
     }
     MONGO_WRITE_CONFLICT_RETRY_LOOP_END(
-        txn, "StorageInterfaceImpl::updateMinValidDocument", _minValidNss.ns());
+        opCtx, "StorageInterfaceImpl::updateMinValidDocument", _minValidNss.ns());
 }
 
-bool StorageInterfaceImpl::getInitialSyncFlag(OperationContext* txn) const {
-    const BSONObj doc = getMinValidDocument(txn);
+bool StorageInterfaceImpl::getInitialSyncFlag(OperationContext* opCtx) const {
+    const BSONObj doc = getMinValidDocument(opCtx);
     const auto flag = doc[kInitialSyncFlagFieldName].trueValue();
     LOG(3) << "returning initial sync flag value of " << flag;
     return flag;
 }
 
-void StorageInterfaceImpl::setInitialSyncFlag(OperationContext* txn) {
+void StorageInterfaceImpl::setInitialSyncFlag(OperationContext* opCtx) {
     LOG(3) << "setting initial sync flag";
-    updateMinValidDocument(txn, BSON("$set" << kInitialSyncFlag));
-    txn->recoveryUnit()->waitUntilDurable();
+    updateMinValidDocument(opCtx, BSON("$set" << kInitialSyncFlag));
+    opCtx->recoveryUnit()->waitUntilDurable();
 }
 
-void StorageInterfaceImpl::clearInitialSyncFlag(OperationContext* txn) {
+void StorageInterfaceImpl::clearInitialSyncFlag(OperationContext* opCtx) {
     LOG(3) << "clearing initial sync flag";
 
-    auto replCoord = repl::ReplicationCoordinator::get(txn);
+    auto replCoord = repl::ReplicationCoordinator::get(opCtx);
     OpTime time = replCoord->getMyLastAppliedOpTime();
     updateMinValidDocument(
-        txn,
+        opCtx,
         BSON("$unset" << kInitialSyncFlag << "$set"
                       << BSON("ts" << time.getTimestamp() << "t" << time.getTerm()
                                    << kBeginFieldName
                                    << time.toBSON())));
 
     if (getGlobalServiceContext()->getGlobalStorageEngine()->isDurable()) {
-        txn->recoveryUnit()->waitUntilDurable();
+        opCtx->recoveryUnit()->waitUntilDurable();
         replCoord->setMyLastDurableOpTime(time);
     }
 }
 
-OpTime StorageInterfaceImpl::getMinValid(OperationContext* txn) const {
-    const BSONObj doc = getMinValidDocument(txn);
+OpTime StorageInterfaceImpl::getMinValid(OperationContext* opCtx) const {
+    const BSONObj doc = getMinValidDocument(opCtx);
     const auto opTimeStatus = OpTime::parseFromOplogEntry(doc);
     // If any of the keys (fields) are missing from the minvalid document, we return
     // a null OpTime.
@@ -182,28 +182,29 @@ OpTime StorageInterfaceImpl::getMinValid(OperationContext* txn) const {
     return minValid;
 }
 
-void StorageInterfaceImpl::setMinValid(OperationContext* txn, const OpTime& minValid) {
+void StorageInterfaceImpl::setMinValid(OperationContext* opCtx, const OpTime& minValid) {
     LOG(3) << "setting minvalid to exactly: " << minValid.toString() << "(" << minValid.toBSON()
            << ")";
     updateMinValidDocument(
-        txn, BSON("$set" << BSON("ts" << minValid.getTimestamp() << "t" << minValid.getTerm())));
+        opCtx, BSON("$set" << BSON("ts" << minValid.getTimestamp() << "t" << minValid.getTerm())));
 }
 
-void StorageInterfaceImpl::setMinValidToAtLeast(OperationContext* txn, const OpTime& minValid) {
+void StorageInterfaceImpl::setMinValidToAtLeast(OperationContext* opCtx, const OpTime& minValid) {
     LOG(3) << "setting minvalid to at least: " << minValid.toString() << "(" << minValid.toBSON()
            << ")";
     updateMinValidDocument(
-        txn, BSON("$max" << BSON("ts" << minValid.getTimestamp() << "t" << minValid.getTerm())));
+        opCtx, BSON("$max" << BSON("ts" << minValid.getTimestamp() << "t" << minValid.getTerm())));
 }
 
-void StorageInterfaceImpl::setOplogDeleteFromPoint(OperationContext* txn,
+void StorageInterfaceImpl::setOplogDeleteFromPoint(OperationContext* opCtx,
                                                    const Timestamp& timestamp) {
     LOG(3) << "setting oplog delete from point to: " << timestamp.toStringPretty();
-    updateMinValidDocument(txn, BSON("$set" << BSON(kOplogDeleteFromPointFieldName << timestamp)));
+    updateMinValidDocument(opCtx,
+                           BSON("$set" << BSON(kOplogDeleteFromPointFieldName << timestamp)));
 }
 
-Timestamp StorageInterfaceImpl::getOplogDeleteFromPoint(OperationContext* txn) {
-    const BSONObj doc = getMinValidDocument(txn);
+Timestamp StorageInterfaceImpl::getOplogDeleteFromPoint(OperationContext* opCtx) {
+    const BSONObj doc = getMinValidDocument(opCtx);
     Timestamp out = {};
     if (auto field = doc[kOplogDeleteFromPointFieldName]) {
         out = field.timestamp();
@@ -213,17 +214,17 @@ Timestamp StorageInterfaceImpl::getOplogDeleteFromPoint(OperationContext* txn) {
     return out;
 }
 
-void StorageInterfaceImpl::setAppliedThrough(OperationContext* txn, const OpTime& optime) {
+void StorageInterfaceImpl::setAppliedThrough(OperationContext* opCtx, const OpTime& optime) {
     LOG(3) << "setting appliedThrough to: " << optime.toString() << "(" << optime.toBSON() << ")";
     if (optime.isNull()) {
-        updateMinValidDocument(txn, BSON("$unset" << BSON(kBeginFieldName << 1)));
+        updateMinValidDocument(opCtx, BSON("$unset" << BSON(kBeginFieldName << 1)));
     } else {
-        updateMinValidDocument(txn, BSON("$set" << BSON(kBeginFieldName << optime.toBSON())));
+        updateMinValidDocument(opCtx, BSON("$set" << BSON(kBeginFieldName << optime.toBSON())));
     }
 }
 
-OpTime StorageInterfaceImpl::getAppliedThrough(OperationContext* txn) {
-    const BSONObj doc = getMinValidDocument(txn);
+OpTime StorageInterfaceImpl::getAppliedThrough(OperationContext* opCtx) {
+    const BSONObj doc = getMinValidDocument(opCtx);
     const auto opTimeStatus = OpTime::parseFromOplogEntry(doc.getObjectField(kBeginFieldName));
     if (!opTimeStatus.isOK()) {
         // Return null OpTime on any parse failure, including if "begin" is missing.
@@ -253,18 +254,18 @@ StorageInterfaceImpl::createCollectionForBulkLoading(
     std::unique_ptr<CollectionBulkLoader> loaderToReturn;
     Collection* collection;
 
-    auto status = runner->runSynchronousTask([&](OperationContext* txn) -> Status {
+    auto status = runner->runSynchronousTask([&](OperationContext* opCtx) -> Status {
         // We are not replicating nor validating writes under this OperationContext*.
         // The OperationContext* is used for all writes to the (newly) cloned collection.
-        txn->setReplicatedWrites(false);
-        documentValidationDisabled(txn) = true;
+        opCtx->setReplicatedWrites(false);
+        documentValidationDisabled(opCtx) = true;
 
         // Retry if WCE.
         MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
             // Get locks and create the collection.
-            ScopedTransaction transaction(txn, MODE_IX);
-            auto db = stdx::make_unique<AutoGetOrCreateDb>(txn, nss.db(), MODE_IX);
-            auto coll = stdx::make_unique<AutoGetCollection>(txn, nss, MODE_X);
+            ScopedTransaction transaction(opCtx, MODE_IX);
+            auto db = stdx::make_unique<AutoGetOrCreateDb>(opCtx, nss.db(), MODE_IX);
+            auto coll = stdx::make_unique<AutoGetCollection>(opCtx, nss, MODE_X);
             collection = coll->getCollection();
 
             if (collection) {
@@ -272,14 +273,14 @@ StorageInterfaceImpl::createCollectionForBulkLoading(
             }
 
             // Create the collection.
-            WriteUnitOfWork wunit(txn);
-            collection = db->getDb()->createCollection(txn, nss.ns(), options, false);
+            WriteUnitOfWork wunit(opCtx);
+            collection = db->getDb()->createCollection(opCtx, nss.ns(), options, false);
             invariant(collection);
             wunit.commit();
-            coll = stdx::make_unique<AutoGetCollection>(txn, nss, MODE_IX);
+            coll = stdx::make_unique<AutoGetCollection>(opCtx, nss, MODE_IX);
 
             // Move locks into loader, so it now controls their lifetime.
-            auto loader = stdx::make_unique<CollectionBulkLoaderImpl>(txn,
+            auto loader = stdx::make_unique<CollectionBulkLoaderImpl>(opCtx,
                                                                       collection,
                                                                       idIndexSpec,
                                                                       std::move(threadPool),
@@ -291,7 +292,7 @@ StorageInterfaceImpl::createCollectionForBulkLoading(
             loaderToReturn = std::move(loader);
             return Status::OK();
         }
-        MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "beginCollectionClone", nss.ns());
+        MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "beginCollectionClone", nss.ns());
         MONGO_UNREACHABLE;
     });
 
@@ -308,20 +309,20 @@ StorageInterfaceImpl::createCollectionForBulkLoading(
 }
 
 
-Status StorageInterfaceImpl::insertDocument(OperationContext* txn,
+Status StorageInterfaceImpl::insertDocument(OperationContext* opCtx,
                                             const NamespaceString& nss,
                                             const BSONObj& doc) {
-    return insertDocuments(txn, nss, {doc});
+    return insertDocuments(opCtx, nss, {doc});
 }
 
 namespace {
 
-Status insertDocumentsSingleBatch(OperationContext* txn,
+Status insertDocumentsSingleBatch(OperationContext* opCtx,
                                   const NamespaceString& nss,
                                   std::vector<BSONObj>::const_iterator begin,
                                   std::vector<BSONObj>::const_iterator end) {
-    ScopedTransaction transaction(txn, MODE_IX);
-    AutoGetCollection autoColl(txn, nss, MODE_IX);
+    ScopedTransaction transaction(opCtx, MODE_IX);
+    AutoGetCollection autoColl(opCtx, nss, MODE_IX);
     auto collection = autoColl.getCollection();
     if (!collection) {
         return {ErrorCodes::NamespaceNotFound,
@@ -329,9 +330,9 @@ Status insertDocumentsSingleBatch(OperationContext* txn,
                               << nss.ns()};
     }
 
-    WriteUnitOfWork wunit(txn);
+    WriteUnitOfWork wunit(opCtx);
     OpDebug* const nullOpDebug = nullptr;
-    auto status = collection->insertDocuments(txn, begin, end, nullOpDebug, false);
+    auto status = collection->insertDocuments(opCtx, begin, end, nullOpDebug, false);
     if (!status.isOK()) {
         return status;
     }
@@ -342,12 +343,12 @@ Status insertDocumentsSingleBatch(OperationContext* txn,
 
 }  // namespace
 
-Status StorageInterfaceImpl::insertDocuments(OperationContext* txn,
+Status StorageInterfaceImpl::insertDocuments(OperationContext* opCtx,
                                              const NamespaceString& nss,
                                              const std::vector<BSONObj>& docs) {
     if (docs.size() > 1U) {
         try {
-            if (insertDocumentsSingleBatch(txn, nss, docs.cbegin(), docs.cend()).isOK()) {
+            if (insertDocumentsSingleBatch(opCtx, nss, docs.cbegin(), docs.cend()).isOK()) {
                 return Status::OK();
             }
         } catch (...) {
@@ -359,83 +360,84 @@ Status StorageInterfaceImpl::insertDocuments(OperationContext* txn,
     // Try to insert the batch one-at-a-time because the batch failed all-at-once inserting.
     for (auto it = docs.cbegin(); it != docs.cend(); ++it) {
         MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
-            auto status = insertDocumentsSingleBatch(txn, nss, it, it + 1);
+            auto status = insertDocumentsSingleBatch(opCtx, nss, it, it + 1);
             if (!status.isOK()) {
                 return status;
             }
         }
-        MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "StorageInterfaceImpl::insertDocuments", nss.ns());
+        MONGO_WRITE_CONFLICT_RETRY_LOOP_END(
+            opCtx, "StorageInterfaceImpl::insertDocuments", nss.ns());
     }
 
     return Status::OK();
 }
 
-Status StorageInterfaceImpl::dropReplicatedDatabases(OperationContext* txn) {
-    dropAllDatabasesExceptLocal(txn);
+Status StorageInterfaceImpl::dropReplicatedDatabases(OperationContext* opCtx) {
+    dropAllDatabasesExceptLocal(opCtx);
     return Status::OK();
 }
 
-Status StorageInterfaceImpl::createOplog(OperationContext* txn, const NamespaceString& nss) {
-    mongo::repl::createOplog(txn, nss.ns(), true);
+Status StorageInterfaceImpl::createOplog(OperationContext* opCtx, const NamespaceString& nss) {
+    mongo::repl::createOplog(opCtx, nss.ns(), true);
     return Status::OK();
 }
 
-StatusWith<size_t> StorageInterfaceImpl::getOplogMaxSize(OperationContext* txn,
+StatusWith<size_t> StorageInterfaceImpl::getOplogMaxSize(OperationContext* opCtx,
                                                          const NamespaceString& nss) {
-    AutoGetCollectionForRead collection(txn, nss);
+    AutoGetCollectionForRead collection(opCtx, nss);
     if (!collection.getCollection()) {
         return {ErrorCodes::NamespaceNotFound,
                 str::stream() << "Your oplog doesn't exist: " << nss.ns()};
     }
 
-    const auto options = collection.getCollection()->getCatalogEntry()->getCollectionOptions(txn);
+    const auto options = collection.getCollection()->getCatalogEntry()->getCollectionOptions(opCtx);
     if (!options.capped)
         return {ErrorCodes::BadValue, str::stream() << nss.ns() << " isn't capped"};
 
     return options.cappedSize;
 }
 
-Status StorageInterfaceImpl::createCollection(OperationContext* txn,
+Status StorageInterfaceImpl::createCollection(OperationContext* opCtx,
                                               const NamespaceString& nss,
                                               const CollectionOptions& options) {
     MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
-        ScopedTransaction transaction(txn, MODE_IX);
-        AutoGetOrCreateDb databaseWriteGuard(txn, nss.db(), MODE_X);
+        ScopedTransaction transaction(opCtx, MODE_IX);
+        AutoGetOrCreateDb databaseWriteGuard(opCtx, nss.db(), MODE_X);
         auto db = databaseWriteGuard.getDb();
         invariant(db);
         if (db->getCollection(nss)) {
             return {ErrorCodes::NamespaceExists,
                     str::stream() << "Collection " << nss.ns() << " already exists."};
         }
-        WriteUnitOfWork wuow(txn);
+        WriteUnitOfWork wuow(opCtx);
         try {
-            auto coll = db->createCollection(txn, nss.ns(), options);
+            auto coll = db->createCollection(opCtx, nss.ns(), options);
             invariant(coll);
         } catch (const UserException& ex) {
             return ex.toStatus();
         }
         wuow.commit();
     }
-    MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "StorageInterfaceImpl::createCollection", nss.ns());
+    MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "StorageInterfaceImpl::createCollection", nss.ns());
     return Status::OK();
 }
 
-Status StorageInterfaceImpl::dropCollection(OperationContext* txn, const NamespaceString& nss) {
+Status StorageInterfaceImpl::dropCollection(OperationContext* opCtx, const NamespaceString& nss) {
     MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
-        ScopedTransaction transaction(txn, MODE_IX);
-        AutoGetDb autoDB(txn, nss.db(), MODE_X);
+        ScopedTransaction transaction(opCtx, MODE_IX);
+        AutoGetDb autoDB(opCtx, nss.db(), MODE_X);
         if (!autoDB.getDb()) {
             // Database does not exist - nothing to do.
             return Status::OK();
         }
-        WriteUnitOfWork wunit(txn);
-        const auto status = autoDB.getDb()->dropCollection(txn, nss.ns());
+        WriteUnitOfWork wunit(opCtx);
+        const auto status = autoDB.getDb()->dropCollection(opCtx, nss.ns());
         if (status.isOK()) {
             wunit.commit();
         }
         return status;
     }
-    MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "StorageInterfaceImpl::dropCollection", nss.ns());
+    MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "StorageInterfaceImpl::dropCollection", nss.ns());
 }
 
 namespace {
@@ -455,7 +457,7 @@ DeleteStageParams makeDeleteStageParamsForDeleteDocuments() {
  */
 enum class FindDeleteMode { kFind, kDelete };
 StatusWith<std::vector<BSONObj>> _findOrDeleteDocuments(
-    OperationContext* txn,
+    OperationContext* opCtx,
     const NamespaceString& nss,
     boost::optional<StringData> indexName,
     StorageInterface::ScanDirection scanDirection,
@@ -468,8 +470,8 @@ StatusWith<std::vector<BSONObj>> _findOrDeleteDocuments(
 
     MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
         auto collectionAccessMode = isFind ? MODE_IS : MODE_IX;
-        ScopedTransaction transaction(txn, collectionAccessMode);
-        AutoGetCollection collectionGuard(txn, nss, collectionAccessMode);
+        ScopedTransaction transaction(opCtx, collectionAccessMode);
+        AutoGetCollection collectionGuard(opCtx, nss, collectionAccessMode);
         auto collection = collectionGuard.getCollection();
         if (!collection) {
             return {ErrorCodes::NamespaceNotFound,
@@ -493,9 +495,9 @@ StatusWith<std::vector<BSONObj>> _findOrDeleteDocuments(
             // Use collection scan.
             planExecutor = isFind
                 ? InternalPlanner::collectionScan(
-                      txn, nss.ns(), collection, PlanExecutor::YIELD_MANUAL, direction)
+                      opCtx, nss.ns(), collection, PlanExecutor::YIELD_MANUAL, direction)
                 : InternalPlanner::deleteWithCollectionScan(
-                      txn,
+                      opCtx,
                       collection,
                       makeDeleteStageParamsForDeleteDocuments(),
                       PlanExecutor::YIELD_MANUAL,
@@ -506,7 +508,7 @@ StatusWith<std::vector<BSONObj>> _findOrDeleteDocuments(
             invariant(indexCatalog);
             bool includeUnfinishedIndexes = false;
             IndexDescriptor* indexDescriptor =
-                indexCatalog->findIndexByName(txn, *indexName, includeUnfinishedIndexes);
+                indexCatalog->findIndexByName(opCtx, *indexName, includeUnfinishedIndexes);
             if (!indexDescriptor) {
                 return {ErrorCodes::IndexNotFound,
                         str::stream() << "Index not found, ns:" << nss.ns() << ", index: "
@@ -529,7 +531,7 @@ StatusWith<std::vector<BSONObj>> _findOrDeleteDocuments(
                 bounds.first = startKey;
             }
             planExecutor = isFind
-                ? InternalPlanner::indexScan(txn,
+                ? InternalPlanner::indexScan(opCtx,
                                              collection,
                                              indexDescriptor,
                                              bounds.first,
@@ -538,7 +540,7 @@ StatusWith<std::vector<BSONObj>> _findOrDeleteDocuments(
                                              PlanExecutor::YIELD_MANUAL,
                                              direction,
                                              InternalPlanner::IXSCAN_FETCH)
-                : InternalPlanner::deleteWithIndexScan(txn,
+                : InternalPlanner::deleteWithIndexScan(opCtx,
                                                        collection,
                                                        makeDeleteStageParamsForDeleteDocuments(),
                                                        indexDescriptor,
@@ -562,33 +564,39 @@ StatusWith<std::vector<BSONObj>> _findOrDeleteDocuments(
         }
         return docs;
     }
-    MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, opStr, nss.ns());
+    MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, opStr, nss.ns());
     MONGO_UNREACHABLE;
 }
 
 }  // namespace
 
 StatusWith<std::vector<BSONObj>> StorageInterfaceImpl::findDocuments(
-    OperationContext* txn,
+    OperationContext* opCtx,
     const NamespaceString& nss,
     boost::optional<StringData> indexName,
     ScanDirection scanDirection,
     const BSONObj& startKey,
     BoundInclusion boundInclusion,
     std::size_t limit) {
-    return _findOrDeleteDocuments(
-        txn, nss, indexName, scanDirection, startKey, boundInclusion, limit, FindDeleteMode::kFind);
+    return _findOrDeleteDocuments(opCtx,
+                                  nss,
+                                  indexName,
+                                  scanDirection,
+                                  startKey,
+                                  boundInclusion,
+                                  limit,
+                                  FindDeleteMode::kFind);
 }
 
 StatusWith<std::vector<BSONObj>> StorageInterfaceImpl::deleteDocuments(
-    OperationContext* txn,
+    OperationContext* opCtx,
     const NamespaceString& nss,
     boost::optional<StringData> indexName,
     ScanDirection scanDirection,
     const BSONObj& startKey,
     BoundInclusion boundInclusion,
     std::size_t limit) {
-    return _findOrDeleteDocuments(txn,
+    return _findOrDeleteDocuments(opCtx,
                                   nss,
                                   indexName,
                                   scanDirection,
@@ -598,10 +606,10 @@ StatusWith<std::vector<BSONObj>> StorageInterfaceImpl::deleteDocuments(
                                   FindDeleteMode::kDelete);
 }
 
-Status StorageInterfaceImpl::isAdminDbValid(OperationContext* txn) {
-    ScopedTransaction transaction(txn, MODE_IX);
-    AutoGetDb autoDB(txn, "admin", MODE_X);
-    return checkAdminDatabase(txn, autoDB.getDb());
+Status StorageInterfaceImpl::isAdminDbValid(OperationContext* opCtx) {
+    ScopedTransaction transaction(opCtx, MODE_IX);
+    AutoGetDb autoDB(opCtx, "admin", MODE_X);
+    return checkAdminDatabase(opCtx, autoDB.getDb());
 }
 
 }  // namespace repl
diff --git a/src/mongo/db/repl/storage_interface_impl.h b/src/mongo/db/repl/storage_interface_impl.h
index 9edd37b44c8..b3bc5eeb617 100644
--- a/src/mongo/db/repl/storage_interface_impl.h
+++ b/src/mongo/db/repl/storage_interface_impl.h
@@ -62,19 +62,19 @@ public:
      */
     NamespaceString getMinValidNss() const;
 
-    bool getInitialSyncFlag(OperationContext* txn) const override;
+    bool getInitialSyncFlag(OperationContext* opCtx) const override;
 
-    void setInitialSyncFlag(OperationContext* txn) override;
+    void setInitialSyncFlag(OperationContext* opCtx) override;
 
-    void clearInitialSyncFlag(OperationContext* txn) override;
+    void clearInitialSyncFlag(OperationContext* opCtx) override;
 
-    OpTime getMinValid(OperationContext* txn) const override;
-    void setMinValid(OperationContext* txn, const OpTime& minValid) override;
-    void setMinValidToAtLeast(OperationContext* txn, const OpTime& endOpTime) override;
-    void setOplogDeleteFromPoint(OperationContext* txn, const Timestamp& timestamp) override;
-    Timestamp getOplogDeleteFromPoint(OperationContext* txn) override;
-    void setAppliedThrough(OperationContext* txn, const OpTime& optime) override;
-    OpTime getAppliedThrough(OperationContext* txn) override;
+    OpTime getMinValid(OperationContext* opCtx) const override;
+    void setMinValid(OperationContext* opCtx, const OpTime& minValid) override;
+    void setMinValidToAtLeast(OperationContext* opCtx, const OpTime& endOpTime) override;
+    void setOplogDeleteFromPoint(OperationContext* opCtx, const Timestamp& timestamp) override;
+    Timestamp getOplogDeleteFromPoint(OperationContext* opCtx) override;
+    void setAppliedThrough(OperationContext* opCtx, const OpTime& optime) override;
+    OpTime getAppliedThrough(OperationContext* opCtx) override;
 
     /**
      *  Allocates a new TaskRunner for use by the passed in collection.
@@ -85,26 +85,27 @@ public:
         const BSONObj idIndexSpec,
         const std::vector<BSONObj>& secondaryIndexSpecs) override;
 
-    Status insertDocument(OperationContext* txn,
+    Status insertDocument(OperationContext* opCtx,
                           const NamespaceString& nss,
                           const BSONObj& doc) override;
 
-    Status insertDocuments(OperationContext* txn,
+    Status insertDocuments(OperationContext* opCtx,
                            const NamespaceString& nss,
                            const std::vector<BSONObj>& docs) override;
 
-    Status dropReplicatedDatabases(OperationContext* txn) override;
+    Status dropReplicatedDatabases(OperationContext* opCtx) override;
 
-    Status createOplog(OperationContext* txn, const NamespaceString& nss) override;
-    StatusWith<size_t> getOplogMaxSize(OperationContext* txn, const NamespaceString& nss) override;
+    Status createOplog(OperationContext* opCtx, const NamespaceString& nss) override;
+    StatusWith<size_t> getOplogMaxSize(OperationContext* opCtx,
+                                       const NamespaceString& nss) override;
 
-    Status createCollection(OperationContext* txn,
+    Status createCollection(OperationContext* opCtx,
                             const NamespaceString& nss,
                             const CollectionOptions& options) override;
 
-    Status dropCollection(OperationContext* txn, const NamespaceString& nss) override;
+    Status dropCollection(OperationContext* opCtx, const NamespaceString& nss) override;
 
-    StatusWith<std::vector<BSONObj>> findDocuments(OperationContext* txn,
+    StatusWith<std::vector<BSONObj>> findDocuments(OperationContext* opCtx,
                                                    const NamespaceString& nss,
                                                    boost::optional<StringData> indexName,
                                                    ScanDirection scanDirection,
@@ -112,7 +113,7 @@ public:
                                                    BoundInclusion boundInclusion,
                                                    std::size_t limit) override;
 
-    StatusWith<std::vector<BSONObj>> deleteDocuments(OperationContext* txn,
+    StatusWith<std::vector<BSONObj>> deleteDocuments(OperationContext* opCtx,
                                                      const NamespaceString& nss,
                                                      boost::optional<StringData> indexName,
                                                      ScanDirection scanDirection,
@@ -120,12 +121,12 @@ public:
                                                      BoundInclusion boundInclusion,
                                                      std::size_t limit) override;
 
-    Status isAdminDbValid(OperationContext* txn) override;
+    Status isAdminDbValid(OperationContext* opCtx) override;
 
 private:
     // Returns empty document if not present.
-    BSONObj getMinValidDocument(OperationContext* txn) const;
-    void updateMinValidDocument(OperationContext* txn, const BSONObj& updateSpec);
+    BSONObj getMinValidDocument(OperationContext* opCtx) const;
+    void updateMinValidDocument(OperationContext* opCtx, const BSONObj& updateSpec);
 
     const NamespaceString _minValidNss;
 };
diff --git a/src/mongo/db/repl/storage_interface_impl_test.cpp b/src/mongo/db/repl/storage_interface_impl_test.cpp
index c44e281f012..2ee2cbf2259 100644
--- a/src/mongo/db/repl/storage_interface_impl_test.cpp
+++ b/src/mongo/db/repl/storage_interface_impl_test.cpp
@@ -87,17 +87,17 @@ NamespaceString makeNamespace(const T& t, const char* suffix = "") {
 /**
  * Returns min valid document.
  */
-BSONObj getMinValidDocument(OperationContext* txn, const NamespaceString& minValidNss) {
+BSONObj getMinValidDocument(OperationContext* opCtx, const NamespaceString& minValidNss) {
     MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
-        ScopedTransaction transaction(txn, MODE_IS);
-        Lock::DBLock dblk(txn->lockState(), minValidNss.db(), MODE_IS);
-        Lock::CollectionLock lk(txn->lockState(), minValidNss.ns(), MODE_IS);
+        ScopedTransaction transaction(opCtx, MODE_IS);
+        Lock::DBLock dblk(opCtx->lockState(), minValidNss.db(), MODE_IS);
+        Lock::CollectionLock lk(opCtx->lockState(), minValidNss.ns(), MODE_IS);
         BSONObj mv;
-        if (Helpers::getSingleton(txn, minValidNss.ns().c_str(), mv)) {
+        if (Helpers::getSingleton(opCtx, minValidNss.ns().c_str(), mv)) {
             return mv;
         }
     }
-    MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "getMinValidDocument", minValidNss.ns());
+    MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "getMinValidDocument", minValidNss.ns());
     return BSONObj();
 }
 
@@ -116,21 +116,21 @@ CollectionOptions createOplogCollectionOptions() {
  * Create test collection.
  * Returns collection.
  */
-void createCollection(OperationContext* txn,
+void createCollection(OperationContext* opCtx,
                       const NamespaceString& nss,
                       const CollectionOptions& options = CollectionOptions()) {
     MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
-        ScopedTransaction transaction(txn, MODE_IX);
-        Lock::DBLock dblk(txn->lockState(), nss.db(), MODE_X);
-        OldClientContext ctx(txn, nss.ns());
+        ScopedTransaction transaction(opCtx, MODE_IX);
+        Lock::DBLock dblk(opCtx->lockState(), nss.db(), MODE_X);
+        OldClientContext ctx(opCtx, nss.ns());
         auto db = ctx.db();
         ASSERT_TRUE(db);
-        mongo::WriteUnitOfWork wuow(txn);
-        auto coll = db->createCollection(txn, nss.ns(), options);
+        mongo::WriteUnitOfWork wuow(opCtx);
+        auto coll = db->createCollection(opCtx, nss.ns(), options);
         ASSERT_TRUE(coll);
         wuow.commit();
     }
-    MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "createCollection", nss.ns());
+    MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "createCollection", nss.ns());
 }
 
 /**
@@ -158,11 +158,11 @@ ReplSettings createReplSettings() {
 /**
  * Counts the number of keys in an index using an IndexAccessMethod::validate call.
  */
-int64_t getIndexKeyCount(OperationContext* txn, IndexCatalog* cat, IndexDescriptor* desc) {
+int64_t getIndexKeyCount(OperationContext* opCtx, IndexCatalog* cat, IndexDescriptor* desc) {
     auto idx = cat->getIndex(desc);
     int64_t numKeys;
     ValidateResults fullRes;
-    idx->validate(txn, &numKeys, &fullRes);
+    idx->validate(opCtx, &numKeys, &fullRes);
     return numKeys;
 }
 
@@ -191,28 +191,28 @@ protected:
         ServiceContextMongoDTest::setUp();
         createOptCtx();
         _coordinator =
-            new ReplicationCoordinatorMock(_txn->getServiceContext(), createReplSettings());
+            new ReplicationCoordinatorMock(_opCtx->getServiceContext(), createReplSettings());
         setGlobalReplicationCoordinator(_coordinator);
     }
     void tearDown() override {
-        _txn.reset(nullptr);
+        _opCtx.reset(nullptr);
         ServiceContextMongoDTest::tearDown();
     }
 
 
     void createOptCtx() {
-        _txn = cc().makeOperationContext();
+        _opCtx = cc().makeOperationContext();
         // We are not replicating nor validating these writes.
-        _txn->setReplicatedWrites(false);
-        DisableDocumentValidation validationDisabler(_txn.get());
+        _opCtx->setReplicatedWrites(false);
+        DisableDocumentValidation validationDisabler(_opCtx.get());
     }
 
     OperationContext* getOperationContext() {
-        return _txn.get();
+        return _opCtx.get();
     }
 
 private:
-    ServiceContext::UniqueOperationContext _txn;
+    ServiceContext::UniqueOperationContext _opCtx;
 
     // Owned by service context
     ReplicationCoordinator* _coordinator;
@@ -249,23 +249,23 @@ TEST_F(StorageInterfaceImplTest, InitialSyncFlag) {
     NamespaceString nss("local.StorageInterfaceImplTest_InitialSyncFlag");
 
     StorageInterfaceImpl storageInterface(nss);
-    auto txn = getClient()->makeOperationContext();
+    auto opCtx = getClient()->makeOperationContext();
 
     // Initial sync flag should be unset after initializing a new storage engine.
-    ASSERT_FALSE(storageInterface.getInitialSyncFlag(txn.get()));
+    ASSERT_FALSE(storageInterface.getInitialSyncFlag(opCtx.get()));
 
     // Setting initial sync flag should affect getInitialSyncFlag() result.
-    storageInterface.setInitialSyncFlag(txn.get());
-    ASSERT_TRUE(storageInterface.getInitialSyncFlag(txn.get()));
+    storageInterface.setInitialSyncFlag(opCtx.get());
+    ASSERT_TRUE(storageInterface.getInitialSyncFlag(opCtx.get()));
 
     // Check min valid document using storage engine interface.
-    auto minValidDocument = getMinValidDocument(txn.get(), nss);
+    auto minValidDocument = getMinValidDocument(opCtx.get(), nss);
     ASSERT_TRUE(minValidDocument.hasField(StorageInterfaceImpl::kInitialSyncFlagFieldName));
     ASSERT_TRUE(minValidDocument.getBoolField(StorageInterfaceImpl::kInitialSyncFlagFieldName));
 
     // Clearing initial sync flag should affect getInitialSyncFlag() result.
-    storageInterface.clearInitialSyncFlag(txn.get());
-    ASSERT_FALSE(storageInterface.getInitialSyncFlag(txn.get()));
+    storageInterface.clearInitialSyncFlag(opCtx.get());
+    ASSERT_FALSE(storageInterface.getInitialSyncFlag(opCtx.get()));
 }
 
 TEST_F(StorageInterfaceImplTest, GetMinValidAfterSettingInitialSyncFlagWorks) {
@@ -273,53 +273,54 @@ TEST_F(StorageInterfaceImplTest, GetMinValidAfterSettingInitialSyncFlagWorks) {
         "local.StorageInterfaceImplTest_GetMinValidAfterSettingInitialSyncFlagWorks");
 
     StorageInterfaceImpl storageInterface(nss);
-    auto txn = getClient()->makeOperationContext();
+    auto opCtx = getClient()->makeOperationContext();
 
     // Initial sync flag should be unset after initializing a new storage engine.
-    ASSERT_FALSE(storageInterface.getInitialSyncFlag(txn.get()));
+    ASSERT_FALSE(storageInterface.getInitialSyncFlag(opCtx.get()));
 
     // Setting initial sync flag should affect getInitialSyncFlag() result.
-    storageInterface.setInitialSyncFlag(txn.get());
-    ASSERT_TRUE(storageInterface.getInitialSyncFlag(txn.get()));
+    storageInterface.setInitialSyncFlag(opCtx.get());
+    ASSERT_TRUE(storageInterface.getInitialSyncFlag(opCtx.get()));
 
-    ASSERT(storageInterface.getMinValid(txn.get()).isNull());
-    ASSERT(storageInterface.getAppliedThrough(txn.get()).isNull());
-    ASSERT(storageInterface.getOplogDeleteFromPoint(txn.get()).isNull());
+    ASSERT(storageInterface.getMinValid(opCtx.get()).isNull());
+    ASSERT(storageInterface.getAppliedThrough(opCtx.get()).isNull());
+    ASSERT(storageInterface.getOplogDeleteFromPoint(opCtx.get()).isNull());
 }
 
 TEST_F(StorageInterfaceImplTest, MinValid) {
     NamespaceString nss("local.StorageInterfaceImplTest_MinValid");
 
     StorageInterfaceImpl storageInterface(nss);
-    auto txn = getClient()->makeOperationContext();
+    auto opCtx = getClient()->makeOperationContext();
 
     // MinValid boundaries should all be null after initializing a new storage engine.
-    ASSERT(storageInterface.getMinValid(txn.get()).isNull());
-    ASSERT(storageInterface.getAppliedThrough(txn.get()).isNull());
-    ASSERT(storageInterface.getOplogDeleteFromPoint(txn.get()).isNull());
+    ASSERT(storageInterface.getMinValid(opCtx.get()).isNull());
+    ASSERT(storageInterface.getAppliedThrough(opCtx.get()).isNull());
+    ASSERT(storageInterface.getOplogDeleteFromPoint(opCtx.get()).isNull());
 
     // Setting min valid boundaries should affect getMinValid() result.
     OpTime startOpTime({Seconds(123), 0}, 1LL);
     OpTime endOpTime({Seconds(456), 0}, 1LL);
-    storageInterface.setAppliedThrough(txn.get(), startOpTime);
-    storageInterface.setMinValid(txn.get(), endOpTime);
-    storageInterface.setOplogDeleteFromPoint(txn.get(), endOpTime.getTimestamp());
+    storageInterface.setAppliedThrough(opCtx.get(), startOpTime);
+    storageInterface.setMinValid(opCtx.get(), endOpTime);
+    storageInterface.setOplogDeleteFromPoint(opCtx.get(), endOpTime.getTimestamp());
 
-    ASSERT_EQ(storageInterface.getAppliedThrough(txn.get()), startOpTime);
-    ASSERT_EQ(storageInterface.getMinValid(txn.get()), endOpTime);
-    ASSERT_EQ(storageInterface.getOplogDeleteFromPoint(txn.get()), endOpTime.getTimestamp());
+    ASSERT_EQ(storageInterface.getAppliedThrough(opCtx.get()), startOpTime);
+    ASSERT_EQ(storageInterface.getMinValid(opCtx.get()), endOpTime);
+    ASSERT_EQ(storageInterface.getOplogDeleteFromPoint(opCtx.get()), endOpTime.getTimestamp());
 
 
     // setMinValid always changes minValid, but setMinValidToAtLeast only does if higher.
-    storageInterface.setMinValid(txn.get(), startOpTime);  // Forcibly lower it.
-    ASSERT_EQ(storageInterface.getMinValid(txn.get()), startOpTime);
-    storageInterface.setMinValidToAtLeast(txn.get(), endOpTime);  // Higher than current (sets it).
-    ASSERT_EQ(storageInterface.getMinValid(txn.get()), endOpTime);
-    storageInterface.setMinValidToAtLeast(txn.get(), startOpTime);  // Lower than current (no-op).
-    ASSERT_EQ(storageInterface.getMinValid(txn.get()), endOpTime);
+    storageInterface.setMinValid(opCtx.get(), startOpTime);  // Forcibly lower it.
+    ASSERT_EQ(storageInterface.getMinValid(opCtx.get()), startOpTime);
+    storageInterface.setMinValidToAtLeast(opCtx.get(),
+                                          endOpTime);  // Higher than current (sets it).
+    ASSERT_EQ(storageInterface.getMinValid(opCtx.get()), endOpTime);
+    storageInterface.setMinValidToAtLeast(opCtx.get(), startOpTime);  // Lower than current (no-op).
+    ASSERT_EQ(storageInterface.getMinValid(opCtx.get()), endOpTime);
 
     // Check min valid document using storage engine interface.
-    auto minValidDocument = getMinValidDocument(txn.get(), nss);
+    auto minValidDocument = getMinValidDocument(opCtx.get(), nss);
     ASSERT_TRUE(minValidDocument.hasField(StorageInterfaceImpl::kBeginFieldName));
     ASSERT_TRUE(minValidDocument[StorageInterfaceImpl::kBeginFieldName].isABSONObj());
     ASSERT_EQUALS(startOpTime,
@@ -330,45 +331,45 @@ TEST_F(StorageInterfaceImplTest, MinValid) {
         endOpTime.getTimestamp(),
         minValidDocument[StorageInterfaceImpl::kOplogDeleteFromPointFieldName].timestamp());
 
-    // Recovery unit will be owned by "txn".
+    // Recovery unit will be owned by "opCtx".
     RecoveryUnitWithDurabilityTracking* recoveryUnit = new RecoveryUnitWithDurabilityTracking();
-    txn->setRecoveryUnit(recoveryUnit, OperationContext::kNotInUnitOfWork);
+    opCtx->setRecoveryUnit(recoveryUnit, OperationContext::kNotInUnitOfWork);
 
     // Set min valid without waiting for the changes to be durable.
     OpTime endOpTime2({Seconds(789), 0}, 1LL);
-    storageInterface.setMinValid(txn.get(), endOpTime2);
-    storageInterface.setAppliedThrough(txn.get(), {});
-    ASSERT_EQUALS(storageInterface.getAppliedThrough(txn.get()), OpTime());
-    ASSERT_EQUALS(storageInterface.getMinValid(txn.get()), endOpTime2);
+    storageInterface.setMinValid(opCtx.get(), endOpTime2);
+    storageInterface.setAppliedThrough(opCtx.get(), {});
+    ASSERT_EQUALS(storageInterface.getAppliedThrough(opCtx.get()), OpTime());
+    ASSERT_EQUALS(storageInterface.getMinValid(opCtx.get()), endOpTime2);
     ASSERT_FALSE(recoveryUnit->waitUntilDurableCalled);
 }
 
 TEST_F(StorageInterfaceImplTest, SnapshotSupported) {
-    auto txn = getClient()->makeOperationContext();
-    Status status = txn->recoveryUnit()->setReadFromMajorityCommittedSnapshot();
+    auto opCtx = getClient()->makeOperationContext();
+    Status status = opCtx->recoveryUnit()->setReadFromMajorityCommittedSnapshot();
     ASSERT(status.isOK());
 }
 
 TEST_F(StorageInterfaceImplTest, InsertDocumentsReturnsOKWhenNoOperationsAreGiven) {
-    auto txn = getClient()->makeOperationContext();
+    auto opCtx = getClient()->makeOperationContext();
     NamespaceString nss("local." + _agent.getTestName());
-    createCollection(txn.get(), nss);
+    createCollection(opCtx.get(), nss);
     StorageInterfaceImpl storageInterface(nss);
-    ASSERT_OK(storageInterface.insertDocuments(txn.get(), nss, {}));
+    ASSERT_OK(storageInterface.insertDocuments(opCtx.get(), nss, {}));
 }
 
 TEST_F(StorageInterfaceImplTest,
        InsertDocumentsReturnsInternalErrorWhenSavingOperationToNonOplogCollection) {
     // Create fake non-oplog collection to ensure saving oplog entries (without _id field) will
     // fail.
-    auto txn = getClient()->makeOperationContext();
+    auto opCtx = getClient()->makeOperationContext();
     NamespaceString nss("local." + _agent.getSuiteName() + "_" + _agent.getTestName());
-    createCollection(txn.get(), nss);
+    createCollection(opCtx.get(), nss);
 
     // Non-oplog collection will enforce mandatory _id field requirement on insertion.
     StorageInterfaceImpl storageInterface(nss);
     auto op = makeOplogEntry({Timestamp(Seconds(1), 0), 1LL});
-    auto status = storageInterface.insertDocuments(txn.get(), nss, {op});
+    auto status = storageInterface.insertDocuments(opCtx.get(), nss, {op});
     ASSERT_EQUALS(ErrorCodes::InternalError, status);
     ASSERT_STRING_CONTAINS(status.reason(), "Collection::insertDocument got document without _id");
 }
@@ -376,12 +377,12 @@ TEST_F(StorageInterfaceImplTest,
 TEST_F(StorageInterfaceImplTest,
        InsertDocumentsInsertsDocumentsOneAtATimeWhenAllAtOnceInsertingFails) {
     // Create a collection that does not support all-at-once inserting.
-    auto txn = getClient()->makeOperationContext();
+    auto opCtx = getClient()->makeOperationContext();
     NamespaceString nss("local." + _agent.getSuiteName() + "_" + _agent.getTestName());
     CollectionOptions options;
     options.capped = true;
     options.cappedSize = 1024 * 1024;
-    createCollection(txn.get(), nss, options);
+    createCollection(opCtx.get(), nss, options);
     // StorageInterfaceImpl::insertDocuments should fall back on inserting the batch one at a time.
     StorageInterfaceImpl storageInterface(nss);
     auto doc1 = BSON("_id" << 1);
@@ -389,16 +390,16 @@ TEST_F(StorageInterfaceImplTest,
     std::vector<BSONObj> docs({doc1, doc2});
     // Confirm that Collection::insertDocuments fails to insert the batch all at once.
     {
-        AutoGetCollection autoCollection(txn.get(), nss, MODE_IX);
-        WriteUnitOfWork wunit(txn.get());
+        AutoGetCollection autoCollection(opCtx.get(), nss, MODE_IX);
+        WriteUnitOfWork wunit(opCtx.get());
         ASSERT_EQUALS(ErrorCodes::OperationCannotBeBatched,
                       autoCollection.getCollection()->insertDocuments(
-                          txn.get(), docs.begin(), docs.cend(), nullptr, false));
+                          opCtx.get(), docs.begin(), docs.cend(), nullptr, false));
     }
-    ASSERT_OK(storageInterface.insertDocuments(txn.get(), nss, docs));
+    ASSERT_OK(storageInterface.insertDocuments(opCtx.get(), nss, docs));
 
     // Check collection contents. OplogInterface returns documents in reverse natural order.
-    OplogInterfaceLocal oplog(txn.get(), nss.ns());
+    OplogInterfaceLocal oplog(opCtx.get(), nss.ns());
     auto iter = oplog.makeIterator();
     ASSERT_BSONOBJ_EQ(doc2, unittest::assertGet(iter->next()).first);
     ASSERT_BSONOBJ_EQ(doc1, unittest::assertGet(iter->next()).first);
@@ -407,19 +408,19 @@ TEST_F(StorageInterfaceImplTest,
 
 TEST_F(StorageInterfaceImplTest, InsertDocumentsSavesOperationsReturnsOpTimeOfLastOperation) {
     // Create fake oplog collection to hold operations.
-    auto txn = getClient()->makeOperationContext();
+    auto opCtx = getClient()->makeOperationContext();
     NamespaceString nss("local." + _agent.getSuiteName() + "_" + _agent.getTestName());
-    createCollection(txn.get(), nss, createOplogCollectionOptions());
+    createCollection(opCtx.get(), nss, createOplogCollectionOptions());
 
     // Insert operations using storage interface. Ensure optime return is consistent with last
     // operation inserted.
     StorageInterfaceImpl storageInterface(nss);
     auto op1 = makeOplogEntry({Timestamp(Seconds(1), 0), 1LL});
     auto op2 = makeOplogEntry({Timestamp(Seconds(1), 0), 1LL});
-    ASSERT_OK(storageInterface.insertDocuments(txn.get(), nss, {op1, op2}));
+    ASSERT_OK(storageInterface.insertDocuments(opCtx.get(), nss, {op1, op2}));
 
     // Check contents of oplog. OplogInterface iterates over oplog collection in reverse.
-    repl::OplogInterfaceLocal oplog(txn.get(), nss.ns());
+    repl::OplogInterfaceLocal oplog(opCtx.get(), nss.ns());
     auto iter = oplog.makeIterator();
     ASSERT_BSONOBJ_EQ(op2, unittest::assertGet(iter->next()).first);
     ASSERT_BSONOBJ_EQ(op1, unittest::assertGet(iter->next()).first);
@@ -431,46 +432,46 @@ TEST_F(StorageInterfaceImplTest,
     auto op = makeOplogEntry({Timestamp(Seconds(1), 0), 1LL});
     NamespaceString nss("local.nosuchcollection");
     StorageInterfaceImpl storageInterface(nss);
-    auto txn = getClient()->makeOperationContext();
-    auto status = storageInterface.insertDocuments(txn.get(), nss, {op});
+    auto opCtx = getClient()->makeOperationContext();
+    auto status = storageInterface.insertDocuments(opCtx.get(), nss, {op});
     ASSERT_EQUALS(ErrorCodes::NamespaceNotFound, status);
     ASSERT_STRING_CONTAINS(status.reason(), "The collection must exist before inserting documents");
 }
 
 TEST_F(StorageInterfaceImplWithReplCoordTest, InsertMissingDocWorksOnExistingCappedCollection) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     NamespaceString nss("foo.bar");
     CollectionOptions opts;
     opts.capped = true;
     opts.cappedSize = 1024 * 1024;
-    createCollection(txn, nss, opts);
-    ASSERT_OK(storage.insertDocument(txn, nss, BSON("_id" << 1)));
-    AutoGetCollectionForRead autoColl(txn, nss);
+    createCollection(opCtx, nss, opts);
+    ASSERT_OK(storage.insertDocument(opCtx, nss, BSON("_id" << 1)));
+    AutoGetCollectionForRead autoColl(opCtx, nss);
     ASSERT_TRUE(autoColl.getCollection());
 }
 
 TEST_F(StorageInterfaceImplWithReplCoordTest, InsertMissingDocWorksOnExistingCollection) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     NamespaceString nss("foo.bar");
-    createCollection(txn, nss);
-    ASSERT_OK(storage.insertDocument(txn, nss, BSON("_id" << 1)));
-    AutoGetCollectionForRead autoColl(txn, nss);
+    createCollection(opCtx, nss);
+    ASSERT_OK(storage.insertDocument(opCtx, nss, BSON("_id" << 1)));
+    AutoGetCollectionForRead autoColl(opCtx, nss);
     ASSERT_TRUE(autoColl.getCollection());
 }
 
 TEST_F(StorageInterfaceImplWithReplCoordTest, InsertMissingDocFailesIfCollectionIsMissing) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     NamespaceString nss("foo.bar");
-    const auto status = storage.insertDocument(txn, nss, BSON("_id" << 1));
+    const auto status = storage.insertDocument(opCtx, nss, BSON("_id" << 1));
     ASSERT_NOT_OK(status);
     ASSERT_EQ(status.code(), ErrorCodes::NamespaceNotFound);
 }
 
 TEST_F(StorageInterfaceImplWithReplCoordTest, CreateCollectionWithIDIndexCommits) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     storage.startup();
     NamespaceString nss("foo.bar");
@@ -484,18 +485,18 @@ TEST_F(StorageInterfaceImplWithReplCoordTest, CreateCollectionWithIDIndexCommits
     ASSERT_OK(loader->insertDocuments(docs.begin(), docs.end()));
     ASSERT_OK(loader->commit());
 
-    AutoGetCollectionForRead autoColl(txn, nss);
+    AutoGetCollectionForRead autoColl(opCtx, nss);
     auto coll = autoColl.getCollection();
     ASSERT(coll);
-    ASSERT_EQ(coll->getRecordStore()->numRecords(txn), 2LL);
+    ASSERT_EQ(coll->getRecordStore()->numRecords(opCtx), 2LL);
     auto collIdxCat = coll->getIndexCatalog();
-    auto idIdxDesc = collIdxCat->findIdIndex(txn);
-    auto count = getIndexKeyCount(txn, collIdxCat, idIdxDesc);
+    auto idIdxDesc = collIdxCat->findIdIndex(opCtx);
+    auto count = getIndexKeyCount(opCtx, collIdxCat, idIdxDesc);
     ASSERT_EQ(count, 2LL);
 }
 
 void _testDestroyUncommitedCollectionBulkLoader(
-    OperationContext* txn,
+    OperationContext* opCtx,
     std::vector<BSONObj> secondaryIndexes,
     stdx::function<void(std::unique_ptr<CollectionBulkLoader> loader)> destroyLoaderFn) {
     StorageInterfaceImpl storage;
@@ -513,23 +514,23 @@ void _testDestroyUncommitedCollectionBulkLoader(
     // Collection and ID index should not exist after 'loader' is destroyed.
     destroyLoaderFn(std::move(loader));
 
-    AutoGetCollectionForRead autoColl(txn, nss);
+    AutoGetCollectionForRead autoColl(opCtx, nss);
     auto coll = autoColl.getCollection();
 
     // Bulk loader is used to create indexes. The collection is not dropped when the bulk loader is
     // destroyed.
     ASSERT_TRUE(coll);
-    ASSERT_EQ(1LL, coll->getRecordStore()->numRecords(txn));
+    ASSERT_EQ(1LL, coll->getRecordStore()->numRecords(opCtx));
 
     // IndexCatalog::numIndexesTotal() includes unfinished indexes. We need to ensure that
     // the bulk loader drops the unfinished indexes.
     auto collIdxCat = coll->getIndexCatalog();
-    ASSERT_EQUALS(0, collIdxCat->numIndexesTotal(txn));
+    ASSERT_EQUALS(0, collIdxCat->numIndexesTotal(opCtx));
 }
 
 TEST_F(StorageInterfaceImplWithReplCoordTest,
        DestroyingUncommittedCollectionBulkLoaderDropsIndexes) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     NamespaceString nss("foo.bar");
     std::vector<BSONObj> indexes = {BSON("v" << 1 << "key" << BSON("x" << 1) << "name"
                                              << "x_1"
@@ -538,24 +539,24 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
     auto destroyLoaderFn = [](std::unique_ptr<CollectionBulkLoader> loader) {
         // Destroy 'loader' by letting it go out of scope.
     };
-    _testDestroyUncommitedCollectionBulkLoader(txn, indexes, destroyLoaderFn);
+    _testDestroyUncommitedCollectionBulkLoader(opCtx, indexes, destroyLoaderFn);
 }
 
 TEST_F(StorageInterfaceImplWithReplCoordTest,
        DestructorInitializesClientBeforeDestroyingIdIndexBuilder) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     NamespaceString nss("foo.bar");
     std::vector<BSONObj> indexes;
     auto destroyLoaderFn = [](std::unique_ptr<CollectionBulkLoader> loader) {
         // Destroy 'loader' in a new thread that does not have a Client.
         stdx::thread([&loader]() { loader.reset(); }).join();
     };
-    _testDestroyUncommitedCollectionBulkLoader(txn, indexes, destroyLoaderFn);
+    _testDestroyUncommitedCollectionBulkLoader(opCtx, indexes, destroyLoaderFn);
 }
 
 TEST_F(StorageInterfaceImplWithReplCoordTest,
        DestructorInitializesClientBeforeDestroyingSecondaryIndexesBuilder) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     NamespaceString nss("foo.bar");
     std::vector<BSONObj> indexes = {BSON("v" << 1 << "key" << BSON("x" << 1) << "name"
                                              << "x_1"
@@ -565,15 +566,15 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
         // Destroy 'loader' in a new thread that does not have a Client.
         stdx::thread([&loader]() { loader.reset(); }).join();
     };
-    _testDestroyUncommitedCollectionBulkLoader(txn, indexes, destroyLoaderFn);
+    _testDestroyUncommitedCollectionBulkLoader(opCtx, indexes, destroyLoaderFn);
 }
 
 TEST_F(StorageInterfaceImplWithReplCoordTest, CreateCollectionThatAlreadyExistsFails) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     storage.startup();
     NamespaceString nss("test.system.indexes");
-    createCollection(txn, nss);
+    createCollection(opCtx, nss);
 
     const CollectionOptions opts;
     const std::vector<BSONObj> indexes;
@@ -583,16 +584,16 @@ TEST_F(StorageInterfaceImplWithReplCoordTest, CreateCollectionThatAlreadyExistsF
 }
 
 TEST_F(StorageInterfaceImplWithReplCoordTest, CreateOplogCreateCappedCollection) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     NamespaceString nss("local.oplog.X");
     {
-        AutoGetCollectionForRead autoColl(txn, nss);
+        AutoGetCollectionForRead autoColl(opCtx, nss);
         ASSERT_FALSE(autoColl.getCollection());
     }
-    ASSERT_OK(storage.createOplog(txn, nss));
+    ASSERT_OK(storage.createOplog(opCtx, nss));
     {
-        AutoGetCollectionForRead autoColl(txn, nss);
+        AutoGetCollectionForRead autoColl(opCtx, nss);
         ASSERT_TRUE(autoColl.getCollection());
         ASSERT_EQ(nss.toString(), autoColl.getCollection()->ns().toString());
         ASSERT_TRUE(autoColl.getCollection()->isCapped());
@@ -601,78 +602,78 @@ TEST_F(StorageInterfaceImplWithReplCoordTest, CreateOplogCreateCappedCollection)
 
 TEST_F(StorageInterfaceImplWithReplCoordTest,
        CreateCollectionReturnsUserExceptionAsStatusIfCollectionCreationThrows) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     NamespaceString nss("local.oplog.Y");
     {
-        AutoGetCollectionForRead autoColl(txn, nss);
+        AutoGetCollectionForRead autoColl(opCtx, nss);
         ASSERT_FALSE(autoColl.getCollection());
     }
 
-    auto status = storage.createCollection(txn, nss, CollectionOptions());
+    auto status = storage.createCollection(opCtx, nss, CollectionOptions());
     ASSERT_EQUALS(ErrorCodes::fromInt(28838), status);
     ASSERT_STRING_CONTAINS(status.reason(), "cannot create a non-capped oplog collection");
 }
 
 TEST_F(StorageInterfaceImplWithReplCoordTest, CreateCollectionFailsIfCollectionExists) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     auto nss = makeNamespace(_agent);
     {
-        AutoGetCollectionForRead autoColl(txn, nss);
+        AutoGetCollectionForRead autoColl(opCtx, nss);
         ASSERT_FALSE(autoColl.getCollection());
     }
-    ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
+    ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
     {
-        AutoGetCollectionForRead autoColl(txn, nss);
+        AutoGetCollectionForRead autoColl(opCtx, nss);
         ASSERT_TRUE(autoColl.getCollection());
         ASSERT_EQ(nss.toString(), autoColl.getCollection()->ns().toString());
     }
-    auto status = storage.createCollection(txn, nss, CollectionOptions());
+    auto status = storage.createCollection(opCtx, nss, CollectionOptions());
     ASSERT_EQUALS(ErrorCodes::NamespaceExists, status);
     ASSERT_STRING_CONTAINS(status.reason(),
                            str::stream() << "Collection " << nss.ns() << " already exists");
 }
 
 TEST_F(StorageInterfaceImplWithReplCoordTest, DropCollectionWorksWithExistingWithDataCollection) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     NamespaceString nss("foo.bar");
-    createCollection(txn, nss);
-    ASSERT_OK(storage.insertDocument(txn, nss, BSON("_id" << 1)));
-    ASSERT_OK(storage.dropCollection(txn, nss));
+    createCollection(opCtx, nss);
+    ASSERT_OK(storage.insertDocument(opCtx, nss, BSON("_id" << 1)));
+    ASSERT_OK(storage.dropCollection(opCtx, nss));
 }
 
 TEST_F(StorageInterfaceImplWithReplCoordTest, DropCollectionWorksWithExistingEmptyCollection) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     NamespaceString nss("foo.bar");
-    createCollection(txn, nss);
-    ASSERT_OK(storage.dropCollection(txn, nss));
-    AutoGetCollectionForRead autoColl(txn, nss);
+    createCollection(opCtx, nss);
+    ASSERT_OK(storage.dropCollection(opCtx, nss));
+    AutoGetCollectionForRead autoColl(opCtx, nss);
     ASSERT_FALSE(autoColl.getCollection());
 }
 
 TEST_F(StorageInterfaceImplWithReplCoordTest, DropCollectionWorksWithMissingCollection) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     NamespaceString nss("foo.bar");
-    ASSERT_FALSE(AutoGetDb(txn, nss.db(), MODE_IS).getDb());
-    ASSERT_OK(storage.dropCollection(txn, nss));
-    ASSERT_FALSE(AutoGetCollectionForRead(txn, nss).getCollection());
+    ASSERT_FALSE(AutoGetDb(opCtx, nss.db(), MODE_IS).getDb());
+    ASSERT_OK(storage.dropCollection(opCtx, nss));
+    ASSERT_FALSE(AutoGetCollectionForRead(opCtx, nss).getCollection());
     // Database should not be created after running dropCollection.
-    ASSERT_FALSE(AutoGetDb(txn, nss.db(), MODE_IS).getDb());
+    ASSERT_FALSE(AutoGetDb(opCtx, nss.db(), MODE_IS).getDb());
 }
 
 TEST_F(StorageInterfaceImplWithReplCoordTest,
        FindDocumentsReturnsInvalidNamespaceIfCollectionIsMissing) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     auto nss = makeNamespace(_agent);
     auto indexName = "_id_"_sd;
     ASSERT_EQUALS(ErrorCodes::NamespaceNotFound,
                   storage
-                      .findDocuments(txn,
+                      .findDocuments(opCtx,
                                      nss,
                                      indexName,
                                      StorageInterface::ScanDirection::kForward,
@@ -683,14 +684,14 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
 }
 
 TEST_F(StorageInterfaceImplWithReplCoordTest, FindDocumentsReturnsIndexNotFoundIfIndexIsMissing) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     auto nss = makeNamespace(_agent);
     auto indexName = "nonexistent"_sd;
-    ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
+    ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
     ASSERT_EQUALS(ErrorCodes::IndexNotFound,
                   storage
-                      .findDocuments(txn,
+                      .findDocuments(opCtx,
                                      nss,
                                      indexName,
                                      StorageInterface::ScanDirection::kForward,
@@ -702,7 +703,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest, FindDocumentsReturnsIndexNotFoundI
 
 TEST_F(StorageInterfaceImplWithReplCoordTest,
        FindDocumentsReturnsIndexOptionsConflictIfIndexIsAPartialIndex) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     storage.startup();
     auto nss = makeNamespace(_agent);
@@ -720,7 +721,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
     auto indexName = "x_1"_sd;
     ASSERT_EQUALS(ErrorCodes::IndexOptionsConflict,
                   storage
-                      .findDocuments(txn,
+                      .findDocuments(opCtx,
                                      nss,
                                      indexName,
                                      StorageInterface::ScanDirection::kForward,
@@ -731,12 +732,12 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
 }
 
 TEST_F(StorageInterfaceImplWithReplCoordTest, FindDocumentsReturnsEmptyVectorIfCollectionIsEmpty) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     auto nss = makeNamespace(_agent);
     auto indexName = "_id_"_sd;
-    ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
-    ASSERT_TRUE(unittest::assertGet(storage.findDocuments(txn,
+    ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+    ASSERT_TRUE(unittest::assertGet(storage.findDocuments(opCtx,
                                                           nss,
                                                           indexName,
                                                           StorageInterface::ScanDirection::kForward,
@@ -765,12 +766,12 @@ std::string _toString(const std::vector<BSONObj>& docs) {
 /**
  * Check collection contents. OplogInterface returns documents in reverse natural order.
  */
-void _assertDocumentsInCollectionEquals(OperationContext* txn,
+void _assertDocumentsInCollectionEquals(OperationContext* opCtx,
                                         const NamespaceString& nss,
                                         const std::vector<BSONObj>& docs) {
     std::vector<BSONObj> reversedDocs(docs);
     std::reverse(reversedDocs.begin(), reversedDocs.end());
-    OplogInterfaceLocal oplog(txn, nss.ns());
+    OplogInterfaceLocal oplog(opCtx, nss.ns());
     auto iter = oplog.makeIterator();
     for (const auto& doc : reversedDocs) {
         ASSERT_BSONOBJ_EQ(doc, unittest::assertGet(iter->next()).first);
@@ -805,12 +806,12 @@ BSONObj _assetGetFront(const StatusWith<std::vector<BSONObj>>& statusWithDocs) {
 
 TEST_F(StorageInterfaceImplWithReplCoordTest,
        FindDocumentsReturnsDocumentWithLowestKeyValueIfScanDirectionIsForward) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     auto nss = makeNamespace(_agent);
     auto indexName = "_id_"_sd;
-    ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
-    ASSERT_OK(storage.insertDocuments(txn,
+    ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+    ASSERT_OK(storage.insertDocuments(opCtx,
                                       nss,
                                       {BSON("_id" << 0),
                                        BSON("_id" << 1),
@@ -821,7 +822,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
     // startKey not provided
     ASSERT_BSONOBJ_EQ(
         BSON("_id" << 0),
-        _assetGetFront(storage.findDocuments(txn,
+        _assetGetFront(storage.findDocuments(opCtx,
                                              nss,
                                              indexName,
                                              StorageInterface::ScanDirection::kForward,
@@ -830,7 +831,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
                                              1U)));
 
     // startKey not provided. limit is 0.
-    _assertDocumentsEqual(storage.findDocuments(txn,
+    _assertDocumentsEqual(storage.findDocuments(opCtx,
                                                 nss,
                                                 indexName,
                                                 StorageInterface::ScanDirection::kForward,
@@ -840,7 +841,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
                           {});
 
     // startKey not provided. limit of 2.
-    _assertDocumentsEqual(storage.findDocuments(txn,
+    _assertDocumentsEqual(storage.findDocuments(opCtx,
                                                 nss,
                                                 indexName,
                                                 StorageInterface::ScanDirection::kForward,
@@ -852,7 +853,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
     // startKey provided; include start key
     ASSERT_BSONOBJ_EQ(
         BSON("_id" << 0),
-        _assetGetFront(storage.findDocuments(txn,
+        _assetGetFront(storage.findDocuments(opCtx,
                                              nss,
                                              indexName,
                                              StorageInterface::ScanDirection::kForward,
@@ -861,7 +862,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
                                              1U)));
     ASSERT_BSONOBJ_EQ(
         BSON("_id" << 1),
-        _assetGetFront(storage.findDocuments(txn,
+        _assetGetFront(storage.findDocuments(opCtx,
                                              nss,
                                              indexName,
                                              StorageInterface::ScanDirection::kForward,
@@ -871,7 +872,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
 
     ASSERT_BSONOBJ_EQ(
         BSON("_id" << 1),
-        _assetGetFront(storage.findDocuments(txn,
+        _assetGetFront(storage.findDocuments(opCtx,
                                              nss,
                                              indexName,
                                              StorageInterface::ScanDirection::kForward,
@@ -882,7 +883,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
     // startKey provided; include both start and end keys
     ASSERT_BSONOBJ_EQ(
         BSON("_id" << 1),
-        _assetGetFront(storage.findDocuments(txn,
+        _assetGetFront(storage.findDocuments(opCtx,
                                              nss,
                                              indexName,
                                              StorageInterface::ScanDirection::kForward,
@@ -893,7 +894,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
     // startKey provided; exclude start key
     ASSERT_BSONOBJ_EQ(
         BSON("_id" << 2),
-        _assetGetFront(storage.findDocuments(txn,
+        _assetGetFront(storage.findDocuments(opCtx,
                                              nss,
                                              indexName,
                                              StorageInterface::ScanDirection::kForward,
@@ -903,7 +904,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
 
     ASSERT_BSONOBJ_EQ(
         BSON("_id" << 2),
-        _assetGetFront(storage.findDocuments(txn,
+        _assetGetFront(storage.findDocuments(opCtx,
                                              nss,
                                              indexName,
                                              StorageInterface::ScanDirection::kForward,
@@ -914,7 +915,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
     // startKey provided; exclude both start and end keys
     ASSERT_BSONOBJ_EQ(
         BSON("_id" << 2),
-        _assetGetFront(storage.findDocuments(txn,
+        _assetGetFront(storage.findDocuments(opCtx,
                                              nss,
                                              indexName,
                                              StorageInterface::ScanDirection::kForward,
@@ -924,7 +925,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
 
     // startKey provided; exclude both start and end keys.
     // A limit of 3 should return 2 documents because we reached the end of the collection.
-    _assertDocumentsEqual(storage.findDocuments(txn,
+    _assertDocumentsEqual(storage.findDocuments(opCtx,
                                                 nss,
                                                 indexName,
                                                 StorageInterface::ScanDirection::kForward,
@@ -934,19 +935,19 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
                           {BSON("_id" << 3), BSON("_id" << 4)});
 
     _assertDocumentsInCollectionEquals(
-        txn,
+        opCtx,
         nss,
         {BSON("_id" << 0), BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 3), BSON("_id" << 4)});
 }
 
 TEST_F(StorageInterfaceImplWithReplCoordTest,
        FindDocumentsReturnsDocumentWithHighestKeyValueIfScanDirectionIsBackward) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     auto nss = makeNamespace(_agent);
     auto indexName = "_id_"_sd;
-    ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
-    ASSERT_OK(storage.insertDocuments(txn,
+    ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+    ASSERT_OK(storage.insertDocuments(opCtx,
                                       nss,
                                       {BSON("_id" << 0),
                                        BSON("_id" << 1),
@@ -957,7 +958,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
     // startKey not provided
     ASSERT_BSONOBJ_EQ(
         BSON("_id" << 4),
-        _assetGetFront(storage.findDocuments(txn,
+        _assetGetFront(storage.findDocuments(opCtx,
                                              nss,
                                              indexName,
                                              StorageInterface::ScanDirection::kBackward,
@@ -966,7 +967,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
                                              1U)));
 
     // startKey not provided. limit is 0.
-    _assertDocumentsEqual(storage.findDocuments(txn,
+    _assertDocumentsEqual(storage.findDocuments(opCtx,
                                                 nss,
                                                 indexName,
                                                 StorageInterface::ScanDirection::kBackward,
@@ -976,7 +977,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
                           {});
 
     // startKey not provided. limit of 2.
-    _assertDocumentsEqual(storage.findDocuments(txn,
+    _assertDocumentsEqual(storage.findDocuments(opCtx,
                                                 nss,
                                                 indexName,
                                                 StorageInterface::ScanDirection::kBackward,
@@ -988,7 +989,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
     // startKey provided; include start key
     ASSERT_BSONOBJ_EQ(
         BSON("_id" << 4),
-        _assetGetFront(storage.findDocuments(txn,
+        _assetGetFront(storage.findDocuments(opCtx,
                                              nss,
                                              indexName,
                                              StorageInterface::ScanDirection::kBackward,
@@ -997,7 +998,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
                                              1U)));
     ASSERT_BSONOBJ_EQ(
         BSON("_id" << 3),
-        _assetGetFront(storage.findDocuments(txn,
+        _assetGetFront(storage.findDocuments(opCtx,
                                              nss,
                                              indexName,
                                              StorageInterface::ScanDirection::kBackward,
@@ -1008,7 +1009,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
     // startKey provided; include both start and end keys
     ASSERT_BSONOBJ_EQ(
         BSON("_id" << 4),
-        _assetGetFront(storage.findDocuments(txn,
+        _assetGetFront(storage.findDocuments(opCtx,
                                              nss,
                                              indexName,
                                              StorageInterface::ScanDirection::kBackward,
@@ -1019,7 +1020,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
     // startKey provided; exclude start key
     ASSERT_BSONOBJ_EQ(
         BSON("_id" << 2),
-        _assetGetFront(storage.findDocuments(txn,
+        _assetGetFront(storage.findDocuments(opCtx,
                                              nss,
                                              indexName,
                                              StorageInterface::ScanDirection::kBackward,
@@ -1030,7 +1031,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
     // startKey provided; exclude both start and end keys
     ASSERT_BSONOBJ_EQ(
         BSON("_id" << 2),
-        _assetGetFront(storage.findDocuments(txn,
+        _assetGetFront(storage.findDocuments(opCtx,
                                              nss,
                                              indexName,
                                              StorageInterface::ScanDirection::kBackward,
@@ -1040,7 +1041,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
 
     // startKey provided; exclude both start and end keys.
     // A limit of 3 should return 2 documents because we reached the beginning of the collection.
-    _assertDocumentsEqual(storage.findDocuments(txn,
+    _assertDocumentsEqual(storage.findDocuments(opCtx,
                                                 nss,
                                                 indexName,
                                                 StorageInterface::ScanDirection::kBackward,
@@ -1050,22 +1051,22 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
                           {BSON("_id" << 1), BSON("_id" << 0)});
 
     _assertDocumentsInCollectionEquals(
-        txn,
+        opCtx,
         nss,
         {BSON("_id" << 0), BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 3), BSON("_id" << 4)});
 }
 
 TEST_F(StorageInterfaceImplWithReplCoordTest,
        FindDocumentsCollScanReturnsFirstDocumentInsertedIfScanDirectionIsForward) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     auto nss = makeNamespace(_agent);
-    ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
-    ASSERT_OK(
-        storage.insertDocuments(txn, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
+    ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+    ASSERT_OK(storage.insertDocuments(
+        opCtx, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
     ASSERT_BSONOBJ_EQ(
         BSON("_id" << 1),
-        _assetGetFront(storage.findDocuments(txn,
+        _assetGetFront(storage.findDocuments(opCtx,
                                              nss,
                                              boost::none,
                                              StorageInterface::ScanDirection::kForward,
@@ -1074,7 +1075,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
                                              1U)));
 
     // Check collection contents. OplogInterface returns documents in reverse natural order.
-    OplogInterfaceLocal oplog(txn, nss.ns());
+    OplogInterfaceLocal oplog(opCtx, nss.ns());
     auto iter = oplog.makeIterator();
     ASSERT_BSONOBJ_EQ(BSON("_id" << 0), unittest::assertGet(iter->next()).first);
     ASSERT_BSONOBJ_EQ(BSON("_id" << 2), unittest::assertGet(iter->next()).first);
@@ -1084,15 +1085,15 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
 
 TEST_F(StorageInterfaceImplWithReplCoordTest,
        FindDocumentsCollScanReturnsLastDocumentInsertedIfScanDirectionIsBackward) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     auto nss = makeNamespace(_agent);
-    ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
-    ASSERT_OK(
-        storage.insertDocuments(txn, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
+    ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+    ASSERT_OK(storage.insertDocuments(
+        opCtx, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
     ASSERT_BSONOBJ_EQ(
         BSON("_id" << 0),
-        _assetGetFront(storage.findDocuments(txn,
+        _assetGetFront(storage.findDocuments(opCtx,
                                              nss,
                                              boost::none,
                                              StorageInterface::ScanDirection::kBackward,
@@ -1101,20 +1102,20 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
                                              1U)));
 
     _assertDocumentsInCollectionEquals(
-        txn, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)});
+        opCtx, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)});
 }
 
 TEST_F(StorageInterfaceImplWithReplCoordTest,
        FindDocumentsCollScanReturnsNoSuchKeyIfStartKeyIsNotEmpty) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     auto nss = makeNamespace(_agent);
-    ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
-    ASSERT_OK(
-        storage.insertDocuments(txn, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
+    ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+    ASSERT_OK(storage.insertDocuments(
+        opCtx, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
     ASSERT_EQUALS(ErrorCodes::NoSuchKey,
                   storage
-                      .findDocuments(txn,
+                      .findDocuments(opCtx,
                                      nss,
                                      boost::none,
                                      StorageInterface::ScanDirection::kForward,
@@ -1126,15 +1127,15 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
 
 TEST_F(StorageInterfaceImplWithReplCoordTest,
        FindDocumentsCollScanReturnsInvalidOptionsIfBoundIsNotStartKeyOnly) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     auto nss = makeNamespace(_agent);
-    ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
-    ASSERT_OK(
-        storage.insertDocuments(txn, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
+    ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+    ASSERT_OK(storage.insertDocuments(
+        opCtx, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
     ASSERT_EQUALS(ErrorCodes::InvalidOptions,
                   storage
-                      .findDocuments(txn,
+                      .findDocuments(opCtx,
                                      nss,
                                      boost::none,
                                      StorageInterface::ScanDirection::kForward,
@@ -1146,13 +1147,13 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
 
 TEST_F(StorageInterfaceImplWithReplCoordTest,
        DeleteDocumentsReturnsInvalidNamespaceIfCollectionIsMissing) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     auto nss = makeNamespace(_agent);
     auto indexName = "_id_"_sd;
     ASSERT_EQUALS(ErrorCodes::NamespaceNotFound,
                   storage
-                      .deleteDocuments(txn,
+                      .deleteDocuments(opCtx,
                                        nss,
                                        indexName,
                                        StorageInterface::ScanDirection::kForward,
@@ -1163,14 +1164,14 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
 }
 
 TEST_F(StorageInterfaceImplWithReplCoordTest, DeleteDocumentsReturnsIndexNotFoundIfIndexIsMissing) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     auto nss = makeNamespace(_agent);
     auto indexName = "nonexistent"_sd;
-    ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
+    ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
     ASSERT_EQUALS(ErrorCodes::IndexNotFound,
                   storage
-                      .deleteDocuments(txn,
+                      .deleteDocuments(opCtx,
                                        nss,
                                        indexName,
                                        StorageInterface::ScanDirection::kForward,
@@ -1182,13 +1183,13 @@ TEST_F(StorageInterfaceImplWithReplCoordTest, DeleteDocumentsReturnsIndexNotFoun
 
 TEST_F(StorageInterfaceImplWithReplCoordTest,
        DeleteDocumentsReturnsEmptyVectorIfCollectionIsEmpty) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     auto nss = makeNamespace(_agent);
     auto indexName = "_id_"_sd;
-    ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
+    ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
     ASSERT_TRUE(
-        unittest::assertGet(storage.deleteDocuments(txn,
+        unittest::assertGet(storage.deleteDocuments(opCtx,
                                                     nss,
                                                     indexName,
                                                     StorageInterface::ScanDirection::kForward,
@@ -1200,12 +1201,12 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
 
 TEST_F(StorageInterfaceImplWithReplCoordTest,
        DeleteDocumentsReturnsDocumentWithLowestKeyValueIfScanDirectionIsForward) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     auto nss = makeNamespace(_agent);
     auto indexName = "_id_"_sd;
-    ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
-    ASSERT_OK(storage.insertDocuments(txn,
+    ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+    ASSERT_OK(storage.insertDocuments(opCtx,
                                       nss,
                                       {BSON("_id" << 0),
                                        BSON("_id" << 1),
@@ -1219,7 +1220,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
     // startKey not provided
     ASSERT_BSONOBJ_EQ(
         BSON("_id" << 0),
-        _assetGetFront(storage.deleteDocuments(txn,
+        _assetGetFront(storage.deleteDocuments(opCtx,
                                                nss,
                                                indexName,
                                                StorageInterface::ScanDirection::kForward,
@@ -1227,7 +1228,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
                                                BoundInclusion::kIncludeStartKeyOnly,
                                                1U)));
 
-    _assertDocumentsInCollectionEquals(txn,
+    _assertDocumentsInCollectionEquals(opCtx,
                                        nss,
                                        {BSON("_id" << 1),
                                         BSON("_id" << 2),
@@ -1238,7 +1239,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
                                         BSON("_id" << 7)});
 
     // startKey not provided. limit is 0.
-    _assertDocumentsEqual(storage.deleteDocuments(txn,
+    _assertDocumentsEqual(storage.deleteDocuments(opCtx,
                                                   nss,
                                                   indexName,
                                                   StorageInterface::ScanDirection::kForward,
@@ -1247,7 +1248,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
                                                   0U),
                           {});
 
-    _assertDocumentsInCollectionEquals(txn,
+    _assertDocumentsInCollectionEquals(opCtx,
                                        nss,
                                        {BSON("_id" << 1),
                                         BSON("_id" << 2),
@@ -1260,7 +1261,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
     // startKey provided; include start key
     ASSERT_BSONOBJ_EQ(
         BSON("_id" << 2),
-        _assetGetFront(storage.deleteDocuments(txn,
+        _assetGetFront(storage.deleteDocuments(opCtx,
                                                nss,
                                                indexName,
                                                StorageInterface::ScanDirection::kForward,
@@ -1268,7 +1269,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
                                                BoundInclusion::kIncludeStartKeyOnly,
                                                1U)));
 
-    _assertDocumentsInCollectionEquals(txn,
+    _assertDocumentsInCollectionEquals(opCtx,
                                        nss,
                                        {BSON("_id" << 1),
                                         BSON("_id" << 3),
@@ -1280,7 +1281,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
     // startKey provided; exclude start key
     ASSERT_BSONOBJ_EQ(
         BSON("_id" << 5),
-        _assetGetFront(storage.deleteDocuments(txn,
+        _assetGetFront(storage.deleteDocuments(opCtx,
                                                nss,
                                                indexName,
                                                StorageInterface::ScanDirection::kForward,
@@ -1289,13 +1290,13 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
                                                1U)));
 
     _assertDocumentsInCollectionEquals(
-        txn,
+        opCtx,
         nss,
         {BSON("_id" << 1), BSON("_id" << 3), BSON("_id" << 4), BSON("_id" << 6), BSON("_id" << 7)});
 
     // startKey provided; exclude start key.
     // A limit of 3 should return 2 documents because we reached the end of the collection.
-    _assertDocumentsEqual(storage.deleteDocuments(txn,
+    _assertDocumentsEqual(storage.deleteDocuments(opCtx,
                                                   nss,
                                                   indexName,
                                                   StorageInterface::ScanDirection::kForward,
@@ -1305,17 +1306,17 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
                           {BSON("_id" << 6), BSON("_id" << 7)});
 
     _assertDocumentsInCollectionEquals(
-        txn, nss, {BSON("_id" << 1), BSON("_id" << 3), BSON("_id" << 4)});
+        opCtx, nss, {BSON("_id" << 1), BSON("_id" << 3), BSON("_id" << 4)});
 }
 
 TEST_F(StorageInterfaceImplWithReplCoordTest,
        DeleteDocumentsReturnsDocumentWithHighestKeyValueIfScanDirectionIsBackward) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     auto nss = makeNamespace(_agent);
     auto indexName = "_id_"_sd;
-    ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
-    ASSERT_OK(storage.insertDocuments(txn,
+    ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+    ASSERT_OK(storage.insertDocuments(opCtx,
                                       nss,
                                       {BSON("_id" << 0),
                                        BSON("_id" << 1),
@@ -1329,7 +1330,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
     // startKey not provided
     ASSERT_BSONOBJ_EQ(
         BSON("_id" << 7),
-        _assetGetFront(storage.deleteDocuments(txn,
+        _assetGetFront(storage.deleteDocuments(opCtx,
                                                nss,
                                                indexName,
                                                StorageInterface::ScanDirection::kBackward,
@@ -1337,7 +1338,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
                                                BoundInclusion::kIncludeStartKeyOnly,
                                                1U)));
 
-    _assertDocumentsInCollectionEquals(txn,
+    _assertDocumentsInCollectionEquals(opCtx,
                                        nss,
                                        {BSON("_id" << 0),
                                         BSON("_id" << 1),
@@ -1348,7 +1349,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
                                         BSON("_id" << 6)});
 
     // startKey not provided. limit is 0.
-    _assertDocumentsEqual(storage.deleteDocuments(txn,
+    _assertDocumentsEqual(storage.deleteDocuments(opCtx,
                                                   nss,
                                                   indexName,
                                                   StorageInterface::ScanDirection::kBackward,
@@ -1357,7 +1358,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
                                                   0U),
                           {});
 
-    _assertDocumentsInCollectionEquals(txn,
+    _assertDocumentsInCollectionEquals(opCtx,
                                        nss,
                                        {BSON("_id" << 0),
                                         BSON("_id" << 1),
@@ -1370,7 +1371,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
     // startKey provided; include start key
     ASSERT_BSONOBJ_EQ(
         BSON("_id" << 5),
-        _assetGetFront(storage.deleteDocuments(txn,
+        _assetGetFront(storage.deleteDocuments(opCtx,
                                                nss,
                                                indexName,
                                                StorageInterface::ScanDirection::kBackward,
@@ -1378,7 +1379,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
                                                BoundInclusion::kIncludeStartKeyOnly,
                                                1U)));
 
-    _assertDocumentsInCollectionEquals(txn,
+    _assertDocumentsInCollectionEquals(opCtx,
                                        nss,
                                        {BSON("_id" << 0),
                                         BSON("_id" << 1),
@@ -1390,7 +1391,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
     // startKey provided; exclude start key
     ASSERT_BSONOBJ_EQ(
         BSON("_id" << 2),
-        _assetGetFront(storage.deleteDocuments(txn,
+        _assetGetFront(storage.deleteDocuments(opCtx,
                                                nss,
                                                indexName,
                                                StorageInterface::ScanDirection::kBackward,
@@ -1399,13 +1400,13 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
                                                1U)));
 
     _assertDocumentsInCollectionEquals(
-        txn,
+        opCtx,
         nss,
         {BSON("_id" << 0), BSON("_id" << 1), BSON("_id" << 3), BSON("_id" << 4), BSON("_id" << 6)});
 
     // startKey provided; exclude start key.
     // A limit of 3 should return 2 documents because we reached the beginning of the collection.
-    _assertDocumentsEqual(storage.deleteDocuments(txn,
+    _assertDocumentsEqual(storage.deleteDocuments(opCtx,
                                                   nss,
                                                   indexName,
                                                   StorageInterface::ScanDirection::kBackward,
@@ -1415,20 +1416,20 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
                           {BSON("_id" << 1), BSON("_id" << 0)});
 
     _assertDocumentsInCollectionEquals(
-        txn, nss, {BSON("_id" << 3), BSON("_id" << 4), BSON("_id" << 6)});
+        opCtx, nss, {BSON("_id" << 3), BSON("_id" << 4), BSON("_id" << 6)});
 }
 
 TEST_F(StorageInterfaceImplWithReplCoordTest,
        DeleteDocumentsCollScanReturnsFirstDocumentInsertedIfScanDirectionIsForward) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     auto nss = makeNamespace(_agent);
-    ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
-    ASSERT_OK(
-        storage.insertDocuments(txn, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
+    ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+    ASSERT_OK(storage.insertDocuments(
+        opCtx, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
     ASSERT_BSONOBJ_EQ(
         BSON("_id" << 1),
-        _assetGetFront(storage.deleteDocuments(txn,
+        _assetGetFront(storage.deleteDocuments(opCtx,
                                                nss,
                                                boost::none,
                                                StorageInterface::ScanDirection::kForward,
@@ -1436,20 +1437,20 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
                                                BoundInclusion::kIncludeStartKeyOnly,
                                                1U)));
 
-    _assertDocumentsInCollectionEquals(txn, nss, {BSON("_id" << 2), BSON("_id" << 0)});
+    _assertDocumentsInCollectionEquals(opCtx, nss, {BSON("_id" << 2), BSON("_id" << 0)});
 }
 
 TEST_F(StorageInterfaceImplWithReplCoordTest,
        DeleteDocumentsCollScanReturnsLastDocumentInsertedIfScanDirectionIsBackward) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     auto nss = makeNamespace(_agent);
-    ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
-    ASSERT_OK(
-        storage.insertDocuments(txn, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
+    ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+    ASSERT_OK(storage.insertDocuments(
+        opCtx, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
     ASSERT_BSONOBJ_EQ(
         BSON("_id" << 0),
-        _assetGetFront(storage.deleteDocuments(txn,
+        _assetGetFront(storage.deleteDocuments(opCtx,
                                                nss,
                                                boost::none,
                                                StorageInterface::ScanDirection::kBackward,
@@ -1457,20 +1458,20 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
                                                BoundInclusion::kIncludeStartKeyOnly,
                                                1U)));
 
-    _assertDocumentsInCollectionEquals(txn, nss, {BSON("_id" << 1), BSON("_id" << 2)});
+    _assertDocumentsInCollectionEquals(opCtx, nss, {BSON("_id" << 1), BSON("_id" << 2)});
 }
 
 TEST_F(StorageInterfaceImplWithReplCoordTest,
        DeleteDocumentsCollScanReturnsNoSuchKeyIfStartKeyIsNotEmpty) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     auto nss = makeNamespace(_agent);
-    ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
-    ASSERT_OK(
-        storage.insertDocuments(txn, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
+    ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+    ASSERT_OK(storage.insertDocuments(
+        opCtx, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
     ASSERT_EQUALS(ErrorCodes::NoSuchKey,
                   storage
-                      .deleteDocuments(txn,
+                      .deleteDocuments(opCtx,
                                        nss,
                                        boost::none,
                                        StorageInterface::ScanDirection::kForward,
@@ -1482,15 +1483,15 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
 
 TEST_F(StorageInterfaceImplWithReplCoordTest,
        DeleteDocumentsCollScanReturnsInvalidOptionsIfBoundIsNotStartKeyOnly) {
-    auto txn = getOperationContext();
+    auto opCtx = getOperationContext();
     StorageInterfaceImpl storage;
     auto nss = makeNamespace(_agent);
-    ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
-    ASSERT_OK(
-        storage.insertDocuments(txn, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
+    ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+    ASSERT_OK(storage.insertDocuments(
+        opCtx, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
     ASSERT_EQUALS(ErrorCodes::InvalidOptions,
                   storage
-                      .deleteDocuments(txn,
+                      .deleteDocuments(opCtx,
                                        nss,
                                        boost::none,
                                        StorageInterface::ScanDirection::kForward,
diff --git a/src/mongo/db/repl/storage_interface_mock.cpp b/src/mongo/db/repl/storage_interface_mock.cpp
index ec870c1a0cc..4b534c05d6a 100644
--- a/src/mongo/db/repl/storage_interface_mock.cpp
+++ b/src/mongo/db/repl/storage_interface_mock.cpp
@@ -40,53 +40,53 @@ namespace mongo {
 namespace repl {
 void StorageInterfaceMock::startup() {}
 void StorageInterfaceMock::shutdown() {}
-bool StorageInterfaceMock::getInitialSyncFlag(OperationContext* txn) const {
+bool StorageInterfaceMock::getInitialSyncFlag(OperationContext* opCtx) const {
     stdx::lock_guard<stdx::mutex> lock(_initialSyncFlagMutex);
     return _initialSyncFlag;
 }
 
-void StorageInterfaceMock::setInitialSyncFlag(OperationContext* txn) {
+void StorageInterfaceMock::setInitialSyncFlag(OperationContext* opCtx) {
     stdx::lock_guard<stdx::mutex> lock(_initialSyncFlagMutex);
     _initialSyncFlag = true;
 }
 
-void StorageInterfaceMock::clearInitialSyncFlag(OperationContext* txn) {
+void StorageInterfaceMock::clearInitialSyncFlag(OperationContext* opCtx) {
     stdx::lock_guard<stdx::mutex> lock(_initialSyncFlagMutex);
     _initialSyncFlag = false;
 }
 
-OpTime StorageInterfaceMock::getMinValid(OperationContext* txn) const {
+OpTime StorageInterfaceMock::getMinValid(OperationContext* opCtx) const {
     stdx::lock_guard<stdx::mutex> lock(_minValidBoundariesMutex);
     return _minValid;
 }
 
-void StorageInterfaceMock::setMinValid(OperationContext* txn, const OpTime& minValid) {
+void StorageInterfaceMock::setMinValid(OperationContext* opCtx, const OpTime& minValid) {
     stdx::lock_guard<stdx::mutex> lock(_minValidBoundariesMutex);
     _minValid = minValid;
 }
 
-void StorageInterfaceMock::setMinValidToAtLeast(OperationContext* txn, const OpTime& minValid) {
+void StorageInterfaceMock::setMinValidToAtLeast(OperationContext* opCtx, const OpTime& minValid) {
     stdx::lock_guard<stdx::mutex> lock(_minValidBoundariesMutex);
     _minValid = std::max(_minValid, minValid);
 }
 
-void StorageInterfaceMock::setOplogDeleteFromPoint(OperationContext* txn,
+void StorageInterfaceMock::setOplogDeleteFromPoint(OperationContext* opCtx,
                                                    const Timestamp& timestamp) {
     stdx::lock_guard<stdx::mutex> lock(_minValidBoundariesMutex);
     _oplogDeleteFromPoint = timestamp;
 }
 
-Timestamp StorageInterfaceMock::getOplogDeleteFromPoint(OperationContext* txn) {
+Timestamp StorageInterfaceMock::getOplogDeleteFromPoint(OperationContext* opCtx) {
     stdx::lock_guard<stdx::mutex> lock(_minValidBoundariesMutex);
     return _oplogDeleteFromPoint;
 }
 
-void StorageInterfaceMock::setAppliedThrough(OperationContext* txn, const OpTime& optime) {
+void StorageInterfaceMock::setAppliedThrough(OperationContext* opCtx, const OpTime& optime) {
     stdx::lock_guard<stdx::mutex> lock(_minValidBoundariesMutex);
     _appliedThrough = optime;
 }
 
-OpTime StorageInterfaceMock::getAppliedThrough(OperationContext* txn) {
+OpTime StorageInterfaceMock::getAppliedThrough(OperationContext* opCtx) {
     stdx::lock_guard<stdx::mutex> lock(_minValidBoundariesMutex);
     return _appliedThrough;
 }
diff --git a/src/mongo/db/repl/storage_interface_mock.h b/src/mongo/db/repl/storage_interface_mock.h
index 911244c2670..9f63764473b 100644
--- a/src/mongo/db/repl/storage_interface_mock.h
+++ b/src/mongo/db/repl/storage_interface_mock.h
@@ -92,17 +92,18 @@ public:
             const BSONObj idIndexSpec,
             const std::vector<BSONObj>& secondaryIndexSpecs)>;
     using InsertDocumentFn = stdx::function<Status(
-        OperationContext* txn, const NamespaceString& nss, const BSONObj& doc)>;
+        OperationContext* opCtx, const NamespaceString& nss, const BSONObj& doc)>;
     using InsertDocumentsFn = stdx::function<Status(
-        OperationContext* txn, const NamespaceString& nss, const std::vector<BSONObj>& docs)>;
-    using DropUserDatabasesFn = stdx::function<Status(OperationContext* txn)>;
-    using CreateOplogFn = stdx::function<Status(OperationContext* txn, const NamespaceString& nss)>;
+        OperationContext* opCtx, const NamespaceString& nss, const std::vector<BSONObj>& docs)>;
+    using DropUserDatabasesFn = stdx::function<Status(OperationContext* opCtx)>;
+    using CreateOplogFn =
+        stdx::function<Status(OperationContext* opCtx, const NamespaceString& nss)>;
     using CreateCollectionFn = stdx::function<Status(
-        OperationContext* txn, const NamespaceString& nss, const CollectionOptions& options)>;
+        OperationContext* opCtx, const NamespaceString& nss, const CollectionOptions& options)>;
     using DropCollectionFn =
-        stdx::function<Status(OperationContext* txn, const NamespaceString& nss)>;
+        stdx::function<Status(OperationContext* opCtx, const NamespaceString& nss)>;
     using FindDocumentsFn =
-        stdx::function<StatusWith<std::vector<BSONObj>>(OperationContext* txn,
+        stdx::function<StatusWith<std::vector<BSONObj>>(OperationContext* opCtx,
                                                         const NamespaceString& nss,
                                                         boost::optional<StringData> indexName,
                                                         ScanDirection scanDirection,
@@ -110,31 +111,31 @@ public:
                                                         BoundInclusion boundInclusion,
                                                         std::size_t limit)>;
     using DeleteDocumentsFn =
-        stdx::function<StatusWith<std::vector<BSONObj>>(OperationContext* txn,
+        stdx::function<StatusWith<std::vector<BSONObj>>(OperationContext* opCtx,
                                                         const NamespaceString& nss,
                                                         boost::optional<StringData> indexName,
                                                         ScanDirection scanDirection,
                                                         const BSONObj& startKey,
                                                         BoundInclusion boundInclusion,
                                                         std::size_t limit)>;
-    using IsAdminDbValidFn = stdx::function<Status(OperationContext* txn)>;
+    using IsAdminDbValidFn = stdx::function<Status(OperationContext* opCtx)>;
 
     StorageInterfaceMock() = default;
 
     void startup() override;
     void shutdown() override;
 
-    bool getInitialSyncFlag(OperationContext* txn) const override;
-    void setInitialSyncFlag(OperationContext* txn) override;
-    void clearInitialSyncFlag(OperationContext* txn) override;
+    bool getInitialSyncFlag(OperationContext* opCtx) const override;
+    void setInitialSyncFlag(OperationContext* opCtx) override;
+    void clearInitialSyncFlag(OperationContext* opCtx) override;
 
-    OpTime getMinValid(OperationContext* txn) const override;
-    void setMinValid(OperationContext* txn, const OpTime& minValid) override;
-    void setMinValidToAtLeast(OperationContext* txn, const OpTime& minValid) override;
-    void setOplogDeleteFromPoint(OperationContext* txn, const Timestamp& timestamp) override;
-    Timestamp getOplogDeleteFromPoint(OperationContext* txn) override;
-    void setAppliedThrough(OperationContext* txn, const OpTime& optime) override;
-    OpTime getAppliedThrough(OperationContext* txn) override;
+    OpTime getMinValid(OperationContext* opCtx) const override;
+    void setMinValid(OperationContext* opCtx, const OpTime& minValid) override;
+    void setMinValidToAtLeast(OperationContext* opCtx, const OpTime& minValid) override;
+    void setOplogDeleteFromPoint(OperationContext* opCtx, const Timestamp& timestamp) override;
+    Timestamp getOplogDeleteFromPoint(OperationContext* opCtx) override;
+    void setAppliedThrough(OperationContext* opCtx, const OpTime& optime) override;
+    OpTime getAppliedThrough(OperationContext* opCtx) override;
 
     StatusWith<std::unique_ptr<CollectionBulkLoader>> createCollectionForBulkLoading(
         const NamespaceString& nss,
@@ -144,51 +145,53 @@ public:
         return createCollectionForBulkFn(nss, options, idIndexSpec, secondaryIndexSpecs);
     };
 
-    Status insertDocument(OperationContext* txn,
+    Status insertDocument(OperationContext* opCtx,
                           const NamespaceString& nss,
                           const BSONObj& doc) override {
-        return insertDocumentFn(txn, nss, doc);
+        return insertDocumentFn(opCtx, nss, doc);
     };
 
-    Status insertDocuments(OperationContext* txn,
+    Status insertDocuments(OperationContext* opCtx,
                            const NamespaceString& nss,
                            const std::vector<BSONObj>& docs) override {
-        return insertDocumentsFn(txn, nss, docs);
+        return insertDocumentsFn(opCtx, nss, docs);
     }
 
-    Status dropReplicatedDatabases(OperationContext* txn) override {
-        return dropUserDBsFn(txn);
+    Status dropReplicatedDatabases(OperationContext* opCtx) override {
+        return dropUserDBsFn(opCtx);
     };
 
-    Status createOplog(OperationContext* txn, const NamespaceString& nss) override {
-        return createOplogFn(txn, nss);
+    Status createOplog(OperationContext* opCtx, const NamespaceString& nss) override {
+        return createOplogFn(opCtx, nss);
     };
 
-    StatusWith<size_t> getOplogMaxSize(OperationContext* txn, const NamespaceString& nss) override {
+    StatusWith<size_t> getOplogMaxSize(OperationContext* opCtx,
+                                       const NamespaceString& nss) override {
         return 1024 * 1024 * 1024;
     }
 
-    Status createCollection(OperationContext* txn,
+    Status createCollection(OperationContext* opCtx,
                             const NamespaceString& nss,
                             const CollectionOptions& options) override {
-        return createCollFn(txn, nss, options);
+        return createCollFn(opCtx, nss, options);
     }
 
-    Status dropCollection(OperationContext* txn, const NamespaceString& nss) override {
-        return dropCollFn(txn, nss);
+    Status dropCollection(OperationContext* opCtx, const NamespaceString& nss) override {
+        return dropCollFn(opCtx, nss);
     };
 
-    StatusWith<std::vector<BSONObj>> findDocuments(OperationContext* txn,
+    StatusWith<std::vector<BSONObj>> findDocuments(OperationContext* opCtx,
                                                    const NamespaceString& nss,
                                                    boost::optional<StringData> indexName,
                                                    ScanDirection scanDirection,
                                                    const BSONObj& startKey,
                                                    BoundInclusion boundInclusion,
                                                    std::size_t limit) override {
-        return findDocumentsFn(txn, nss, indexName, scanDirection, startKey, boundInclusion, limit);
+        return findDocumentsFn(
+            opCtx, nss, indexName, scanDirection, startKey, boundInclusion, limit);
     }
 
-    StatusWith<std::vector<BSONObj>> deleteDocuments(OperationContext* txn,
+    StatusWith<std::vector<BSONObj>> deleteDocuments(OperationContext* opCtx,
                                                      const NamespaceString& nss,
                                                      boost::optional<StringData> indexName,
                                                      ScanDirection scanDirection,
@@ -196,11 +199,11 @@ public:
                                                      BoundInclusion boundInclusion,
                                                      std::size_t limit) override {
         return deleteDocumentsFn(
-            txn, nss, indexName, scanDirection, startKey, boundInclusion, limit);
+            opCtx, nss, indexName, scanDirection, startKey, boundInclusion, limit);
     }
 
-    Status isAdminDbValid(OperationContext* txn) override {
-        return isAdminDbValidFn(txn);
+    Status isAdminDbValid(OperationContext* opCtx) override {
+        return isAdminDbValidFn(opCtx);
     };
 
 
@@ -214,27 +217,27 @@ public:
         return Status{ErrorCodes::IllegalOperation, "CreateCollectionForBulkFn not implemented."};
     };
     InsertDocumentFn insertDocumentFn =
-        [](OperationContext* txn, const NamespaceString& nss, const BSONObj& doc) {
+        [](OperationContext* opCtx, const NamespaceString& nss, const BSONObj& doc) {
             return Status{ErrorCodes::IllegalOperation, "InsertDocumentFn not implemented."};
         };
     InsertDocumentsFn insertDocumentsFn =
-        [](OperationContext* txn, const NamespaceString& nss, const std::vector<BSONObj>& docs) {
+        [](OperationContext* opCtx, const NamespaceString& nss, const std::vector<BSONObj>& docs) {
             return Status{ErrorCodes::IllegalOperation, "InsertDocumentsFn not implemented."};
         };
-    DropUserDatabasesFn dropUserDBsFn = [](OperationContext* txn) {
+    DropUserDatabasesFn dropUserDBsFn = [](OperationContext* opCtx) {
         return Status{ErrorCodes::IllegalOperation, "DropUserDatabasesFn not implemented."};
     };
-    CreateOplogFn createOplogFn = [](OperationContext* txn, const NamespaceString& nss) {
+    CreateOplogFn createOplogFn = [](OperationContext* opCtx, const NamespaceString& nss) {
         return Status{ErrorCodes::IllegalOperation, "CreateOplogFn not implemented."};
     };
     CreateCollectionFn createCollFn =
-        [](OperationContext* txn, const NamespaceString& nss, const CollectionOptions& options) {
+        [](OperationContext* opCtx, const NamespaceString& nss, const CollectionOptions& options) {
             return Status{ErrorCodes::IllegalOperation, "CreateCollectionFn not implemented."};
         };
-    DropCollectionFn dropCollFn = [](OperationContext* txn, const NamespaceString& nss) {
+    DropCollectionFn dropCollFn = [](OperationContext* opCtx, const NamespaceString& nss) {
         return Status{ErrorCodes::IllegalOperation, "DropCollectionFn not implemented."};
     };
-    FindDocumentsFn findDocumentsFn = [](OperationContext* txn,
+    FindDocumentsFn findDocumentsFn = [](OperationContext* opCtx,
                                          const NamespaceString& nss,
                                          boost::optional<StringData> indexName,
                                          ScanDirection scanDirection,
@@ -243,7 +246,7 @@ public:
                                          std::size_t limit) {
         return Status{ErrorCodes::IllegalOperation, "FindOneFn not implemented."};
     };
-    DeleteDocumentsFn deleteDocumentsFn = [](OperationContext* txn,
+    DeleteDocumentsFn deleteDocumentsFn = [](OperationContext* opCtx,
                                              const NamespaceString& nss,
                                              boost::optional<StringData> indexName,
                                              ScanDirection scanDirection,
diff --git a/src/mongo/db/repl/sync_source_feedback.cpp b/src/mongo/db/repl/sync_source_feedback.cpp
index 2633e058e44..b8c41b1e1fd 100644
--- a/src/mongo/db/repl/sync_source_feedback.cpp
+++ b/src/mongo/db/repl/sync_source_feedback.cpp
@@ -52,9 +52,9 @@ namespace {
  * Calculates the keep alive interval based on the current configuration in the replication
  * coordinator.
  */
-Milliseconds calculateKeepAliveInterval(OperationContext* txn, stdx::mutex& mtx) {
+Milliseconds calculateKeepAliveInterval(OperationContext* opCtx, stdx::mutex& mtx) {
     stdx::lock_guard<stdx::mutex> lock(mtx);
-    auto replCoord = repl::ReplicationCoordinator::get(txn);
+    auto replCoord = repl::ReplicationCoordinator::get(opCtx);
     auto rsConfig = replCoord->getConfig();
     auto keepAliveInterval = rsConfig.getElectionTimeoutPeriod() / 2;
     return keepAliveInterval;
@@ -64,9 +64,9 @@ Milliseconds calculateKeepAliveInterval(OperationContext* txn, stdx::mutex& mtx)
  * Returns function to prepare update command
  */
 Reporter::PrepareReplSetUpdatePositionCommandFn makePrepareReplSetUpdatePositionCommandFn(
-    OperationContext* txn, const HostAndPort& syncTarget, BackgroundSync* bgsync) {
-    return [syncTarget, txn, bgsync](ReplicationCoordinator::ReplSetUpdatePositionCommandStyle
-                                         commandStyle) -> StatusWith<BSONObj> {
+    OperationContext* opCtx, const HostAndPort& syncTarget, BackgroundSync* bgsync) {
+    return [syncTarget, opCtx, bgsync](ReplicationCoordinator::ReplSetUpdatePositionCommandStyle
+                                           commandStyle) -> StatusWith<BSONObj> {
         auto currentSyncTarget = bgsync->getSyncTarget();
         if (currentSyncTarget != syncTarget) {
             if (currentSyncTarget.empty()) {
@@ -82,7 +82,7 @@ Reporter::PrepareReplSetUpdatePositionCommandFn makePrepareReplSetUpdatePosition
             }
         }
 
-        auto replCoord = repl::ReplicationCoordinator::get(txn);
+        auto replCoord = repl::ReplicationCoordinator::get(opCtx);
         if (replCoord->getMemberState().primary()) {
             // Primary has no one to send updates to.
             return Status(ErrorCodes::InvalidSyncSource,
@@ -149,10 +149,10 @@ void SyncSourceFeedback::run(executor::TaskExecutor* executor, BackgroundSync* b
     Milliseconds keepAliveInterval(0);
 
     while (true) {  // breaks once _shutdownSignaled is true
-        auto txn = cc().makeOperationContext();
+        auto opCtx = cc().makeOperationContext();
 
         if (keepAliveInterval == Milliseconds(0)) {
-            keepAliveInterval = calculateKeepAliveInterval(txn.get(), _mtx);
+            keepAliveInterval = calculateKeepAliveInterval(opCtx.get(), _mtx);
         }
 
         {
@@ -163,7 +163,7 @@ void SyncSourceFeedback::run(executor::TaskExecutor* executor, BackgroundSync* b
             while (!_positionChanged && !_shutdownSignaled) {
                 if (_cond.wait_for(lock, keepAliveInterval.toSystemDuration()) ==
                     stdx::cv_status::timeout) {
-                    MemberState state = ReplicationCoordinator::get(txn.get())->getMemberState();
+                    MemberState state = ReplicationCoordinator::get(opCtx.get())->getMemberState();
                     if (!(state.primary() || state.startup())) {
                         break;
                     }
@@ -179,7 +179,7 @@ void SyncSourceFeedback::run(executor::TaskExecutor* executor, BackgroundSync* b
 
         {
             stdx::lock_guard<stdx::mutex> lock(_mtx);
-            MemberState state = ReplicationCoordinator::get(txn.get())->getMemberState();
+            MemberState state = ReplicationCoordinator::get(opCtx.get())->getMemberState();
             if (state.primary() || state.startup()) {
                 continue;
             }
@@ -201,17 +201,18 @@ void SyncSourceFeedback::run(executor::TaskExecutor* executor, BackgroundSync* b
 
             // Update keepalive value from config.
             auto oldKeepAliveInterval = keepAliveInterval;
-            keepAliveInterval = calculateKeepAliveInterval(txn.get(), _mtx);
+            keepAliveInterval = calculateKeepAliveInterval(opCtx.get(), _mtx);
             if (oldKeepAliveInterval != keepAliveInterval) {
                 LOG(1) << "new syncSourceFeedback keep alive duration = " << keepAliveInterval
                        << " (previously " << oldKeepAliveInterval << ")";
             }
         }
 
-        Reporter reporter(executor,
-                          makePrepareReplSetUpdatePositionCommandFn(txn.get(), syncTarget, bgsync),
-                          syncTarget,
-                          keepAliveInterval);
+        Reporter reporter(
+            executor,
+            makePrepareReplSetUpdatePositionCommandFn(opCtx.get(), syncTarget, bgsync),
+            syncTarget,
+            keepAliveInterval);
         {
             stdx::lock_guard<stdx::mutex> lock(_mtx);
             if (_shutdownSignaled) {
diff --git a/src/mongo/db/repl/sync_tail.cpp b/src/mongo/db/repl/sync_tail.cpp
index 277df2f9a9d..8738b47d027 100644
--- a/src/mongo/db/repl/sync_tail.cpp
+++ b/src/mongo/db/repl/sync_tail.cpp
@@ -255,8 +255,8 @@ void ApplyBatchFinalizerForJournal::_run() {
             _latestOpTime = OpTime();
         }
 
-        auto txn = cc().makeOperationContext();
-        txn->recoveryUnit()->waitUntilDurable();
+        auto opCtx = cc().makeOperationContext();
+        opCtx->recoveryUnit()->waitUntilDurable();
         _recordDurable(latestOpTime);
     }
 }
@@ -276,19 +276,19 @@ std::unique_ptr<OldThreadPool> SyncTail::makeWriterPool() {
     return stdx::make_unique<OldThreadPool>(replWriterThreadCount, "repl writer worker ");
 }
 
-bool SyncTail::peek(OperationContext* txn, BSONObj* op) {
-    return _networkQueue->peek(txn, op);
+bool SyncTail::peek(OperationContext* opCtx, BSONObj* op) {
+    return _networkQueue->peek(opCtx, op);
 }
 
 // static
-Status SyncTail::syncApply(OperationContext* txn,
+Status SyncTail::syncApply(OperationContext* opCtx,
                            const BSONObj& op,
                            bool inSteadyStateReplication,
                            ApplyOperationInLockFn applyOperationInLock,
                            ApplyCommandInLockFn applyCommandInLock,
                            IncrementOpsAppliedStatsFn incrementOpsAppliedStats) {
     // Count each log op application as a separate operation, for reporting purposes
-    CurOp individualOp(txn);
+    CurOp individualOp(opCtx);
 
     const char* ns = op.getStringField("ns");
     verify(ns);
@@ -312,24 +312,24 @@ Status SyncTail::syncApply(OperationContext* txn,
         MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
             // a command may need a global write lock. so we will conservatively go
             // ahead and grab one here. suboptimal. :-(
-            Lock::GlobalWrite globalWriteLock(txn->lockState());
+            Lock::GlobalWrite globalWriteLock(opCtx->lockState());
 
             // special case apply for commands to avoid implicit database creation
-            Status status = applyCommandInLock(txn, op, inSteadyStateReplication);
+            Status status = applyCommandInLock(opCtx, op, inSteadyStateReplication);
             incrementOpsAppliedStats();
             return status;
         }
-        MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "syncApply_command", ns);
+        MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "syncApply_command", ns);
     }
 
     auto applyOp = [&](Database* db) {
         // For non-initial-sync, we convert updates to upserts
         // to suppress errors when replaying oplog entries.
-        txn->setReplicatedWrites(false);
-        DisableDocumentValidation validationDisabler(txn);
+        opCtx->setReplicatedWrites(false);
+        DisableDocumentValidation validationDisabler(opCtx);
 
         Status status =
-            applyOperationInLock(txn, db, op, inSteadyStateReplication, incrementOpsAppliedStats);
+            applyOperationInLock(opCtx, db, op, inSteadyStateReplication, incrementOpsAppliedStats);
         if (!status.isOK() && status.code() == ErrorCodes::WriteConflict) {
             throw WriteConflictException();
         }
@@ -339,11 +339,11 @@ Status SyncTail::syncApply(OperationContext* txn,
     if (isNoOp || (opType[0] == 'i' && nsToCollectionSubstring(ns) == "system.indexes")) {
         auto opStr = isNoOp ? "syncApply_noop" : "syncApply_indexBuild";
         MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
-            Lock::DBLock dbLock(txn->lockState(), nsToDatabaseSubstring(ns), MODE_X);
-            OldClientContext ctx(txn, ns);
+            Lock::DBLock dbLock(opCtx->lockState(), nsToDatabaseSubstring(ns), MODE_X);
+            OldClientContext ctx(opCtx, ns);
             return applyOp(ctx.db());
         }
-        MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, opStr, ns);
+        MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, opStr, ns);
     }
 
     if (isCrudOpType(opType)) {
@@ -361,29 +361,29 @@ Status SyncTail::syncApply(OperationContext* txn,
                 // drop the DB lock before acquiring
                 // the upgraded one.
                 dbLock.reset();
-                dbLock.reset(new Lock::DBLock(txn->lockState(), dbName, mode));
-                collectionLock.reset(new Lock::CollectionLock(txn->lockState(), ns, mode));
+                dbLock.reset(new Lock::DBLock(opCtx->lockState(), dbName, mode));
+                collectionLock.reset(new Lock::CollectionLock(opCtx->lockState(), ns, mode));
             };
 
             resetLocks(MODE_IX);
-            if (!dbHolder().get(txn, dbName)) {
+            if (!dbHolder().get(opCtx, dbName)) {
                 // Need to create database, so reset lock to stronger mode.
                 resetLocks(MODE_X);
-                ctx.reset(new OldClientContext(txn, ns));
+                ctx.reset(new OldClientContext(opCtx, ns));
             } else {
-                ctx.reset(new OldClientContext(txn, ns));
+                ctx.reset(new OldClientContext(opCtx, ns));
                 if (!ctx->db()->getCollection(ns)) {
                     // Need to implicitly create collection.  This occurs for 'u' opTypes,
                     // but not for 'i' nor 'd'.
                     ctx.reset();
                     resetLocks(MODE_X);
-                    ctx.reset(new OldClientContext(txn, ns));
+                    ctx.reset(new OldClientContext(opCtx, ns));
                 }
             }
 
             return applyOp(ctx->db());
         }
-        MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "syncApply_CRUD", ns);
+        MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "syncApply_CRUD", ns);
     }
 
     // unknown opType
@@ -393,10 +393,10 @@ Status SyncTail::syncApply(OperationContext* txn,
     return Status(ErrorCodes::BadValue, ss);
 }
 
-Status SyncTail::syncApply(OperationContext* txn,
+Status SyncTail::syncApply(OperationContext* opCtx,
                            const BSONObj& op,
                            bool inSteadyStateReplication) {
-    return SyncTail::syncApply(txn,
+    return SyncTail::syncApply(opCtx,
                                op,
                                inSteadyStateReplication,
                                applyOperation_inlock,
@@ -416,12 +416,12 @@ void prefetchOp(const BSONObj& op) {
         try {
             // one possible tweak here would be to stay in the read lock for this database
             // for multiple prefetches if they are for the same database.
-            const ServiceContext::UniqueOperationContext txnPtr = cc().makeOperationContext();
-            OperationContext& txn = *txnPtr;
-            AutoGetCollectionForRead ctx(&txn, NamespaceString(ns));
+            const ServiceContext::UniqueOperationContext opCtxPtr = cc().makeOperationContext();
+            OperationContext& opCtx = *opCtxPtr;
+            AutoGetCollectionForRead ctx(&opCtx, NamespaceString(ns));
             Database* db = ctx.getDb();
             if (db) {
-                prefetchPagesForReplicatedOp(&txn, db, op);
+                prefetchPagesForReplicatedOp(&opCtx, db, op);
             }
         } catch (const DBException& e) {
             LOG(2) << "ignoring exception in prefetchOp(): " << redact(e) << endl;
@@ -468,7 +468,7 @@ void initializeWriterThread() {
 
 // Schedules the writes to the oplog for 'ops' into threadPool. The caller must guarantee that 'ops'
 // stays valid until all scheduled work in the thread pool completes.
-void scheduleWritesToOplog(OperationContext* txn,
+void scheduleWritesToOplog(OperationContext* opCtx,
                            OldThreadPool* threadPool,
                            const MultiApplier::Operations& ops) {
 
@@ -479,9 +479,9 @@ void scheduleWritesToOplog(OperationContext* txn,
         return [&ops, begin, end] {
             initializeWriterThread();
             const auto txnHolder = cc().makeOperationContext();
-            const auto txn = txnHolder.get();
-            txn->lockState()->setShouldConflictWithSecondaryBatchApplication(false);
-            txn->setReplicatedWrites(false);
+            const auto opCtx = txnHolder.get();
+            opCtx->lockState()->setShouldConflictWithSecondaryBatchApplication(false);
+            opCtx->setReplicatedWrites(false);
 
             std::vector<BSONObj> docs;
             docs.reserve(end - begin);
@@ -492,8 +492,8 @@ void scheduleWritesToOplog(OperationContext* txn,
             }
 
             fassertStatusOK(40141,
-                            StorageInterface::get(txn)->insertDocuments(
-                                txn, NamespaceString(rsOplogName), docs));
+                            StorageInterface::get(opCtx)->insertDocuments(
+                                opCtx, NamespaceString(rsOplogName), docs));
         };
     };
 
@@ -509,7 +509,7 @@ void scheduleWritesToOplog(OperationContext* txn,
     // there would be no way to take advantage of multiple threads if a storage engine doesn't
     // support document locking.
     if (!enoughToMultiThread ||
-        !txn->getServiceContext()->getGlobalStorageEngine()->supportsDocLocking()) {
+        !opCtx->getServiceContext()->getGlobalStorageEngine()->supportsDocLocking()) {
 
         threadPool->schedule(makeOplogWriterForRange(0, ops.size()));
         return;
@@ -536,24 +536,24 @@ public:
         const CollatorInterface* collator = nullptr;
     };
 
-    CollectionProperties getCollectionProperties(OperationContext* txn,
+    CollectionProperties getCollectionProperties(OperationContext* opCtx,
                                                  const StringMapTraits::HashedKey& ns) {
         auto it = _cache.find(ns);
         if (it != _cache.end()) {
             return it->second;
         }
 
-        auto collProperties = getCollectionPropertiesImpl(txn, ns.key());
+        auto collProperties = getCollectionPropertiesImpl(opCtx, ns.key());
         _cache[ns] = collProperties;
         return collProperties;
     }
 
 private:
-    CollectionProperties getCollectionPropertiesImpl(OperationContext* txn, StringData ns) {
+    CollectionProperties getCollectionPropertiesImpl(OperationContext* opCtx, StringData ns) {
         CollectionProperties collProperties;
 
-        Lock::DBLock dbLock(txn->lockState(), nsToDatabaseSubstring(ns), MODE_IS);
-        auto db = dbHolder().get(txn, ns);
+        Lock::DBLock dbLock(opCtx->lockState(), nsToDatabaseSubstring(ns), MODE_IS);
+        auto db = dbHolder().get(opCtx, ns);
         if (!db) {
             return collProperties;
         }
@@ -573,7 +573,7 @@ private:
 
 // This only modifies the isForCappedCollection field on each op. It does not alter the ops vector
 // in any other way.
-void fillWriterVectors(OperationContext* txn,
+void fillWriterVectors(OperationContext* opCtx,
                        MultiApplier::Operations* ops,
                        std::vector<MultiApplier::OperationPtrs>* writerVectors) {
     const bool supportsDocLocking =
@@ -587,7 +587,7 @@ void fillWriterVectors(OperationContext* txn,
         uint32_t hash = hashedNs.hash();
 
         if (op.isCrudOpType()) {
-            auto collProperties = collPropertiesCache.getCollectionProperties(txn, hashedNs);
+            auto collProperties = collPropertiesCache.getCollectionProperties(opCtx, hashedNs);
 
             // For doc locking engines, include the _id of the document in the hash so we get
             // parallelism even if all writes are to a single collection.
@@ -620,7 +620,7 @@ void fillWriterVectors(OperationContext* txn,
 
 // Applies a batch of oplog entries, by using a set of threads to apply the operations and then
 // writes the oplog entries to the local oplog.
-OpTime SyncTail::multiApply(OperationContext* txn, MultiApplier::Operations ops) {
+OpTime SyncTail::multiApply(OperationContext* opCtx, MultiApplier::Operations ops) {
     auto applyOperation = [this](MultiApplier::OperationPtrs* ops) -> Status {
         _applyFunc(ops, this);
         // This function is used by 3.2 initial sync and steady state data replication.
@@ -628,11 +628,11 @@ OpTime SyncTail::multiApply(OperationContext* txn, MultiApplier::Operations ops)
         return Status::OK();
     };
     return fassertStatusOK(
-        34437, repl::multiApply(txn, _writerPool.get(), std::move(ops), applyOperation));
+        34437, repl::multiApply(opCtx, _writerPool.get(), std::move(ops), applyOperation));
 }
 
 namespace {
-void tryToGoLiveAsASecondary(OperationContext* txn, ReplicationCoordinator* replCoord) {
+void tryToGoLiveAsASecondary(OperationContext* opCtx, ReplicationCoordinator* replCoord) {
     if (replCoord->isInPrimaryOrSecondaryState()) {
         return;
     }
@@ -640,8 +640,8 @@ void tryToGoLiveAsASecondary(OperationContext* txn, ReplicationCoordinator* repl
     // This needs to happen after the attempt so readers can be sure we've already tried.
     ON_BLOCK_EXIT([] { attemptsToBecomeSecondary.increment(); });
 
-    ScopedTransaction transaction(txn, MODE_S);
-    Lock::GlobalRead readLock(txn->lockState());
+    ScopedTransaction transaction(opCtx, MODE_S);
+    Lock::GlobalRead readLock(opCtx->lockState());
 
     if (replCoord->getMaintenanceMode()) {
         LOG(1) << "Can't go live (tryToGoLiveAsASecondary) as maintenance mode is active.";
@@ -657,7 +657,7 @@ void tryToGoLiveAsASecondary(OperationContext* txn, ReplicationCoordinator* repl
     }
 
     // We can't go to SECONDARY until we reach minvalid.
-    if (replCoord->getMyLastAppliedOpTime() < StorageInterface::get(txn)->getMinValid(txn)) {
+    if (replCoord->getMyLastAppliedOpTime() < StorageInterface::get(opCtx)->getMinValid(opCtx)) {
         return;
     }
 
@@ -697,13 +697,13 @@ public:
 private:
     void run() {
         Client::initThread("ReplBatcher");
-        const ServiceContext::UniqueOperationContext txnPtr = cc().makeOperationContext();
-        OperationContext& txn = *txnPtr;
-        const auto replCoord = ReplicationCoordinator::get(&txn);
-        const auto fastClockSource = txn.getServiceContext()->getFastClockSource();
+        const ServiceContext::UniqueOperationContext opCtxPtr = cc().makeOperationContext();
+        OperationContext& opCtx = *opCtxPtr;
+        const auto replCoord = ReplicationCoordinator::get(&opCtx);
+        const auto fastClockSource = opCtx.getServiceContext()->getFastClockSource();
         const auto oplogMaxSize = fassertStatusOK(
             40301,
-            StorageInterface::get(&txn)->getOplogMaxSize(&txn, NamespaceString(rsOplogName)));
+            StorageInterface::get(&opCtx)->getOplogMaxSize(&opCtx, NamespaceString(rsOplogName)));
 
         // Batches are limited to 10% of the oplog.
         BatchLimits batchLimits;
@@ -720,7 +720,7 @@ private:
 
             OpQueue ops;
             // tryPopAndWaitForMore adds to ops and returns true when we need to end a batch early.
-            while (!_syncTail->tryPopAndWaitForMore(&txn, &ops, batchLimits)) {
+            while (!_syncTail->tryPopAndWaitForMore(&opCtx, &ops, batchLimits)) {
             }
 
             if (ops.empty() && !ops.mustShutdown()) {
@@ -755,8 +755,8 @@ private:
 void SyncTail::oplogApplication(ReplicationCoordinator* replCoord) {
     OpQueueBatcher batcher(this);
 
-    const ServiceContext::UniqueOperationContext txnPtr = cc().makeOperationContext();
-    OperationContext& txn = *txnPtr;
+    const ServiceContext::UniqueOperationContext opCtxPtr = cc().makeOperationContext();
+    OperationContext& opCtx = *opCtxPtr;
     std::unique_ptr<ApplyBatchFinalizer> finalizer{
         getGlobalServiceContext()->getGlobalStorageEngine()->isDurable()
             ? new ApplyBatchFinalizerForJournal(replCoord)
@@ -774,7 +774,7 @@ void SyncTail::oplogApplication(ReplicationCoordinator* replCoord) {
             sleepmillis(10);
         }
 
-        tryToGoLiveAsASecondary(&txn, replCoord);
+        tryToGoLiveAsASecondary(&opCtx, replCoord);
 
         long long termWhenBufferIsEmpty = replCoord->getTerm();
         // Blocks up to a second waiting for a batch to be ready to apply. If one doesn't become
@@ -788,7 +788,7 @@ void SyncTail::oplogApplication(ReplicationCoordinator* replCoord) {
                 continue;
             }
             // Signal drain complete if we're in Draining state and the buffer is empty.
-            replCoord->signalDrainComplete(&txn, termWhenBufferIsEmpty);
+            replCoord->signalDrainComplete(&opCtx, termWhenBufferIsEmpty);
             continue;  // Try again.
         }
 
@@ -813,13 +813,13 @@ void SyncTail::oplogApplication(ReplicationCoordinator* replCoord) {
         stdx::lock_guard<SimpleMutex> fsynclk(filesLockedFsync);
 
         // Do the work.
-        multiApply(&txn, ops.releaseBatch());
+        multiApply(&opCtx, ops.releaseBatch());
 
         // Update various things that care about our last applied optime. Tests rely on 2 happening
         // before 3 even though it isn't strictly necessary. The order of 1 doesn't matter.
-        setNewTimestamp(txn.getServiceContext(), lastOpTimeInBatch.getTimestamp());  // 1
-        StorageInterface::get(&txn)->setAppliedThrough(&txn, lastOpTimeInBatch);     // 2
-        finalizer->record(lastOpTimeInBatch);                                        // 3
+        setNewTimestamp(opCtx.getServiceContext(), lastOpTimeInBatch.getTimestamp());  // 1
+        StorageInterface::get(&opCtx)->setAppliedThrough(&opCtx, lastOpTimeInBatch);   // 2
+        finalizer->record(lastOpTimeInBatch);                                          // 3
     }
 }
 
@@ -830,13 +830,13 @@ void SyncTail::oplogApplication(ReplicationCoordinator* replCoord) {
 // This function also blocks 1 second waiting for new ops to appear in the bgsync
 // queue.  We don't block forever so that we can periodically check for things like shutdown or
 // reconfigs.
-bool SyncTail::tryPopAndWaitForMore(OperationContext* txn,
+bool SyncTail::tryPopAndWaitForMore(OperationContext* opCtx,
                                     SyncTail::OpQueue* ops,
                                     const BatchLimits& limits) {
     {
         BSONObj op;
         // Check to see if there are ops waiting in the bgsync queue
-        bool peek_success = peek(txn, &op);
+        bool peek_success = peek(opCtx, &op);
         if (!peek_success) {
             // If we don't have anything in the queue, wait a bit for something to appear.
             if (ops->empty()) {
@@ -908,7 +908,7 @@ bool SyncTail::tryPopAndWaitForMore(OperationContext* txn,
         (!entry.ns.empty() && nsToCollectionSubstring(entry.ns) == "system.indexes")) {
         if (ops->getCount() == 1) {
             // apply commands one-at-a-time
-            _networkQueue->consume(txn);
+            _networkQueue->consume(opCtx);
         } else {
             // This op must be processed alone, but we already had ops in the queue so we can't
             // include it in this batch. Since we didn't call consume(), we'll see this again next
@@ -921,7 +921,7 @@ bool SyncTail::tryPopAndWaitForMore(OperationContext* txn,
     }
 
     // We are going to apply this Op.
-    _networkQueue->consume(txn);
+    _networkQueue->consume(opCtx);
 
     // Go back for more ops, unless we've hit the limit.
     return ops->getCount() >= limits.ops;
@@ -935,7 +935,7 @@ OldThreadPool* SyncTail::getWriterPool() {
     return _writerPool.get();
 }
 
-BSONObj SyncTail::getMissingDoc(OperationContext* txn, Database* db, const BSONObj& o) {
+BSONObj SyncTail::getMissingDoc(OperationContext* opCtx, Database* db, const BSONObj& o) {
     OplogReader missingObjReader;  // why are we using OplogReader to run a non-oplog query?
     const char* ns = o.getStringField("ns");
 
@@ -1004,18 +1004,18 @@ BSONObj SyncTail::getMissingDoc(OperationContext* txn, Database* db, const BSONO
                 str::stream() << "Can no longer connect to initial sync source: " << _hostname);
 }
 
-bool SyncTail::shouldRetry(OperationContext* txn, const BSONObj& o) {
+bool SyncTail::shouldRetry(OperationContext* opCtx, const BSONObj& o) {
     const NamespaceString nss(o.getStringField("ns"));
     MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
         // Take an X lock on the database in order to preclude other modifications.
         // Also, the database might not exist yet, so create it.
-        AutoGetOrCreateDb autoDb(txn, nss.db(), MODE_X);
+        AutoGetOrCreateDb autoDb(opCtx, nss.db(), MODE_X);
         Database* const db = autoDb.getDb();
 
         // we don't have the object yet, which is possible on initial sync.  get it.
         log() << "adding missing object" << endl;  // rare enough we can log
 
-        BSONObj missingObj = getMissingDoc(txn, db, o);
+        BSONObj missingObj = getMissingDoc(opCtx, db, o);
 
         if (missingObj.isEmpty()) {
             log() << "missing object not found on source."
@@ -1025,13 +1025,13 @@ bool SyncTail::shouldRetry(OperationContext* txn, const BSONObj& o) {
 
             return false;
         } else {
-            WriteUnitOfWork wunit(txn);
+            WriteUnitOfWork wunit(opCtx);
 
-            Collection* const coll = db->getOrCreateCollection(txn, nss.toString());
+            Collection* const coll = db->getOrCreateCollection(opCtx, nss.toString());
             invariant(coll);
 
             OpDebug* const nullOpDebug = nullptr;
-            Status status = coll->insertDocument(txn, missingObj, nullOpDebug, true);
+            Status status = coll->insertDocument(opCtx, missingObj, nullOpDebug, true);
             uassert(15917,
                     str::stream() << "failed to insert missing doc: " << status.toString(),
                     status.isOK());
@@ -1042,7 +1042,7 @@ bool SyncTail::shouldRetry(OperationContext* txn, const BSONObj& o) {
             return true;
         }
     }
-    MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "InsertRetry", nss.ns());
+    MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "InsertRetry", nss.ns());
 
     // fixes compile errors on GCC - see SERVER-18219 for details
     MONGO_UNREACHABLE;
@@ -1051,22 +1051,22 @@ bool SyncTail::shouldRetry(OperationContext* txn, const BSONObj& o) {
 // This free function is used by the writer threads to apply each op
 void multiSyncApply(MultiApplier::OperationPtrs* ops, SyncTail*) {
     initializeWriterThread();
-    auto txn = cc().makeOperationContext();
-    auto syncApply = [](OperationContext* txn, const BSONObj& op, bool inSteadyStateReplication) {
-        return SyncTail::syncApply(txn, op, inSteadyStateReplication);
+    auto opCtx = cc().makeOperationContext();
+    auto syncApply = [](OperationContext* opCtx, const BSONObj& op, bool inSteadyStateReplication) {
+        return SyncTail::syncApply(opCtx, op, inSteadyStateReplication);
     };
 
-    fassertNoTrace(16359, multiSyncApply_noAbort(txn.get(), ops, syncApply));
+    fassertNoTrace(16359, multiSyncApply_noAbort(opCtx.get(), ops, syncApply));
 }
 
-Status multiSyncApply_noAbort(OperationContext* txn,
+Status multiSyncApply_noAbort(OperationContext* opCtx,
                               MultiApplier::OperationPtrs* oplogEntryPointers,
                               SyncApplyFn syncApply) {
-    txn->setReplicatedWrites(false);
-    DisableDocumentValidation validationDisabler(txn);
+    opCtx->setReplicatedWrites(false);
+    DisableDocumentValidation validationDisabler(opCtx);
 
     // allow us to get through the magic barrier
-    txn->lockState()->setShouldConflictWithSecondaryBatchApplication(false);
+    opCtx->lockState()->setShouldConflictWithSecondaryBatchApplication(false);
 
     if (oplogEntryPointers->size() > 1) {
         std::stable_sort(oplogEntryPointers->begin(),
@@ -1125,7 +1125,7 @@ Status multiSyncApply_noAbort(OperationContext* txn,
                 try {
                     // Apply the group of inserts.
                     uassertStatusOK(
-                        syncApply(txn, groupedInsertBuilder.done(), inSteadyStateReplication));
+                        syncApply(opCtx, groupedInsertBuilder.done(), inSteadyStateReplication));
                     // It succeeded, advance the oplogEntriesIterator to the end of the
                     // group of inserts.
                     oplogEntriesIterator = endOfGroupableOpsIterator - 1;
@@ -1145,7 +1145,7 @@ Status multiSyncApply_noAbort(OperationContext* txn,
 
         try {
             // Apply an individual (non-grouped) op.
-            const Status status = syncApply(txn, entry->raw, inSteadyStateReplication);
+            const Status status = syncApply(opCtx, entry->raw, inSteadyStateReplication);
 
             if (!status.isOK()) {
                 severe() << "Error applying operation (" << redact(entry->raw)
@@ -1165,28 +1165,28 @@ Status multiSyncApply_noAbort(OperationContext* txn,
 // This free function is used by the initial sync writer threads to apply each op
 void multiInitialSyncApply_abortOnFailure(MultiApplier::OperationPtrs* ops, SyncTail* st) {
     initializeWriterThread();
-    auto txn = cc().makeOperationContext();
+    auto opCtx = cc().makeOperationContext();
     AtomicUInt32 fetchCount(0);
-    fassertNoTrace(15915, multiInitialSyncApply_noAbort(txn.get(), ops, st, &fetchCount));
+    fassertNoTrace(15915, multiInitialSyncApply_noAbort(opCtx.get(), ops, st, &fetchCount));
 }
 
 Status multiInitialSyncApply(MultiApplier::OperationPtrs* ops,
                              SyncTail* st,
                              AtomicUInt32* fetchCount) {
     initializeWriterThread();
-    auto txn = cc().makeOperationContext();
-    return multiInitialSyncApply_noAbort(txn.get(), ops, st, fetchCount);
+    auto opCtx = cc().makeOperationContext();
+    return multiInitialSyncApply_noAbort(opCtx.get(), ops, st, fetchCount);
 }
 
-Status multiInitialSyncApply_noAbort(OperationContext* txn,
+Status multiInitialSyncApply_noAbort(OperationContext* opCtx,
                                      MultiApplier::OperationPtrs* ops,
                                      SyncTail* st,
                                      AtomicUInt32* fetchCount) {
-    txn->setReplicatedWrites(false);
-    DisableDocumentValidation validationDisabler(txn);
+    opCtx->setReplicatedWrites(false);
+    DisableDocumentValidation validationDisabler(opCtx);
 
     // allow us to get through the magic barrier
-    txn->lockState()->setShouldConflictWithSecondaryBatchApplication(false);
+    opCtx->lockState()->setShouldConflictWithSecondaryBatchApplication(false);
 
     // This function is only called in initial sync, as its name suggests.
     const bool inSteadyStateReplication = false;
@@ -1194,7 +1194,7 @@ Status multiInitialSyncApply_noAbort(OperationContext* txn,
     for (auto it = ops->begin(); it != ops->end(); ++it) {
         auto& entry = **it;
         try {
-            const Status s = SyncTail::syncApply(txn, entry.raw, inSteadyStateReplication);
+            const Status s = SyncTail::syncApply(opCtx, entry.raw, inSteadyStateReplication);
             if (!s.isOK()) {
                 // Don't retry on commands.
                 if (entry.isCommand()) {
@@ -1205,8 +1205,9 @@ Status multiInitialSyncApply_noAbort(OperationContext* txn,
 
                 // We might need to fetch the missing docs from the sync source.
                 fetchCount->fetchAndAdd(1);
-                if (st->shouldRetry(txn, entry.raw)) {
-                    const Status s2 = SyncTail::syncApply(txn, entry.raw, inSteadyStateReplication);
+                if (st->shouldRetry(opCtx, entry.raw)) {
+                    const Status s2 =
+                        SyncTail::syncApply(opCtx, entry.raw, inSteadyStateReplication);
                     if (!s2.isOK()) {
                         severe() << "Error applying operation (" << redact(entry.raw)
                                  << "): " << redact(s2);
@@ -1234,11 +1235,11 @@ Status multiInitialSyncApply_noAbort(OperationContext* txn,
     return Status::OK();
 }
 
-StatusWith<OpTime> multiApply(OperationContext* txn,
+StatusWith<OpTime> multiApply(OperationContext* opCtx,
                               OldThreadPool* workerPool,
                               MultiApplier::Operations ops,
                               MultiApplier::ApplyOperationFn applyOperation) {
-    if (!txn) {
+    if (!opCtx) {
         return {ErrorCodes::BadValue, "invalid operation context"};
     }
 
@@ -1259,14 +1260,14 @@ StatusWith<OpTime> multiApply(OperationContext* txn,
         prefetchOps(ops, workerPool);
     }
 
-    auto storage = StorageInterface::get(txn);
+    auto storage = StorageInterface::get(opCtx);
 
     LOG(2) << "replication batch size is " << ops.size();
     // Stop all readers until we're done. This also prevents doc-locking engines from deleting old
     // entries from the oplog until we finish writing.
-    Lock::ParallelBatchWriterMode pbwm(txn->lockState());
+    Lock::ParallelBatchWriterMode pbwm(opCtx->lockState());
 
-    auto replCoord = ReplicationCoordinator::get(txn);
+    auto replCoord = ReplicationCoordinator::get(opCtx);
     if (replCoord->getApplierState() == ReplicationCoordinator::ApplierState::Stopped) {
         severe() << "attempting to replicate ops while primary";
         return {ErrorCodes::CannotApplyOplogWhilePrimary,
@@ -1280,14 +1281,14 @@ StatusWith<OpTime> multiApply(OperationContext* txn,
         std::vector<MultiApplier::OperationPtrs> writerVectors(workerPool->getNumThreads());
         ON_BLOCK_EXIT([&] { workerPool->join(); });
 
-        storage->setOplogDeleteFromPoint(txn, ops.front().ts.timestamp());
-        scheduleWritesToOplog(txn, workerPool, ops);
-        fillWriterVectors(txn, &ops, &writerVectors);
+        storage->setOplogDeleteFromPoint(opCtx, ops.front().ts.timestamp());
+        scheduleWritesToOplog(opCtx, workerPool, ops);
+        fillWriterVectors(opCtx, &ops, &writerVectors);
 
         workerPool->join();
 
-        storage->setOplogDeleteFromPoint(txn, Timestamp());
-        storage->setMinValidToAtLeast(txn, ops.back().getOpTime());
+        storage->setOplogDeleteFromPoint(opCtx, Timestamp());
+        storage->setMinValidToAtLeast(opCtx, ops.back().getOpTime());
 
         applyOps(writerVectors, workerPool, applyOperation, &statusVector);
     }
diff --git a/src/mongo/db/repl/sync_tail.h b/src/mongo/db/repl/sync_tail.h
index 98485782868..1f4aa0e12c4 100644
--- a/src/mongo/db/repl/sync_tail.h
+++ b/src/mongo/db/repl/sync_tail.h
@@ -70,7 +70,7 @@ public:
      * 'opCounter' is used to update server status metrics.
      * Returns failure status if the op was an update that could not be applied.
      */
-    using ApplyOperationInLockFn = stdx::function<Status(OperationContext* txn,
+    using ApplyOperationInLockFn = stdx::function<Status(OperationContext* opCtx,
                                                          Database* db,
                                                          const BSONObj& opObj,
                                                          bool inSteadyStateReplication,
@@ -100,17 +100,19 @@ public:
      * Functions for applying operations/commands and increment server status counters may
      * be overridden for testing.
      */
-    static Status syncApply(OperationContext* txn,
+    static Status syncApply(OperationContext* opCtx,
                             const BSONObj& o,
                             bool inSteadyStateReplication,
                             ApplyOperationInLockFn applyOperationInLock,
                             ApplyCommandInLockFn applyCommandInLock,
                             IncrementOpsAppliedStatsFn incrementOpsAppliedStats);
 
-    static Status syncApply(OperationContext* txn, const BSONObj& o, bool inSteadyStateReplication);
+    static Status syncApply(OperationContext* opCtx,
+                            const BSONObj& o,
+                            bool inSteadyStateReplication);
 
     void oplogApplication(ReplicationCoordinator* replCoord);
-    bool peek(OperationContext* txn, BSONObj* obj);
+    bool peek(OperationContext* opCtx, BSONObj* obj);
 
     class OpQueue {
     public:
@@ -195,17 +197,17 @@ public:
      * If ops is empty on entry and nothing can be added yet, will wait up to a second before
      * returning true.
      */
-    bool tryPopAndWaitForMore(OperationContext* txn, OpQueue* ops, const BatchLimits& limits);
+    bool tryPopAndWaitForMore(OperationContext* opCtx, OpQueue* ops, const BatchLimits& limits);
 
     /**
      * Fetch a single document referenced in the operation from the sync source.
      */
-    virtual BSONObj getMissingDoc(OperationContext* txn, Database* db, const BSONObj& o);
+    virtual BSONObj getMissingDoc(OperationContext* opCtx, Database* db, const BSONObj& o);
 
     /**
      * If applyOperation_inlock should be called again after an update fails.
      */
-    virtual bool shouldRetry(OperationContext* txn, const BSONObj& o);
+    virtual bool shouldRetry(OperationContext* opCtx, const BSONObj& o);
     void setHostname(const std::string& hostname);
 
     /**
@@ -222,7 +224,7 @@ protected:
 
     // Apply a batch of operations, using multiple threads.
     // Returns the last OpTime applied during the apply batch, ops.end["ts"] basically.
-    OpTime multiApply(OperationContext* txn, MultiApplier::Operations ops);
+    OpTime multiApply(OperationContext* opCtx, MultiApplier::Operations ops);
 
 private:
     class OpQueueBatcher;
@@ -247,7 +249,7 @@ private:
  *
  * Shared between here and MultiApplier.
  */
-StatusWith<OpTime> multiApply(OperationContext* txn,
+StatusWith<OpTime> multiApply(OperationContext* opCtx,
                               OldThreadPool* workerPool,
                               MultiApplier::Operations ops,
                               MultiApplier::ApplyOperationFn applyOperation);
@@ -271,9 +273,9 @@ Status multiInitialSyncApply(MultiApplier::OperationPtrs* ops,
  * Accepts an external operation context and a function with the same argument list as
  * SyncTail::syncApply.
  */
-using SyncApplyFn =
-    stdx::function<Status(OperationContext* txn, const BSONObj& o, bool inSteadyStateReplication)>;
-Status multiSyncApply_noAbort(OperationContext* txn,
+using SyncApplyFn = stdx::function<Status(
+    OperationContext* opCtx, const BSONObj& o, bool inSteadyStateReplication)>;
+Status multiSyncApply_noAbort(OperationContext* opCtx,
                               MultiApplier::OperationPtrs* ops,
                               SyncApplyFn syncApply);
 
@@ -281,7 +283,7 @@ Status multiSyncApply_noAbort(OperationContext* txn,
  * Testing-only version of multiInitialSyncApply that accepts an external operation context and
  * returns an error instead of aborting.
  */
-Status multiInitialSyncApply_noAbort(OperationContext* txn,
+Status multiInitialSyncApply_noAbort(OperationContext* opCtx,
                                      MultiApplier::OperationPtrs* ops,
                                      SyncTail* st,
                                      AtomicUInt32* fetchCount);
diff --git a/src/mongo/db/repl/sync_tail_test.cpp b/src/mongo/db/repl/sync_tail_test.cpp
index b6946a4edc2..b1e62a2efa5 100644
--- a/src/mongo/db/repl/sync_tail_test.cpp
+++ b/src/mongo/db/repl/sync_tail_test.cpp
@@ -69,7 +69,7 @@ using namespace mongo::repl;
 class SyncTailTest : public ServiceContextMongoDTest {
 protected:
     void _testSyncApplyInsertDocument(LockMode expectedMode);
-    ServiceContext::UniqueOperationContext _txn;
+    ServiceContext::UniqueOperationContext _opCtx;
     unsigned int _opsApplied;
     SyncTail::ApplyOperationInLockFn _applyOp;
     SyncTail::ApplyCommandInLockFn _applyCmd;
@@ -91,7 +91,7 @@ protected:
 class SyncTailWithLocalDocumentFetcher : public SyncTail {
 public:
     SyncTailWithLocalDocumentFetcher(const BSONObj& document);
-    BSONObj getMissingDoc(OperationContext* txn, Database* db, const BSONObj& o) override;
+    BSONObj getMissingDoc(OperationContext* opCtx, Database* db, const BSONObj& o) override;
 
 private:
     BSONObj _document;
@@ -103,7 +103,7 @@ private:
 class SyncTailWithOperationContextChecker : public SyncTail {
 public:
     SyncTailWithOperationContextChecker();
-    bool shouldRetry(OperationContext* txn, const BSONObj& o) override;
+    bool shouldRetry(OperationContext* opCtx, const BSONObj& o) override;
 };
 
 void SyncTailTest::setUp() {
@@ -122,19 +122,19 @@ void SyncTailTest::setUp() {
                                              const std::vector<BSONObj>&) { return Status::OK(); };
     StorageInterface::set(service, std::move(storageInterface));
 
-    _txn = cc().makeOperationContext();
+    _opCtx = cc().makeOperationContext();
     _opsApplied = 0;
-    _applyOp = [](OperationContext* txn,
+    _applyOp = [](OperationContext* opCtx,
                   Database* db,
                   const BSONObj& op,
                   bool inSteadyStateReplication,
                   stdx::function<void()>) { return Status::OK(); };
-    _applyCmd = [](OperationContext* txn, const BSONObj& op, bool) { return Status::OK(); };
+    _applyCmd = [](OperationContext* opCtx, const BSONObj& op, bool) { return Status::OK(); };
     _incOps = [this]() { _opsApplied++; };
 }
 
 void SyncTailTest::tearDown() {
-    _txn.reset();
+    _opCtx.reset();
     ServiceContextMongoDTest::tearDown();
     _storageInterface = nullptr;
 }
@@ -151,10 +151,10 @@ BSONObj SyncTailWithLocalDocumentFetcher::getMissingDoc(OperationContext*,
 SyncTailWithOperationContextChecker::SyncTailWithOperationContextChecker()
     : SyncTail(nullptr, SyncTail::MultiSyncApplyFunc(), nullptr) {}
 
-bool SyncTailWithOperationContextChecker::shouldRetry(OperationContext* txn, const BSONObj&) {
-    ASSERT_FALSE(txn->writesAreReplicated());
-    ASSERT_FALSE(txn->lockState()->shouldConflictWithSecondaryBatchApplication());
-    ASSERT_TRUE(documentValidationDisabled(txn));
+bool SyncTailWithOperationContextChecker::shouldRetry(OperationContext* opCtx, const BSONObj&) {
+    ASSERT_FALSE(opCtx->writesAreReplicated());
+    ASSERT_FALSE(opCtx->lockState()->shouldConflictWithSecondaryBatchApplication());
+    ASSERT_TRUE(documentValidationDisabled(opCtx));
     return false;
 }
 
@@ -173,21 +173,21 @@ CollectionOptions createOplogCollectionOptions() {
  * Create test collection.
  * Returns collection.
  */
-void createCollection(OperationContext* txn,
+void createCollection(OperationContext* opCtx,
                       const NamespaceString& nss,
                       const CollectionOptions& options) {
     MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
-        ScopedTransaction transaction(txn, MODE_IX);
-        Lock::DBLock dblk(txn->lockState(), nss.db(), MODE_X);
-        OldClientContext ctx(txn, nss.ns());
+        ScopedTransaction transaction(opCtx, MODE_IX);
+        Lock::DBLock dblk(opCtx->lockState(), nss.db(), MODE_X);
+        OldClientContext ctx(opCtx, nss.ns());
         auto db = ctx.db();
         ASSERT_TRUE(db);
-        mongo::WriteUnitOfWork wuow(txn);
-        auto coll = db->createCollection(txn, nss.ns(), options);
+        mongo::WriteUnitOfWork wuow(opCtx);
+        auto coll = db->createCollection(opCtx, nss.ns(), options);
         ASSERT_TRUE(coll);
         wuow.commit();
     }
-    MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "createCollection", nss.ns());
+    MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "createCollection", nss.ns());
 }
 
 /**
@@ -250,7 +250,7 @@ OplogEntry makeUpdateDocumentOplogEntry(OpTime opTime,
     return OplogEntry(bob.obj());
 }
 
-Status failedApplyCommand(OperationContext* txn, const BSONObj& theOperation, bool) {
+Status failedApplyCommand(OperationContext* opCtx, const BSONObj& theOperation, bool) {
     FAIL("applyCommand unexpectedly invoked.");
     return Status::OK();
 }
@@ -258,12 +258,12 @@ Status failedApplyCommand(OperationContext* txn, const BSONObj& theOperation, bo
 TEST_F(SyncTailTest, SyncApplyNoNamespaceBadOp) {
     const BSONObj op = BSON("op"
                             << "x");
-    ASSERT_OK(SyncTail::syncApply(_txn.get(), op, false, _applyOp, _applyCmd, _incOps));
+    ASSERT_OK(SyncTail::syncApply(_opCtx.get(), op, false, _applyOp, _applyCmd, _incOps));
     ASSERT_EQUALS(0U, _opsApplied);
 }
 
 TEST_F(SyncTailTest, SyncApplyNoNamespaceNoOp) {
-    ASSERT_OK(SyncTail::syncApply(_txn.get(),
+    ASSERT_OK(SyncTail::syncApply(_opCtx.get(),
                                   BSON("op"
                                        << "n"),
                                   false));
@@ -275,8 +275,9 @@ TEST_F(SyncTailTest, SyncApplyBadOp) {
                             << "x"
                             << "ns"
                             << "test.t");
-    ASSERT_EQUALS(ErrorCodes::BadValue,
-                  SyncTail::syncApply(_txn.get(), op, false, _applyOp, _applyCmd, _incOps).code());
+    ASSERT_EQUALS(
+        ErrorCodes::BadValue,
+        SyncTail::syncApply(_opCtx.get(), op, false, _applyOp, _applyCmd, _incOps).code());
     ASSERT_EQUALS(0U, _opsApplied);
 }
 
@@ -286,24 +287,24 @@ TEST_F(SyncTailTest, SyncApplyNoOp) {
                             << "ns"
                             << "test.t");
     bool applyOpCalled = false;
-    SyncTail::ApplyOperationInLockFn applyOp = [&](OperationContext* txn,
+    SyncTail::ApplyOperationInLockFn applyOp = [&](OperationContext* opCtx,
                                                    Database* db,
                                                    const BSONObj& theOperation,
                                                    bool inSteadyStateReplication,
                                                    stdx::function<void()>) {
         applyOpCalled = true;
-        ASSERT_TRUE(txn);
-        ASSERT_TRUE(txn->lockState()->isDbLockedForMode("test", MODE_X));
-        ASSERT_FALSE(txn->writesAreReplicated());
-        ASSERT_TRUE(documentValidationDisabled(txn));
+        ASSERT_TRUE(opCtx);
+        ASSERT_TRUE(opCtx->lockState()->isDbLockedForMode("test", MODE_X));
+        ASSERT_FALSE(opCtx->writesAreReplicated());
+        ASSERT_TRUE(documentValidationDisabled(opCtx));
         ASSERT_TRUE(db);
         ASSERT_BSONOBJ_EQ(op, theOperation);
         ASSERT_FALSE(inSteadyStateReplication);
         return Status::OK();
     };
-    ASSERT_TRUE(_txn->writesAreReplicated());
-    ASSERT_FALSE(documentValidationDisabled(_txn.get()));
-    ASSERT_OK(SyncTail::syncApply(_txn.get(), op, false, applyOp, failedApplyCommand, _incOps));
+    ASSERT_TRUE(_opCtx->writesAreReplicated());
+    ASSERT_FALSE(documentValidationDisabled(_opCtx.get()));
+    ASSERT_OK(SyncTail::syncApply(_opCtx.get(), op, false, applyOp, failedApplyCommand, _incOps));
     ASSERT_TRUE(applyOpCalled);
 }
 
@@ -313,7 +314,7 @@ TEST_F(SyncTailTest, SyncApplyNoOpApplyOpThrowsException) {
                             << "ns"
                             << "test.t");
     int applyOpCalled = 0;
-    SyncTail::ApplyOperationInLockFn applyOp = [&](OperationContext* txn,
+    SyncTail::ApplyOperationInLockFn applyOp = [&](OperationContext* opCtx,
                                                    Database* db,
                                                    const BSONObj& theOperation,
                                                    bool inSteadyStateReplication,
@@ -324,7 +325,7 @@ TEST_F(SyncTailTest, SyncApplyNoOpApplyOpThrowsException) {
         }
         return Status::OK();
     };
-    ASSERT_OK(SyncTail::syncApply(_txn.get(), op, false, applyOp, failedApplyCommand, _incOps));
+    ASSERT_OK(SyncTail::syncApply(_opCtx.get(), op, false, applyOp, failedApplyCommand, _incOps));
     ASSERT_EQUALS(5, applyOpCalled);
 }
 
@@ -334,25 +335,25 @@ void SyncTailTest::_testSyncApplyInsertDocument(LockMode expectedMode) {
                             << "ns"
                             << "test.t");
     bool applyOpCalled = false;
-    SyncTail::ApplyOperationInLockFn applyOp = [&](OperationContext* txn,
+    SyncTail::ApplyOperationInLockFn applyOp = [&](OperationContext* opCtx,
                                                    Database* db,
                                                    const BSONObj& theOperation,
                                                    bool inSteadyStateReplication,
                                                    stdx::function<void()>) {
         applyOpCalled = true;
-        ASSERT_TRUE(txn);
-        ASSERT_TRUE(txn->lockState()->isDbLockedForMode("test", expectedMode));
-        ASSERT_TRUE(txn->lockState()->isCollectionLockedForMode("test.t", expectedMode));
-        ASSERT_FALSE(txn->writesAreReplicated());
-        ASSERT_TRUE(documentValidationDisabled(txn));
+        ASSERT_TRUE(opCtx);
+        ASSERT_TRUE(opCtx->lockState()->isDbLockedForMode("test", expectedMode));
+        ASSERT_TRUE(opCtx->lockState()->isCollectionLockedForMode("test.t", expectedMode));
+        ASSERT_FALSE(opCtx->writesAreReplicated());
+        ASSERT_TRUE(documentValidationDisabled(opCtx));
         ASSERT_TRUE(db);
         ASSERT_BSONOBJ_EQ(op, theOperation);
         ASSERT_TRUE(inSteadyStateReplication);
         return Status::OK();
     };
-    ASSERT_TRUE(_txn->writesAreReplicated());
-    ASSERT_FALSE(documentValidationDisabled(_txn.get()));
-    ASSERT_OK(SyncTail::syncApply(_txn.get(), op, true, applyOp, failedApplyCommand, _incOps));
+    ASSERT_TRUE(_opCtx->writesAreReplicated());
+    ASSERT_FALSE(documentValidationDisabled(_opCtx.get()));
+    ASSERT_OK(SyncTail::syncApply(_opCtx.get(), op, true, applyOp, failedApplyCommand, _incOps));
     ASSERT_TRUE(applyOpCalled);
 }
 
@@ -362,9 +363,9 @@ TEST_F(SyncTailTest, SyncApplyInsertDocumentDatabaseMissing) {
 
 TEST_F(SyncTailTest, SyncApplyInsertDocumentCollectionMissing) {
     {
-        Lock::GlobalWrite globalLock(_txn->lockState());
+        Lock::GlobalWrite globalLock(_opCtx->lockState());
         bool justCreated = false;
-        Database* db = dbHolder().openDb(_txn.get(), "test", &justCreated);
+        Database* db = dbHolder().openDb(_opCtx.get(), "test", &justCreated);
         ASSERT_TRUE(db);
         ASSERT_TRUE(justCreated);
     }
@@ -373,12 +374,12 @@ TEST_F(SyncTailTest, SyncApplyInsertDocumentCollectionMissing) {
 
 TEST_F(SyncTailTest, SyncApplyInsertDocumentCollectionExists) {
     {
-        Lock::GlobalWrite globalLock(_txn->lockState());
+        Lock::GlobalWrite globalLock(_opCtx->lockState());
         bool justCreated = false;
-        Database* db = dbHolder().openDb(_txn.get(), "test", &justCreated);
+        Database* db = dbHolder().openDb(_opCtx.get(), "test", &justCreated);
         ASSERT_TRUE(db);
         ASSERT_TRUE(justCreated);
-        Collection* collection = db->createCollection(_txn.get(), "test.t");
+        Collection* collection = db->createCollection(_opCtx.get(), "test.t");
         ASSERT_TRUE(collection);
     }
     _testSyncApplyInsertDocument(MODE_IX);
@@ -390,24 +391,24 @@ TEST_F(SyncTailTest, SyncApplyIndexBuild) {
                             << "ns"
                             << "test.system.indexes");
     bool applyOpCalled = false;
-    SyncTail::ApplyOperationInLockFn applyOp = [&](OperationContext* txn,
+    SyncTail::ApplyOperationInLockFn applyOp = [&](OperationContext* opCtx,
                                                    Database* db,
                                                    const BSONObj& theOperation,
                                                    bool inSteadyStateReplication,
                                                    stdx::function<void()>) {
         applyOpCalled = true;
-        ASSERT_TRUE(txn);
-        ASSERT_TRUE(txn->lockState()->isDbLockedForMode("test", MODE_X));
-        ASSERT_FALSE(txn->writesAreReplicated());
-        ASSERT_TRUE(documentValidationDisabled(txn));
+        ASSERT_TRUE(opCtx);
+        ASSERT_TRUE(opCtx->lockState()->isDbLockedForMode("test", MODE_X));
+        ASSERT_FALSE(opCtx->writesAreReplicated());
+        ASSERT_TRUE(documentValidationDisabled(opCtx));
         ASSERT_TRUE(db);
         ASSERT_BSONOBJ_EQ(op, theOperation);
         ASSERT_FALSE(inSteadyStateReplication);
         return Status::OK();
     };
-    ASSERT_TRUE(_txn->writesAreReplicated());
-    ASSERT_FALSE(documentValidationDisabled(_txn.get()));
-    ASSERT_OK(SyncTail::syncApply(_txn.get(), op, false, applyOp, failedApplyCommand, _incOps));
+    ASSERT_TRUE(_opCtx->writesAreReplicated());
+    ASSERT_FALSE(documentValidationDisabled(_opCtx.get()));
+    ASSERT_OK(SyncTail::syncApply(_opCtx.get(), op, false, applyOp, failedApplyCommand, _incOps));
     ASSERT_TRUE(applyOpCalled);
 }
 
@@ -417,7 +418,7 @@ TEST_F(SyncTailTest, SyncApplyCommand) {
                             << "ns"
                             << "test.t");
     bool applyCmdCalled = false;
-    SyncTail::ApplyOperationInLockFn applyOp = [&](OperationContext* txn,
+    SyncTail::ApplyOperationInLockFn applyOp = [&](OperationContext* opCtx,
                                                    Database* db,
                                                    const BSONObj& theOperation,
                                                    bool inSteadyStateReplication,
@@ -426,18 +427,18 @@ TEST_F(SyncTailTest, SyncApplyCommand) {
         return Status::OK();
     };
     SyncTail::ApplyCommandInLockFn applyCmd =
-        [&](OperationContext* txn, const BSONObj& theOperation, bool inSteadyStateReplication) {
+        [&](OperationContext* opCtx, const BSONObj& theOperation, bool inSteadyStateReplication) {
             applyCmdCalled = true;
-            ASSERT_TRUE(txn);
-            ASSERT_TRUE(txn->lockState()->isW());
-            ASSERT_TRUE(txn->writesAreReplicated());
-            ASSERT_FALSE(documentValidationDisabled(txn));
+            ASSERT_TRUE(opCtx);
+            ASSERT_TRUE(opCtx->lockState()->isW());
+            ASSERT_TRUE(opCtx->writesAreReplicated());
+            ASSERT_FALSE(documentValidationDisabled(opCtx));
             ASSERT_BSONOBJ_EQ(op, theOperation);
             return Status::OK();
         };
-    ASSERT_TRUE(_txn->writesAreReplicated());
-    ASSERT_FALSE(documentValidationDisabled(_txn.get()));
-    ASSERT_OK(SyncTail::syncApply(_txn.get(), op, false, applyOp, applyCmd, _incOps));
+    ASSERT_TRUE(_opCtx->writesAreReplicated());
+    ASSERT_FALSE(documentValidationDisabled(_opCtx.get()));
+    ASSERT_OK(SyncTail::syncApply(_opCtx.get(), op, false, applyOp, applyCmd, _incOps));
     ASSERT_TRUE(applyCmdCalled);
     ASSERT_EQUALS(1U, _opsApplied);
 }
@@ -448,7 +449,7 @@ TEST_F(SyncTailTest, SyncApplyCommandThrowsException) {
                             << "ns"
                             << "test.t");
     int applyCmdCalled = 0;
-    SyncTail::ApplyOperationInLockFn applyOp = [&](OperationContext* txn,
+    SyncTail::ApplyOperationInLockFn applyOp = [&](OperationContext* opCtx,
                                                    Database* db,
                                                    const BSONObj& theOperation,
                                                    bool inSteadyStateReplication,
@@ -457,14 +458,14 @@ TEST_F(SyncTailTest, SyncApplyCommandThrowsException) {
         return Status::OK();
     };
     SyncTail::ApplyCommandInLockFn applyCmd =
-        [&](OperationContext* txn, const BSONObj& theOperation, bool inSteadyStateReplication) {
+        [&](OperationContext* opCtx, const BSONObj& theOperation, bool inSteadyStateReplication) {
             applyCmdCalled++;
             if (applyCmdCalled < 5) {
                 throw WriteConflictException();
             }
             return Status::OK();
         };
-    ASSERT_OK(SyncTail::syncApply(_txn.get(), op, false, applyOp, applyCmd, _incOps));
+    ASSERT_OK(SyncTail::syncApply(_opCtx.get(), op, false, applyOp, applyCmd, _incOps));
     ASSERT_EQUALS(5, applyCmdCalled);
     ASSERT_EQUALS(1U, _opsApplied);
 }
@@ -479,14 +480,14 @@ TEST_F(SyncTailTest, MultiApplyReturnsBadValueOnNullOperationContext) {
 
 TEST_F(SyncTailTest, MultiApplyReturnsBadValueOnNullWriterPool) {
     auto op = makeCreateCollectionOplogEntry({Timestamp(Seconds(1), 0), 1LL});
-    auto status = multiApply(_txn.get(), nullptr, {op}, noopApplyOperationFn).getStatus();
+    auto status = multiApply(_opCtx.get(), nullptr, {op}, noopApplyOperationFn).getStatus();
     ASSERT_EQUALS(ErrorCodes::BadValue, status);
     ASSERT_STRING_CONTAINS(status.reason(), "invalid worker pool");
 }
 
 TEST_F(SyncTailTest, MultiApplyReturnsEmptyArrayOperationWhenNoOperationsAreGiven) {
     auto writerPool = SyncTail::makeWriterPool();
-    auto status = multiApply(_txn.get(), writerPool.get(), {}, noopApplyOperationFn).getStatus();
+    auto status = multiApply(_opCtx.get(), writerPool.get(), {}, noopApplyOperationFn).getStatus();
     ASSERT_EQUALS(ErrorCodes::EmptyArrayOperation, status);
     ASSERT_STRING_CONTAINS(status.reason(), "no operations provided to multiApply");
 }
@@ -495,12 +496,13 @@ TEST_F(SyncTailTest, MultiApplyReturnsBadValueOnNullApplyOperation) {
     auto writerPool = SyncTail::makeWriterPool();
     MultiApplier::ApplyOperationFn nullApplyOperationFn;
     auto op = makeCreateCollectionOplogEntry({Timestamp(Seconds(1), 0), 1LL});
-    auto status = multiApply(_txn.get(), writerPool.get(), {op}, nullApplyOperationFn).getStatus();
+    auto status =
+        multiApply(_opCtx.get(), writerPool.get(), {op}, nullApplyOperationFn).getStatus();
     ASSERT_EQUALS(ErrorCodes::BadValue, status);
     ASSERT_STRING_CONTAINS(status.reason(), "invalid apply operation function");
 }
 
-bool _testOplogEntryIsForCappedCollection(OperationContext* txn,
+bool _testOplogEntryIsForCappedCollection(OperationContext* opCtx,
                                           const NamespaceString& nss,
                                           const CollectionOptions& options) {
     auto writerPool = SyncTail::makeWriterPool();
@@ -512,13 +514,13 @@ bool _testOplogEntryIsForCappedCollection(OperationContext* txn,
         }
         return Status::OK();
     };
-    createCollection(txn, nss, options);
+    createCollection(opCtx, nss, options);
 
     auto op = makeInsertDocumentOplogEntry({Timestamp(Seconds(1), 0), 1LL}, nss, BSON("a" << 1));
     ASSERT_FALSE(op.isForCappedCollection);
 
     auto lastOpTime =
-        unittest::assertGet(multiApply(txn, writerPool.get(), {op}, applyOperationFn));
+        unittest::assertGet(multiApply(opCtx, writerPool.get(), {op}, applyOperationFn));
     ASSERT_EQUALS(op.getOpTime(), lastOpTime);
 
     ASSERT_EQUALS(1U, operationsApplied.size());
@@ -532,14 +534,14 @@ TEST_F(
     SyncTailTest,
     MultiApplyDoesNotSetOplogEntryIsForCappedCollectionWhenProcessingNonCappedCollectionInsertOperation) {
     NamespaceString nss("local." + _agent.getSuiteName() + "_" + _agent.getTestName());
-    ASSERT_FALSE(_testOplogEntryIsForCappedCollection(_txn.get(), nss, CollectionOptions()));
+    ASSERT_FALSE(_testOplogEntryIsForCappedCollection(_opCtx.get(), nss, CollectionOptions()));
 }
 
 TEST_F(SyncTailTest,
        MultiApplySetsOplogEntryIsForCappedCollectionWhenProcessingCappedCollectionInsertOperation) {
     NamespaceString nss("local." + _agent.getSuiteName() + "_" + _agent.getTestName());
     ASSERT_TRUE(
-        _testOplogEntryIsForCappedCollection(_txn.get(), nss, createOplogCollectionOptions()));
+        _testOplogEntryIsForCappedCollection(_opCtx.get(), nss, createOplogCollectionOptions()));
 }
 
 TEST_F(SyncTailTest, MultiApplyAssignsOperationsToWriterThreadsBasedOnNamespaceHash) {
@@ -569,7 +571,7 @@ TEST_F(SyncTailTest, MultiApplyAssignsOperationsToWriterThreadsBasedOnNamespaceH
     NamespaceString nssForInsert;
     std::vector<BSONObj> operationsWrittenToOplog;
     _storageInterface->insertDocumentsFn = [&mutex, &nssForInsert, &operationsWrittenToOplog](
-        OperationContext* txn, const NamespaceString& nss, const std::vector<BSONObj>& docs) {
+        OperationContext* opCtx, const NamespaceString& nss, const std::vector<BSONObj>& docs) {
         stdx::lock_guard<stdx::mutex> lock(mutex);
         nssForInsert = nss;
         operationsWrittenToOplog = docs;
@@ -577,7 +579,7 @@ TEST_F(SyncTailTest, MultiApplyAssignsOperationsToWriterThreadsBasedOnNamespaceH
     };
 
     auto lastOpTime =
-        unittest::assertGet(multiApply(_txn.get(), &writerPool, {op1, op2}, applyOperationFn));
+        unittest::assertGet(multiApply(_opCtx.get(), &writerPool, {op1, op2}, applyOperationFn));
     ASSERT_EQUALS(op2.getOpTime(), lastOpTime);
 
     // Each writer thread should be given exactly one operation to apply.
@@ -606,28 +608,28 @@ TEST_F(SyncTailTest, MultiApplyAssignsOperationsToWriterThreadsBasedOnNamespaceH
 TEST_F(SyncTailTest, MultiSyncApplyUsesSyncApplyToApplyOperation) {
     NamespaceString nss("local." + _agent.getSuiteName() + "_" + _agent.getTestName());
     auto op = makeCreateCollectionOplogEntry({Timestamp(Seconds(1), 0), 1LL}, nss);
-    _txn.reset();
+    _opCtx.reset();
 
     MultiApplier::OperationPtrs ops = {&op};
     multiSyncApply(&ops, nullptr);
     // Collection should be created after SyncTail::syncApply() processes operation.
-    _txn = cc().makeOperationContext();
-    ASSERT_TRUE(AutoGetCollectionForRead(_txn.get(), nss).getCollection());
+    _opCtx = cc().makeOperationContext();
+    ASSERT_TRUE(AutoGetCollectionForRead(_opCtx.get(), nss).getCollection());
 }
 
 TEST_F(SyncTailTest, MultiSyncApplyDisablesDocumentValidationWhileApplyingOperations) {
     NamespaceString nss("local." + _agent.getSuiteName() + "_" + _agent.getTestName());
-    auto syncApply = [](OperationContext* txn, const BSONObj&, bool convertUpdatesToUpserts) {
-        ASSERT_FALSE(txn->writesAreReplicated());
-        ASSERT_FALSE(txn->lockState()->shouldConflictWithSecondaryBatchApplication());
-        ASSERT_TRUE(documentValidationDisabled(txn));
+    auto syncApply = [](OperationContext* opCtx, const BSONObj&, bool convertUpdatesToUpserts) {
+        ASSERT_FALSE(opCtx->writesAreReplicated());
+        ASSERT_FALSE(opCtx->lockState()->shouldConflictWithSecondaryBatchApplication());
+        ASSERT_TRUE(documentValidationDisabled(opCtx));
         ASSERT_TRUE(convertUpdatesToUpserts);
         return Status::OK();
     };
     auto op = makeUpdateDocumentOplogEntry(
         {Timestamp(Seconds(1), 0), 1LL}, nss, BSON("_id" << 0), BSON("_id" << 0 << "x" << 2));
     MultiApplier::OperationPtrs ops = {&op};
-    ASSERT_OK(multiSyncApply_noAbort(_txn.get(), &ops, syncApply));
+    ASSERT_OK(multiSyncApply_noAbort(_opCtx.get(), &ops, syncApply));
 }
 
 TEST_F(SyncTailTest, MultiSyncApplyPassesThroughSyncApplyErrorAfterFailingToApplyOperation) {
@@ -640,7 +642,8 @@ TEST_F(SyncTailTest, MultiSyncApplyPassesThroughSyncApplyErrorAfterFailingToAppl
         return {ErrorCodes::OperationFailed, ""};
     };
     MultiApplier::OperationPtrs ops = {&op};
-    ASSERT_EQUALS(ErrorCodes::OperationFailed, multiSyncApply_noAbort(_txn.get(), &ops, syncApply));
+    ASSERT_EQUALS(ErrorCodes::OperationFailed,
+                  multiSyncApply_noAbort(_opCtx.get(), &ops, syncApply));
 }
 
 TEST_F(SyncTailTest, MultiSyncApplyPassesThroughSyncApplyException) {
@@ -654,7 +657,8 @@ TEST_F(SyncTailTest, MultiSyncApplyPassesThroughSyncApplyException) {
         MONGO_UNREACHABLE;
     };
     MultiApplier::OperationPtrs ops = {&op};
-    ASSERT_EQUALS(ErrorCodes::OperationFailed, multiSyncApply_noAbort(_txn.get(), &ops, syncApply));
+    ASSERT_EQUALS(ErrorCodes::OperationFailed,
+                  multiSyncApply_noAbort(_opCtx.get(), &ops, syncApply));
 }
 
 TEST_F(SyncTailTest, MultiSyncApplySortsOperationsStablyByNamespaceBeforeApplying) {
@@ -677,7 +681,7 @@ TEST_F(SyncTailTest, MultiSyncApplySortsOperationsStablyByNamespaceBeforeApplyin
         return Status::OK();
     };
     MultiApplier::OperationPtrs ops = {&op4, &op1, &op3, &op2};
-    ASSERT_OK(multiSyncApply_noAbort(_txn.get(), &ops, syncApply));
+    ASSERT_OK(multiSyncApply_noAbort(_opCtx.get(), &ops, syncApply));
     ASSERT_EQUALS(4U, operationsApplied.size());
     ASSERT_EQUALS(op1, operationsApplied[0]);
     ASSERT_EQUALS(op2, operationsApplied[1]);
@@ -707,7 +711,7 @@ TEST_F(SyncTailTest, MultiSyncApplyGroupsInsertOperationByNamespaceBeforeApplyin
 
     MultiApplier::OperationPtrs ops = {
         &createOp1, &createOp2, &insertOp1a, &insertOp2a, &insertOp1b, &insertOp2b};
-    ASSERT_OK(multiSyncApply_noAbort(_txn.get(), &ops, syncApply));
+    ASSERT_OK(multiSyncApply_noAbort(_opCtx.get(), &ops, syncApply));
 
     ASSERT_EQUALS(4U, operationsApplied.size());
     ASSERT_EQUALS(createOp1, operationsApplied[0]);
@@ -761,7 +765,7 @@ TEST_F(SyncTailTest, MultiSyncApplyUsesLimitWhenGroupingInsertOperation) {
     for (auto&& op : operationsToApply) {
         ops.push_back(&op);
     }
-    ASSERT_OK(multiSyncApply_noAbort(_txn.get(), &ops, syncApply));
+    ASSERT_OK(multiSyncApply_noAbort(_opCtx.get(), &ops, syncApply));
 
     // multiSyncApply should combine operations as follows:
     // {create}, {grouped_insert}, {insert_(limit+1)}
@@ -820,7 +824,7 @@ TEST_F(SyncTailTest, MultiSyncApplyFallsBackOnApplyingInsertsIndividuallyWhenGro
     for (auto&& op : operationsToApply) {
         ops.push_back(&op);
     }
-    ASSERT_OK(multiSyncApply_noAbort(_txn.get(), &ops, syncApply));
+    ASSERT_OK(multiSyncApply_noAbort(_opCtx.get(), &ops, syncApply));
 
     // On failing to apply the grouped insert operation, multiSyncApply should apply the operations
     // as given in "operationsToApply":
@@ -845,7 +849,7 @@ TEST_F(SyncTailTest, MultiInitialSyncApplyDisablesDocumentValidationWhileApplyin
         {Timestamp(Seconds(1), 0), 1LL}, nss, BSON("_id" << 0), BSON("_id" << 0 << "x" << 2));
     MultiApplier::OperationPtrs ops = {&op};
     AtomicUInt32 fetchCount(0);
-    ASSERT_OK(multiInitialSyncApply_noAbort(_txn.get(), &ops, &syncTail, &fetchCount));
+    ASSERT_OK(multiInitialSyncApply_noAbort(_opCtx.get(), &ops, &syncTail, &fetchCount));
     ASSERT_EQUALS(fetchCount.load(), 1U);
 }
 
@@ -858,11 +862,11 @@ TEST_F(SyncTailTest,
         {Timestamp(Seconds(1), 0), 1LL}, nss, BSON("_id" << 0), BSON("_id" << 0 << "x" << 2));
     MultiApplier::OperationPtrs ops = {&op};
     AtomicUInt32 fetchCount(0);
-    ASSERT_OK(multiInitialSyncApply_noAbort(_txn.get(), &ops, &syncTail, &fetchCount));
+    ASSERT_OK(multiInitialSyncApply_noAbort(_opCtx.get(), &ops, &syncTail, &fetchCount));
 
     // Since the missing document is not found on the sync source, the collection referenced by
     // the failed operation should not be automatically created.
-    ASSERT_FALSE(AutoGetCollectionForRead(_txn.get(), nss).getCollection());
+    ASSERT_FALSE(AutoGetCollectionForRead(_opCtx.get(), nss).getCollection());
     ASSERT_EQUALS(fetchCount.load(), 1U);
 }
 
@@ -880,10 +884,10 @@ TEST_F(SyncTailTest, MultiInitialSyncApplySkipsDocumentOnNamespaceNotFound) {
     auto op3 = makeInsertDocumentOplogEntry({Timestamp(Seconds(4), 0), 1LL}, nss, doc3);
     MultiApplier::OperationPtrs ops = {&op0, &op1, &op2, &op3};
     AtomicUInt32 fetchCount(0);
-    ASSERT_OK(multiInitialSyncApply_noAbort(_txn.get(), &ops, &syncTail, &fetchCount));
+    ASSERT_OK(multiInitialSyncApply_noAbort(_opCtx.get(), &ops, &syncTail, &fetchCount));
     ASSERT_EQUALS(fetchCount.load(), 0U);
 
-    OplogInterfaceLocal collectionReader(_txn.get(), nss.ns());
+    OplogInterfaceLocal collectionReader(_opCtx.get(), nss.ns());
     auto iter = collectionReader.makeIterator();
     ASSERT_BSONOBJ_EQ(doc3, unittest::assertGet(iter->next()).first);
     ASSERT_BSONOBJ_EQ(doc1, unittest::assertGet(iter->next()).first);
@@ -898,13 +902,13 @@ TEST_F(SyncTailTest, MultiInitialSyncApplyRetriesFailedUpdateIfDocumentIsAvailab
         {Timestamp(Seconds(1), 0), 1LL}, nss, BSON("_id" << 0), updatedDocument);
     MultiApplier::OperationPtrs ops = {&op};
     AtomicUInt32 fetchCount(0);
-    ASSERT_OK(multiInitialSyncApply_noAbort(_txn.get(), &ops, &syncTail, &fetchCount));
+    ASSERT_OK(multiInitialSyncApply_noAbort(_opCtx.get(), &ops, &syncTail, &fetchCount));
     ASSERT_EQUALS(fetchCount.load(), 1U);
 
     // The collection referenced by "ns" in the failed operation is automatically created to hold
     // the missing document fetched from the sync source. We verify the contents of the collection
     // with the OplogInterfaceLocal class.
-    OplogInterfaceLocal collectionReader(_txn.get(), nss.ns());
+    OplogInterfaceLocal collectionReader(_opCtx.get(), nss.ns());
     auto iter = collectionReader.makeIterator();
     ASSERT_BSONOBJ_EQ(updatedDocument, unittest::assertGet(iter->next()).first);
     ASSERT_EQUALS(ErrorCodes::CollectionIsEmpty, iter->next().getStatus());
@@ -920,7 +924,7 @@ TEST_F(SyncTailTest, MultiInitialSyncApplyPassesThroughSyncApplyErrorAfterFailin
     MultiApplier::OperationPtrs ops = {&op};
     AtomicUInt32 fetchCount(0);
     ASSERT_EQUALS(ErrorCodes::BadValue,
-                  multiInitialSyncApply_noAbort(_txn.get(), &ops, &syncTail, &fetchCount));
+                  multiInitialSyncApply_noAbort(_opCtx.get(), &ops, &syncTail, &fetchCount));
     ASSERT_EQUALS(fetchCount.load(), 1U);
 }
 
@@ -929,12 +933,13 @@ TEST_F(SyncTailTest, MultiInitialSyncApplyPassesThroughShouldSyncTailRetryError)
     NamespaceString nss("local." + _agent.getSuiteName() + "_" + _agent.getTestName());
     auto op = makeUpdateDocumentOplogEntry(
         {Timestamp(Seconds(1), 0), 1LL}, nss, BSON("_id" << 0), BSON("_id" << 0 << "x" << 2));
-    ASSERT_THROWS_CODE(
-        syncTail.shouldRetry(_txn.get(), op.raw), mongo::UserException, ErrorCodes::FailedToParse);
+    ASSERT_THROWS_CODE(syncTail.shouldRetry(_opCtx.get(), op.raw),
+                       mongo::UserException,
+                       ErrorCodes::FailedToParse);
     MultiApplier::OperationPtrs ops = {&op};
     AtomicUInt32 fetchCount(0);
     ASSERT_EQUALS(ErrorCodes::FailedToParse,
-                  multiInitialSyncApply_noAbort(_txn.get(), &ops, &syncTail, &fetchCount));
+                  multiInitialSyncApply_noAbort(_opCtx.get(), &ops, &syncTail, &fetchCount));
     ASSERT_EQUALS(fetchCount.load(), 1U);
 }
 
@@ -970,7 +975,7 @@ Status IdempotencyTest::runOps(std::initializer_list<OplogEntry> ops) {
         opsPtrs.push_back(&op);
     }
     AtomicUInt32 fetchCount(0);
-    return multiInitialSyncApply_noAbort(_txn.get(), &opsPtrs, &syncTail, &fetchCount);
+    return multiInitialSyncApply_noAbort(_opCtx.get(), &opsPtrs, &syncTail, &fetchCount);
 }
 
 OplogEntry IdempotencyTest::createCollection() {
@@ -1002,21 +1007,21 @@ OplogEntry IdempotencyTest::dropIndex(const std::string& indexName) {
 }
 
 std::string IdempotencyTest::validate() {
-    auto collection = AutoGetCollectionForRead(_txn.get(), nss).getCollection();
+    auto collection = AutoGetCollectionForRead(_opCtx.get(), nss).getCollection();
     if (!collection) {
         return "CollectionNotFound";
     }
     ValidateResults validateResults;
     BSONObjBuilder bob;
 
-    Lock::DBLock lk(_txn->lockState(), nss.db(), MODE_IS);
-    Lock::CollectionLock lock(_txn->lockState(), nss.ns(), MODE_IS);
-    ASSERT_OK(collection->validate(_txn.get(), kValidateFull, &validateResults, &bob));
+    Lock::DBLock lk(_opCtx->lockState(), nss.db(), MODE_IS);
+    Lock::CollectionLock lock(_opCtx->lockState(), nss.ns(), MODE_IS);
+    ASSERT_OK(collection->validate(_opCtx.get(), kValidateFull, &validateResults, &bob));
     ASSERT_TRUE(validateResults.valid);
 
-    IndexDescriptor* desc = collection->getIndexCatalog()->findIdIndex(_txn.get());
+    IndexDescriptor* desc = collection->getIndexCatalog()->findIdIndex(_opCtx.get());
     ASSERT_TRUE(desc);
-    auto exec = InternalPlanner::indexScan(_txn.get(),
+    auto exec = InternalPlanner::indexScan(_opCtx.get(),
                                            collection,
                                            desc,
                                            BSONObj(),
@@ -1041,7 +1046,7 @@ std::string IdempotencyTest::validate() {
 }
 
 TEST_F(IdempotencyTest, Geo2dsphereIndexFailedOnUpdate) {
-    ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+    ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
     ASSERT_OK(runOp(createCollection()));
     auto insertOp = insert(fromjson("{_id: 1, loc: 'hi'}"));
     auto updateOp = update(1, fromjson("{$set: {loc: [1, 2]}}"));
@@ -1054,13 +1059,13 @@ TEST_F(IdempotencyTest, Geo2dsphereIndexFailedOnUpdate) {
     ASSERT_OK(runOps(ops));
     ASSERT_EQUALS(hash, validate());
 
-    ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_PRIMARY);
+    ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_PRIMARY);
     auto status = runOps(ops);
     ASSERT_EQ(status.code(), 16755);
 }
 
 TEST_F(IdempotencyTest, Geo2dsphereIndexFailedOnIndexing) {
-    ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+    ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
     ASSERT_OK(runOp(createCollection()));
     auto indexOp = buildIndex(fromjson("{loc: '2dsphere'}"), BSON("2dsphereIndexVersion" << 3));
     auto dropIndexOp = dropIndex("loc_index");
@@ -1073,13 +1078,13 @@ TEST_F(IdempotencyTest, Geo2dsphereIndexFailedOnIndexing) {
     ASSERT_OK(runOps(ops));
     ASSERT_EQUALS(hash, validate());
 
-    ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_PRIMARY);
+    ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_PRIMARY);
     auto status = runOps(ops);
     ASSERT_EQ(status.code(), 16755);
 }
 
 TEST_F(IdempotencyTest, Geo2dIndex) {
-    ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+    ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
     ASSERT_OK(runOp(createCollection()));
     auto insertOp = insert(fromjson("{_id: 1, loc: [1]}"));
     auto updateOp = update(1, fromjson("{$set: {loc: [1, 2]}}"));
@@ -1092,13 +1097,13 @@ TEST_F(IdempotencyTest, Geo2dIndex) {
     ASSERT_OK(runOps(ops));
     ASSERT_EQUALS(hash, validate());
 
-    ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_PRIMARY);
+    ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_PRIMARY);
     auto status = runOps(ops);
     ASSERT_EQ(status.code(), 13068);
 }
 
 TEST_F(IdempotencyTest, UniqueKeyIndex) {
-    ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+    ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
     ASSERT_OK(runOp(createCollection()));
     auto insertOp = insert(fromjson("{_id: 1, x: 5}"));
     auto updateOp = update(1, fromjson("{$set: {x: 6}}"));
@@ -1112,13 +1117,13 @@ TEST_F(IdempotencyTest, UniqueKeyIndex) {
     ASSERT_OK(runOps(ops));
     ASSERT_EQUALS(hash, validate());
 
-    ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_PRIMARY);
+    ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_PRIMARY);
     auto status = runOps(ops);
     ASSERT_EQ(status.code(), ErrorCodes::DuplicateKey);
 }
 
 TEST_F(IdempotencyTest, ParallelArrayError) {
-    ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+    ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
 
     ASSERT_OK(runOp(createCollection()));
     ASSERT_OK(runOp(insert(fromjson("{_id: 1}"))));
@@ -1135,13 +1140,13 @@ TEST_F(IdempotencyTest, ParallelArrayError) {
     ASSERT_OK(runOps(ops));
     ASSERT_EQUALS(hash, validate());
 
-    ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_PRIMARY);
+    ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_PRIMARY);
     auto status = runOps(ops);
     ASSERT_EQ(status.code(), ErrorCodes::CannotIndexParallelArrays);
 }
 
 TEST_F(IdempotencyTest, IndexKeyTooLongError) {
-    ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+    ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
 
     ASSERT_OK(runOp(createCollection()));
     ASSERT_OK(runOp(insert(fromjson("{_id: 1}"))));
@@ -1161,13 +1166,13 @@ TEST_F(IdempotencyTest, IndexKeyTooLongError) {
     ASSERT_OK(runOps(ops));
     ASSERT_EQUALS(hash, validate());
 
-    ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_PRIMARY);
+    ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_PRIMARY);
     auto status = runOps(ops);
     ASSERT_EQ(status.code(), ErrorCodes::KeyTooLong);
 }
 
 TEST_F(IdempotencyTest, IndexWithDifferentOptions) {
-    ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+    ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
 
     ASSERT_OK(runOp(createCollection()));
     ASSERT_OK(runOp(insert(fromjson("{_id: 1, x: 'hi'}"))));
@@ -1183,13 +1188,13 @@ TEST_F(IdempotencyTest, IndexWithDifferentOptions) {
     ASSERT_OK(runOps(ops));
     ASSERT_EQUALS(hash, validate());
 
-    ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_PRIMARY);
+    ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_PRIMARY);
     auto status = runOps(ops);
     ASSERT_EQ(status.code(), ErrorCodes::IndexOptionsConflict);
 }
 
 TEST_F(IdempotencyTest, TextIndexDocumentHasNonStringLanguageField) {
-    ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+    ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
 
     ASSERT_OK(runOp(createCollection()));
     auto insertOp = insert(fromjson("{_id: 1, x: 'words to index', language: 1}"));
@@ -1203,13 +1208,13 @@ TEST_F(IdempotencyTest, TextIndexDocumentHasNonStringLanguageField) {
     ASSERT_OK(runOps(ops));
     ASSERT_EQUALS(hash, validate());
 
-    ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_PRIMARY);
+    ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_PRIMARY);
     auto status = runOps(ops);
     ASSERT_EQ(status.code(), 17261);
 }
 
 TEST_F(IdempotencyTest, InsertDocumentWithNonStringLanguageFieldWhenTextIndexExists) {
-    ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+    ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
 
     ASSERT_OK(runOp(createCollection()));
     auto indexOp = buildIndex(fromjson("{x: 'text'}"), BSONObj());
@@ -1223,13 +1228,13 @@ TEST_F(IdempotencyTest, InsertDocumentWithNonStringLanguageFieldWhenTextIndexExi
     ASSERT_OK(runOps(ops));
     ASSERT_EQUALS(hash, validate());
 
-    ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_PRIMARY);
+    ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_PRIMARY);
     auto status = runOps(ops);
     ASSERT_EQ(status.code(), 17261);
 }
 
 TEST_F(IdempotencyTest, TextIndexDocumentHasNonStringLanguageOverrideField) {
-    ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+    ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
 
     ASSERT_OK(runOp(createCollection()));
     auto insertOp = insert(fromjson("{_id: 1, x: 'words to index', y: 1}"));
@@ -1243,13 +1248,13 @@ TEST_F(IdempotencyTest, TextIndexDocumentHasNonStringLanguageOverrideField) {
     ASSERT_OK(runOps(ops));
     ASSERT_EQUALS(hash, validate());
 
-    ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_PRIMARY);
+    ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_PRIMARY);
     auto status = runOps(ops);
     ASSERT_EQ(status.code(), 17261);
 }
 
 TEST_F(IdempotencyTest, InsertDocumentWithNonStringLanguageOverrideFieldWhenTextIndexExists) {
-    ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+    ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
 
     ASSERT_OK(runOp(createCollection()));
     auto indexOp = buildIndex(fromjson("{x: 'text'}"), fromjson("{language_override: 'y'}"));
@@ -1263,13 +1268,13 @@ TEST_F(IdempotencyTest, InsertDocumentWithNonStringLanguageOverrideFieldWhenText
     ASSERT_OK(runOps(ops));
     ASSERT_EQUALS(hash, validate());
 
-    ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_PRIMARY);
+    ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_PRIMARY);
     auto status = runOps(ops);
     ASSERT_EQ(status.code(), 17261);
 }
 
 TEST_F(IdempotencyTest, TextIndexDocumentHasUnknownLanguage) {
-    ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+    ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
 
     ASSERT_OK(runOp(createCollection()));
     auto insertOp = insert(fromjson("{_id: 1, x: 'words to index', language: 'bad'}"));
@@ -1283,7 +1288,7 @@ TEST_F(IdempotencyTest, TextIndexDocumentHasUnknownLanguage) {
     ASSERT_OK(runOps(ops));
     ASSERT_EQUALS(hash, validate());
 
-    ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_PRIMARY);
+    ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_PRIMARY);
     auto status = runOps(ops);
     ASSERT_EQ(status.code(), 17262);
 }
@@ -1428,7 +1433,7 @@ TEST_F(IdempotencyTest, CollModIndexNotFound) {
 }
 
 TEST_F(IdempotencyTest, ResyncOnRenameCollection) {
-    ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+    ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
 
     auto cmd = BSON("renameCollection" << nss.ns() << "to"
                                        << "test.bar"
diff --git a/src/mongo/db/repl/task_runner.cpp b/src/mongo/db/repl/task_runner.cpp
index 210718bba3e..d364151a228 100644
--- a/src/mongo/db/repl/task_runner.cpp
+++ b/src/mongo/db/repl/task_runner.cpp
@@ -60,10 +60,10 @@ using LockGuard = stdx::lock_guard<stdx::mutex>;
  * next action of kCancel.
  */
 TaskRunner::NextAction runSingleTask(const TaskRunner::Task& task,
-                                     OperationContext* txn,
+                                     OperationContext* opCtx,
                                      const Status& status) {
     try {
-        return task(txn, status);
+        return task(opCtx, status);
     } catch (...) {
         log() << "Unhandled exception in task runner: " << redact(exceptionToStatus());
     }
@@ -74,7 +74,7 @@ TaskRunner::NextAction runSingleTask(const TaskRunner::Task& task,
 
 // static
 TaskRunner::Task TaskRunner::makeCancelTask() {
-    return [](OperationContext* txn, const Status& status) { return NextAction::kCancel; };
+    return [](OperationContext* opCtx, const Status& status) { return NextAction::kCancel; };
 }
 
 TaskRunner::TaskRunner(OldThreadPool* threadPool)
@@ -132,10 +132,10 @@ void TaskRunner::join() {
 
 void TaskRunner::_runTasks() {
     Client* client = nullptr;
-    ServiceContext::UniqueOperationContext txn;
+    ServiceContext::UniqueOperationContext opCtx;
 
     while (Task task = _waitForNextTask()) {
-        if (!txn) {
+        if (!opCtx) {
             if (!client) {
                 // We initialize cc() because ServiceContextMongoD::_newOpCtx() expects cc()
                 // to be equal to the client used to create the operation context.
@@ -145,13 +145,13 @@ void TaskRunner::_runTasks() {
                     AuthorizationSession::get(client)->grantInternalAuthorization();
                 }
             }
-            txn = client->makeOperationContext();
+            opCtx = client->makeOperationContext();
         }
 
-        NextAction nextAction = runSingleTask(task, txn.get(), Status::OK());
+        NextAction nextAction = runSingleTask(task, opCtx.get(), Status::OK());
 
         if (nextAction != NextAction::kKeepOperationContext) {
-            txn.reset();
+            opCtx.reset();
         }
 
         if (nextAction == NextAction::kCancel) {
@@ -167,7 +167,7 @@ void TaskRunner::_runTasks() {
             }
         }
     }
-    txn.reset();
+    opCtx.reset();
 
     std::list<Task> tasks;
     UniqueLock lk{_mutex};
@@ -221,13 +221,13 @@ Status TaskRunner::runSynchronousTask(SynchronousTask func, TaskRunner::NextActi
     stdx::condition_variable waitTillDoneCond;
 
     Status returnStatus{Status::OK()};
-    this->schedule([&](OperationContext* txn, const Status taskStatus) {
+    this->schedule([&](OperationContext* opCtx, const Status taskStatus) {
         if (!taskStatus.isOK()) {
             returnStatus = taskStatus;
         } else {
             // Run supplied function.
             try {
-                returnStatus = func(txn);
+                returnStatus = func(opCtx);
             } catch (...) {
                 returnStatus = exceptionToStatus();
                 error() << "Exception thrown in runSynchronousTask: " << redact(returnStatus);
diff --git a/src/mongo/db/repl/task_runner.h b/src/mongo/db/repl/task_runner.h
index a8908660c44..b7dcf4c05d6 100644
--- a/src/mongo/db/repl/task_runner.h
+++ b/src/mongo/db/repl/task_runner.h
@@ -59,7 +59,7 @@ public:
     };
 
     using Task = stdx::function<NextAction(OperationContext*, const Status&)>;
-    using SynchronousTask = stdx::function<Status(OperationContext* txn)>;
+    using SynchronousTask = stdx::function<Status(OperationContext* opCtx)>;
 
     /**
      * Returns the Status from the supplied function after running it..
diff --git a/src/mongo/db/repl/task_runner_test.cpp b/src/mongo/db/repl/task_runner_test.cpp
index dedb6269083..62b64513b37 100644
--- a/src/mongo/db/repl/task_runner_test.cpp
+++ b/src/mongo/db/repl/task_runner_test.cpp
@@ -58,12 +58,12 @@ TEST_F(TaskRunnerTest, GetDiagnosticString) {
 TEST_F(TaskRunnerTest, CallbackValues) {
     stdx::mutex mutex;
     bool called = false;
-    OperationContext* txn = nullptr;
+    OperationContext* opCtx = nullptr;
     Status status = getDetectableErrorStatus();
     auto task = [&](OperationContext* theTxn, const Status& theStatus) {
         stdx::lock_guard<stdx::mutex> lk(mutex);
         called = true;
-        txn = theTxn;
+        opCtx = theTxn;
         status = theStatus;
         return TaskRunner::NextAction::kCancel;
     };
@@ -73,7 +73,7 @@ TEST_F(TaskRunnerTest, CallbackValues) {
 
     stdx::lock_guard<stdx::mutex> lk(mutex);
     ASSERT_TRUE(called);
-    ASSERT(txn);
+    ASSERT(opCtx);
     ASSERT_OK(status);
 }
 
@@ -149,7 +149,7 @@ TEST_F(TaskRunnerTest, RunTaskTwiceKeepOperationContext) {
 TEST_F(TaskRunnerTest, SkipSecondTask) {
     stdx::mutex mutex;
     int i = 0;
-    OperationContext* txn[2] = {nullptr, nullptr};
+    OperationContext* opCtx[2] = {nullptr, nullptr};
     Status status[2] = {getDetectableErrorStatus(), getDetectableErrorStatus()};
     stdx::condition_variable condition;
     bool schedulingDone = false;
@@ -159,7 +159,7 @@ TEST_F(TaskRunnerTest, SkipSecondTask) {
         if (j >= 2) {
             return TaskRunner::NextAction::kCancel;
         }
-        txn[j] = theTxn;
+        opCtx[j] = theTxn;
         status[j] = theStatus;
 
         // Wait for the test code to schedule the second task.
@@ -182,16 +182,16 @@ TEST_F(TaskRunnerTest, SkipSecondTask) {
 
     stdx::lock_guard<stdx::mutex> lk(mutex);
     ASSERT_EQUALS(2, i);
-    ASSERT(txn[0]);
+    ASSERT(opCtx[0]);
     ASSERT_OK(status[0]);
-    ASSERT_FALSE(txn[1]);
+    ASSERT_FALSE(opCtx[1]);
     ASSERT_EQUALS(ErrorCodes::CallbackCanceled, status[1].code());
 }
 
 TEST_F(TaskRunnerTest, FirstTaskThrowsException) {
     stdx::mutex mutex;
     int i = 0;
-    OperationContext* txn[2] = {nullptr, nullptr};
+    OperationContext* opCtx[2] = {nullptr, nullptr};
     Status status[2] = {getDetectableErrorStatus(), getDetectableErrorStatus()};
     stdx::condition_variable condition;
     bool schedulingDone = false;
@@ -201,7 +201,7 @@ TEST_F(TaskRunnerTest, FirstTaskThrowsException) {
         if (j >= 2) {
             return TaskRunner::NextAction::kCancel;
         }
-        txn[j] = theTxn;
+        opCtx[j] = theTxn;
         status[j] = theStatus;
 
         // Wait for the test code to schedule the second task.
@@ -231,9 +231,9 @@ TEST_F(TaskRunnerTest, FirstTaskThrowsException) {
 
     stdx::lock_guard<stdx::mutex> lk(mutex);
     ASSERT_EQUALS(2, i);
-    ASSERT(txn[0]);
+    ASSERT(opCtx[0]);
     ASSERT_OK(status[0]);
-    ASSERT_FALSE(txn[1]);
+    ASSERT_FALSE(opCtx[1]);
     ASSERT_EQUALS(ErrorCodes::CallbackCanceled, status[1].code());
 }
author	Maria van Keulen <maria@mongodb.com>	2017-03-07 12:00:08 -0500
committer	Maria van Keulen <maria@mongodb.com>	2017-03-07 12:00:08 -0500
commit	589a5c169ced8f6e9ddcd3d182ae1b75db6b7d79 (patch)
tree	c7a090ffdd56a91ae677e2492c61b820af44f964 /src/mongo/db/repl
parent	3cba97198638df3750e3b455e2ad57af7ee536ae (diff)
download	mongo-589a5c169ced8f6e9ddcd3d182ae1b75db6b7d79.tar.gz