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.

9 files changed, 107 insertions, 105 deletions

diff --git a/src/mongo/s/write_ops/batch_write_exec.cpp b/src/mongo/s/write_ops/batch_write_exec.cpp
index 6a6395eea13..57f84edf800 100644
--- a/src/mongo/s/write_ops/batch_write_exec.cpp
+++ b/src/mongo/s/write_ops/batch_write_exec.cpp
@@ -84,7 +84,7 @@ static void noteStaleResponses(const vector<ShardError*>& staleErrors, NSTargete
 // This only applies when no writes are occurring and metadata is not changing on reload
 static const int kMaxRoundsWithoutProgress(5);
 
-void BatchWriteExec::executeBatch(OperationContext* txn,
+void BatchWriteExec::executeBatch(OperationContext* opCtx,
                                   const BatchedCommandRequest& clientRequest,
                                   BatchedCommandResponse* clientResponse,
                                   BatchWriteExecStats* stats) {
@@ -132,7 +132,7 @@ void BatchWriteExec::executeBatch(OperationContext* txn,
         // record target errors definitively.
         bool recordTargetErrors = refreshedTargeter;
         Status targetStatus =
-            batchOp.targetBatch(txn, *_targeter, recordTargetErrors, &childBatches);
+            batchOp.targetBatch(opCtx, *_targeter, recordTargetErrors, &childBatches);
         if (!targetStatus.isOK()) {
             // Don't do anything until a targeter refresh
             _targeter->noteCouldNotTarget();
@@ -171,8 +171,8 @@ void BatchWriteExec::executeBatch(OperationContext* txn,
 
                 // Figure out what host we need to dispatch our targeted batch
                 const ReadPreferenceSetting readPref(ReadPreference::PrimaryOnly, TagSet());
-                auto shardStatus = Grid::get(txn)->shardRegistry()->getShard(
-                    txn, nextBatch->getEndpoint().shardName);
+                auto shardStatus = Grid::get(opCtx)->shardRegistry()->getShard(
+                    opCtx, nextBatch->getEndpoint().shardName);
 
                 bool resolvedHost = false;
                 ConnectionString shardHost;
@@ -327,7 +327,7 @@ void BatchWriteExec::executeBatch(OperationContext* txn,
         //
 
         bool targeterChanged = false;
-        Status refreshStatus = _targeter->refreshIfNeeded(txn, &targeterChanged);
+        Status refreshStatus = _targeter->refreshIfNeeded(opCtx, &targeterChanged);
 
         if (!refreshStatus.isOK()) {
             // It's okay if we can't refresh, we'll just record errors for the ops if
diff --git a/src/mongo/s/write_ops/batch_write_exec.h b/src/mongo/s/write_ops/batch_write_exec.h
index 739e16a046d..b430e3c5baf 100644
--- a/src/mongo/s/write_ops/batch_write_exec.h
+++ b/src/mongo/s/write_ops/batch_write_exec.h
@@ -72,7 +72,7 @@ public:
      *
      * This function does not throw, any errors are reported via the clientResponse.
      */
-    void executeBatch(OperationContext* txn,
+    void executeBatch(OperationContext* opCtx,
                       const BatchedCommandRequest& clientRequest,
                       BatchedCommandResponse* clientResponse,
                       BatchWriteExecStats* stats);
diff --git a/src/mongo/s/write_ops/batch_write_op.cpp b/src/mongo/s/write_ops/batch_write_op.cpp
index 4f7a4efe52c..6f0aad917b4 100644
--- a/src/mongo/s/write_ops/batch_write_op.cpp
+++ b/src/mongo/s/write_ops/batch_write_op.cpp
@@ -233,7 +233,7 @@ static void cancelBatches(const WriteErrorDetail& why,
     batchMap->clear();
 }
 
-Status BatchWriteOp::targetBatch(OperationContext* txn,
+Status BatchWriteOp::targetBatch(OperationContext* opCtx,
                                  const NSTargeter& targeter,
                                  bool recordTargetErrors,
                                  vector<TargetedWriteBatch*>* targetedBatches) {
@@ -293,7 +293,7 @@ Status BatchWriteOp::targetBatch(OperationContext* txn,
         OwnedPointerVector<TargetedWrite> writesOwned;
         vector<TargetedWrite*>& writes = writesOwned.mutableVector();
 
-        Status targetStatus = writeOp.targetWrites(txn, targeter, &writes);
+        Status targetStatus = writeOp.targetWrites(opCtx, targeter, &writes);
 
         if (!targetStatus.isOK()) {
             WriteErrorDetail targetError;
diff --git a/src/mongo/s/write_ops/batch_write_op.h b/src/mongo/s/write_ops/batch_write_op.h
index 030767851c3..455b84e1cd3 100644
--- a/src/mongo/s/write_ops/batch_write_op.h
+++ b/src/mongo/s/write_ops/batch_write_op.h
@@ -106,7 +106,7 @@ public:
      *
      * Returned TargetedWriteBatches are owned by the caller.
      */
-    Status targetBatch(OperationContext* txn,
+    Status targetBatch(OperationContext* opCtx,
                        const NSTargeter& targeter,
                        bool recordTargetErrors,
                        std::vector<TargetedWriteBatch*>* targetedBatches);
diff --git a/src/mongo/s/write_ops/batch_write_op_test.cpp b/src/mongo/s/write_ops/batch_write_op_test.cpp
index ea50d84a996..e5bc9b5a5cd 100644
--- a/src/mongo/s/write_ops/batch_write_op_test.cpp
+++ b/src/mongo/s/write_ops/batch_write_op_test.cpp
@@ -135,7 +135,7 @@ TEST(WriteOpTests, SingleOp) {
     // Single-op targeting test
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpoint(ShardId("shard"), ChunkVersion::IGNORED());
     MockNSTargeter targeter;
@@ -152,7 +152,7 @@ TEST(WriteOpTests, SingleOp) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     ASSERT(status.isOK());
     ASSERT(!batchOp.isFinished());
@@ -175,7 +175,7 @@ TEST(WriteOpTests, SingleError) {
     // Single-op error test
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpoint(ShardId("shard"), ChunkVersion::IGNORED());
     MockNSTargeter targeter;
@@ -192,7 +192,7 @@ TEST(WriteOpTests, SingleError) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     ASSERT(status.isOK());
     ASSERT(!batchOp.isFinished());
@@ -221,7 +221,7 @@ TEST(WriteOpTests, SingleTargetError) {
     // Single-op targeting error test
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpoint(ShardId("shard"), ChunkVersion::IGNORED());
     MockNSTargeter targeter;
@@ -238,14 +238,14 @@ TEST(WriteOpTests, SingleTargetError) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     ASSERT(!status.isOK());
     ASSERT(!batchOp.isFinished());
     ASSERT_EQUALS(targeted.size(), 0u);
 
     // Record targeting failures
-    status = batchOp.targetBatch(&txn, targeter, true, &targeted);
+    status = batchOp.targetBatch(&opCtx, targeter, true, &targeted);
 
     ASSERT(status.isOK());
     ASSERT(batchOp.isFinished());
@@ -264,7 +264,7 @@ TEST(WriteOpTests, SingleWriteConcernErrorOrdered) {
     // write concern error if one occurs
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpoint(ShardId("shard"), ChunkVersion::IGNORED());
     MockNSTargeter targeter;
@@ -281,7 +281,7 @@ TEST(WriteOpTests, SingleWriteConcernErrorOrdered) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     ASSERT(status.isOK());
     ASSERT(!batchOp.isFinished());
@@ -314,7 +314,7 @@ TEST(WriteOpTests, SingleStaleError) {
     // We should retry the same batch until we're not stale
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpoint(ShardId("shard"), ChunkVersion::IGNORED());
     MockNSTargeter targeter;
@@ -329,7 +329,7 @@ TEST(WriteOpTests, SingleStaleError) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     BatchedCommandResponse response;
     buildResponse(0, &response);
@@ -340,14 +340,14 @@ TEST(WriteOpTests, SingleStaleError) {
     ASSERT(!batchOp.isFinished());
 
     targetedOwned.clear();
-    status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     // Respond again with a stale response
     batchOp.noteBatchResponse(*targeted.front(), response, NULL);
     ASSERT(!batchOp.isFinished());
 
     targetedOwned.clear();
-    status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     buildResponse(1, &response);
 
@@ -381,7 +381,7 @@ TEST(WriteOpTests, MultiOpSameShardOrdered) {
     // Multi-op targeting test (ordered)
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpoint(ShardId("shard"), ChunkVersion::IGNORED());
     MockNSTargeter targeter;
@@ -400,7 +400,7 @@ TEST(WriteOpTests, MultiOpSameShardOrdered) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     ASSERT(status.isOK());
     ASSERT(!batchOp.isFinished());
@@ -425,7 +425,7 @@ TEST(WriteOpTests, MultiOpSameShardUnordered) {
     // Multi-op targeting test (unordered)
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpoint(ShardId("shard"), ChunkVersion::IGNORED());
     MockNSTargeter targeter;
@@ -444,7 +444,7 @@ TEST(WriteOpTests, MultiOpSameShardUnordered) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     ASSERT(status.isOK());
     ASSERT(!batchOp.isFinished());
@@ -470,7 +470,7 @@ TEST(WriteOpTests, MultiOpTwoShardsOrdered) {
     // There should be two sets of single batches (one to each shard, one-by-one)
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpointA(ShardId("shardA"), ChunkVersion::IGNORED());
     ShardEndpoint endpointB(ShardId("shardB"), ChunkVersion::IGNORED());
@@ -490,7 +490,7 @@ TEST(WriteOpTests, MultiOpTwoShardsOrdered) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     ASSERT(status.isOK());
     ASSERT(!batchOp.isFinished());
@@ -506,7 +506,7 @@ TEST(WriteOpTests, MultiOpTwoShardsOrdered) {
     ASSERT(!batchOp.isFinished());
 
     targetedOwned.clear();
-    status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
     ASSERT(status.isOK());
     ASSERT(!batchOp.isFinished());
     ASSERT_EQUALS(targeted.size(), 1u);
@@ -529,7 +529,7 @@ TEST(WriteOpTests, MultiOpTwoShardsUnordered) {
     // There should be one set of two batches (one to each shard)
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpointA(ShardId("shardA"), ChunkVersion::IGNORED());
     ShardEndpoint endpointB(ShardId("shardB"), ChunkVersion::IGNORED());
@@ -549,7 +549,7 @@ TEST(WriteOpTests, MultiOpTwoShardsUnordered) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     ASSERT(status.isOK());
     ASSERT(!batchOp.isFinished());
@@ -581,7 +581,7 @@ TEST(WriteOpTests, MultiOpTwoShardsEachOrdered) {
     // There should be two sets of two batches to each shard (two for each delete op)
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpointA(ShardId("shardA"), ChunkVersion::IGNORED());
     ShardEndpoint endpointB(ShardId("shardB"), ChunkVersion::IGNORED());
@@ -603,7 +603,7 @@ TEST(WriteOpTests, MultiOpTwoShardsEachOrdered) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     ASSERT(status.isOK());
     ASSERT(!batchOp.isFinished());
@@ -624,7 +624,7 @@ TEST(WriteOpTests, MultiOpTwoShardsEachOrdered) {
     ASSERT(!batchOp.isFinished());
 
     targetedOwned.clear();
-    status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
     ASSERT(status.isOK());
     ASSERT(!batchOp.isFinished());
     ASSERT_EQUALS(targeted.size(), 2u);
@@ -652,7 +652,7 @@ TEST(WriteOpTests, MultiOpTwoShardsEachUnordered) {
     // There should be one set of two batches to each shard (containing writes for both ops)
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpointA(ShardId("shardA"), ChunkVersion::IGNORED());
     ShardEndpoint endpointB(ShardId("shardB"), ChunkVersion::IGNORED());
@@ -674,7 +674,7 @@ TEST(WriteOpTests, MultiOpTwoShardsEachUnordered) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     ASSERT(status.isOK());
     ASSERT(!batchOp.isFinished());
@@ -708,7 +708,7 @@ TEST(WriteOpTests, MultiOpOneOrTwoShardsOrdered) {
     // last ops should be batched together
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpointA(ShardId("shardA"), ChunkVersion::IGNORED());
     ShardEndpoint endpointB(ShardId("shardB"), ChunkVersion::IGNORED());
@@ -736,7 +736,7 @@ TEST(WriteOpTests, MultiOpOneOrTwoShardsOrdered) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     ASSERT(status.isOK());
     ASSERT(!batchOp.isFinished());
@@ -753,7 +753,7 @@ TEST(WriteOpTests, MultiOpOneOrTwoShardsOrdered) {
     ASSERT(!batchOp.isFinished());
 
     targetedOwned.clear();
-    status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     ASSERT(status.isOK());
     ASSERT(!batchOp.isFinished());
@@ -774,7 +774,7 @@ TEST(WriteOpTests, MultiOpOneOrTwoShardsOrdered) {
     ASSERT(!batchOp.isFinished());
 
     targetedOwned.clear();
-    status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     ASSERT(status.isOK());
     ASSERT(!batchOp.isFinished());
@@ -792,7 +792,7 @@ TEST(WriteOpTests, MultiOpOneOrTwoShardsOrdered) {
     ASSERT(!batchOp.isFinished());
 
     targetedOwned.clear();
-    status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     ASSERT(status.isOK());
     ASSERT(!batchOp.isFinished());
@@ -820,7 +820,7 @@ TEST(WriteOpTests, MultiOpOneOrTwoShardsUnordered) {
     // Should batch all the ops together into two batches of four ops for each shard
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpointA(ShardId("shardA"), ChunkVersion::IGNORED());
     ShardEndpoint endpointB(ShardId("shardB"), ChunkVersion::IGNORED());
@@ -848,7 +848,7 @@ TEST(WriteOpTests, MultiOpOneOrTwoShardsUnordered) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     ASSERT(status.isOK());
     ASSERT(!batchOp.isFinished());
@@ -882,7 +882,7 @@ TEST(WriteOpTests, MultiOpSingleShardErrorUnordered) {
     // There should be one set of two batches to each shard and an error reported
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpointA(ShardId("shardA"), ChunkVersion::IGNORED());
     ShardEndpoint endpointB(ShardId("shardB"), ChunkVersion::IGNORED());
@@ -901,7 +901,7 @@ TEST(WriteOpTests, MultiOpSingleShardErrorUnordered) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     ASSERT(status.isOK());
     ASSERT(!batchOp.isFinished());
@@ -946,7 +946,7 @@ TEST(WriteOpTests, MultiOpTwoShardErrorsUnordered) {
     // There should be one set of two batches to each shard and and two errors reported
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpointA(ShardId("shardA"), ChunkVersion::IGNORED());
     ShardEndpoint endpointB(ShardId("shardB"), ChunkVersion::IGNORED());
@@ -965,7 +965,7 @@ TEST(WriteOpTests, MultiOpTwoShardErrorsUnordered) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     ASSERT(status.isOK());
     ASSERT(!batchOp.isFinished());
@@ -1013,7 +1013,7 @@ TEST(WriteOpTests, MultiOpPartialSingleShardErrorUnordered) {
     // There should be one set of two batches to each shard and an error reported
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpointA(ShardId("shardA"), ChunkVersion::IGNORED());
     ShardEndpoint endpointB(ShardId("shardB"), ChunkVersion::IGNORED());
@@ -1034,7 +1034,7 @@ TEST(WriteOpTests, MultiOpPartialSingleShardErrorUnordered) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     ASSERT(status.isOK());
     ASSERT(!batchOp.isFinished());
@@ -1080,7 +1080,7 @@ TEST(WriteOpTests, MultiOpPartialSingleShardErrorOrdered) {
     // op should not get run
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpointA(ShardId("shardA"), ChunkVersion::IGNORED());
     ShardEndpoint endpointB(ShardId("shardB"), ChunkVersion::IGNORED());
@@ -1101,7 +1101,7 @@ TEST(WriteOpTests, MultiOpPartialSingleShardErrorOrdered) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     ASSERT(status.isOK());
     ASSERT(!batchOp.isFinished());
@@ -1151,7 +1151,7 @@ TEST(WriteOpTests, MultiOpErrorAndWriteConcernErrorUnordered) {
     // Don't suppress the error if ordered : false
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpoint(ShardId("shard"), ChunkVersion::IGNORED());
     MockNSTargeter targeter;
@@ -1169,7 +1169,7 @@ TEST(WriteOpTests, MultiOpErrorAndWriteConcernErrorUnordered) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     BatchedCommandResponse response;
     buildResponse(1, &response);
@@ -1195,7 +1195,7 @@ TEST(WriteOpTests, SingleOpErrorAndWriteConcernErrorOrdered) {
     // Suppress the write concern error if ordered and we also have an error
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpointA(ShardId("shardA"), ChunkVersion::IGNORED());
     ShardEndpoint endpointB(ShardId("shardB"), ChunkVersion::IGNORED());
@@ -1214,7 +1214,7 @@ TEST(WriteOpTests, SingleOpErrorAndWriteConcernErrorOrdered) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     BatchedCommandResponse response;
     buildResponse(1, &response);
@@ -1246,7 +1246,7 @@ TEST(WriteOpTests, MultiOpFailedTargetOrdered) {
     // Targeting failure on second op in batch op (ordered)
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpoint(ShardId("shard"), ChunkVersion::IGNORED());
     MockNSTargeter targeter;
@@ -1265,14 +1265,14 @@ TEST(WriteOpTests, MultiOpFailedTargetOrdered) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     // First targeting round fails since we may be stale
     ASSERT(!status.isOK());
     ASSERT(!batchOp.isFinished());
 
     targetedOwned.clear();
-    status = batchOp.targetBatch(&txn, targeter, true, &targeted);
+    status = batchOp.targetBatch(&opCtx, targeter, true, &targeted);
 
     // Second targeting round is ok, but should stop at first write
     ASSERT(status.isOK());
@@ -1288,7 +1288,7 @@ TEST(WriteOpTests, MultiOpFailedTargetOrdered) {
     ASSERT(!batchOp.isFinished());
 
     targetedOwned.clear();
-    status = batchOp.targetBatch(&txn, targeter, true, &targeted);
+    status = batchOp.targetBatch(&opCtx, targeter, true, &targeted);
 
     // Second targeting round results in an error which finishes the batch
     ASSERT(status.isOK());
@@ -1309,7 +1309,7 @@ TEST(WriteOpTests, MultiOpFailedTargetUnordered) {
     // Targeting failure on second op in batch op (unordered)
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpoint(ShardId("shard"), ChunkVersion::IGNORED());
     MockNSTargeter targeter;
@@ -1329,14 +1329,14 @@ TEST(WriteOpTests, MultiOpFailedTargetUnordered) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     // First targeting round fails since we may be stale
     ASSERT(!status.isOK());
     ASSERT(!batchOp.isFinished());
 
     targetedOwned.clear();
-    status = batchOp.targetBatch(&txn, targeter, true, &targeted);
+    status = batchOp.targetBatch(&opCtx, targeter, true, &targeted);
 
     // Second targeting round is ok, and should record an error
     ASSERT(status.isOK());
@@ -1366,7 +1366,7 @@ TEST(WriteOpTests, MultiOpFailedBatchOrdered) {
     // Expect this gets translated down into write errors for first affected write
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpointA(ShardId("shardA"), ChunkVersion::IGNORED());
     ShardEndpoint endpointB(ShardId("shardB"), ChunkVersion::IGNORED());
@@ -1384,7 +1384,7 @@ TEST(WriteOpTests, MultiOpFailedBatchOrdered) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     BatchedCommandResponse response;
     buildResponse(1, &response);
@@ -1394,7 +1394,7 @@ TEST(WriteOpTests, MultiOpFailedBatchOrdered) {
     ASSERT(!batchOp.isFinished());
 
     targetedOwned.clear();
-    status = batchOp.targetBatch(&txn, targeter, true, &targeted);
+    status = batchOp.targetBatch(&opCtx, targeter, true, &targeted);
 
     buildErrResponse(ErrorCodes::UnknownError, "mock error", &response);
 
@@ -1419,7 +1419,7 @@ TEST(WriteOpTests, MultiOpFailedBatchUnordered) {
     // Expect this gets translated down into write errors for all affected writes
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpointA(ShardId("shardA"), ChunkVersion::IGNORED());
     ShardEndpoint endpointB(ShardId("shardB"), ChunkVersion::IGNORED());
@@ -1438,7 +1438,7 @@ TEST(WriteOpTests, MultiOpFailedBatchUnordered) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     BatchedCommandResponse response;
     buildResponse(1, &response);
@@ -1472,7 +1472,7 @@ TEST(WriteOpTests, MultiOpAbortOrdered) {
     // Expect this gets translated down into write error for first affected write
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpointA(ShardId("shardA"), ChunkVersion::IGNORED());
     ShardEndpoint endpointB(ShardId("shardB"), ChunkVersion::IGNORED());
@@ -1490,7 +1490,7 @@ TEST(WriteOpTests, MultiOpAbortOrdered) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     BatchedCommandResponse response;
     buildResponse(1, &response);
@@ -1522,7 +1522,7 @@ TEST(WriteOpTests, MultiOpAbortUnordered) {
     // Expect this gets translated down into write errors for all affected writes
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpointA(ShardId("shardA"), ChunkVersion::IGNORED());
     ShardEndpoint endpointB(ShardId("shardB"), ChunkVersion::IGNORED());
@@ -1563,7 +1563,7 @@ TEST(WriteOpTests, MultiOpTwoWCErrors) {
     // error
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpointA(ShardId("shardA"), ChunkVersion::IGNORED());
     ShardEndpoint endpointB(ShardId("shardB"), ChunkVersion::IGNORED());
@@ -1581,7 +1581,7 @@ TEST(WriteOpTests, MultiOpTwoWCErrors) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
 
     BatchedCommandResponse response;
     buildResponse(1, &response);
@@ -1592,7 +1592,7 @@ TEST(WriteOpTests, MultiOpTwoWCErrors) {
     ASSERT(!batchOp.isFinished());
 
     targetedOwned.clear();
-    status = batchOp.targetBatch(&txn, targeter, true, &targeted);
+    status = batchOp.targetBatch(&opCtx, targeter, true, &targeted);
 
     // Second shard write write concern fails.
     batchOp.noteBatchResponse(*targeted.front(), response, NULL);
@@ -1615,7 +1615,7 @@ TEST(WriteOpLimitTests, OneBigDoc) {
     // Big single operation test - should go through
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpoint(ShardId("shard"), ChunkVersion::IGNORED());
     MockNSTargeter targeter;
@@ -1634,7 +1634,7 @@ TEST(WriteOpLimitTests, OneBigDoc) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
     ASSERT(status.isOK());
     ASSERT_EQUALS(targeted.size(), 1u);
 
@@ -1650,7 +1650,7 @@ TEST(WriteOpLimitTests, OneBigOneSmall) {
     // Big doc with smaller additional doc - should go through as two batches
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpoint(ShardId("shard"), ChunkVersion::IGNORED());
     MockNSTargeter targeter;
@@ -1671,7 +1671,7 @@ TEST(WriteOpLimitTests, OneBigOneSmall) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
     ASSERT(status.isOK());
     ASSERT_EQUALS(targeted.size(), 1u);
     ASSERT_EQUALS(targeted.front()->getWrites().size(), 1u);
@@ -1683,7 +1683,7 @@ TEST(WriteOpLimitTests, OneBigOneSmall) {
     ASSERT(!batchOp.isFinished());
 
     targetedOwned.clear();
-    status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
     ASSERT(status.isOK());
     ASSERT_EQUALS(targeted.size(), 1u);
     ASSERT_EQUALS(targeted.front()->getWrites().size(), 1u);
@@ -1697,7 +1697,7 @@ TEST(WriteOpLimitTests, TooManyOps) {
     // Batch of 1002 documents
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpoint(ShardId("shard"), ChunkVersion::IGNORED());
     MockNSTargeter targeter;
@@ -1716,7 +1716,7 @@ TEST(WriteOpLimitTests, TooManyOps) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
     ASSERT(status.isOK());
     ASSERT_EQUALS(targeted.size(), 1u);
     ASSERT_EQUALS(targeted.front()->getWrites().size(), 1000u);
@@ -1728,7 +1728,7 @@ TEST(WriteOpLimitTests, TooManyOps) {
     ASSERT(!batchOp.isFinished());
 
     targetedOwned.clear();
-    status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
     ASSERT(status.isOK());
     ASSERT_EQUALS(targeted.size(), 1u);
     ASSERT_EQUALS(targeted.front()->getWrites().size(), 2u);
@@ -1743,7 +1743,7 @@ TEST(WriteOpLimitTests, UpdateOverheadIncluded) {
     // calculation
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
     ShardEndpoint endpoint(ShardId("shard"), ChunkVersion::IGNORED());
     MockNSTargeter targeter;
@@ -1780,7 +1780,7 @@ TEST(WriteOpLimitTests, UpdateOverheadIncluded) {
 
     OwnedPointerVector<TargetedWriteBatch> targetedOwned;
     vector<TargetedWriteBatch*>& targeted = targetedOwned.mutableVector();
-    Status status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    Status status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
     ASSERT(status.isOK());
     ASSERT_EQUALS(targeted.size(), 1u);
     ASSERT_LESS_THAN(targeted.front()->getWrites().size(), 1000u);
@@ -1796,7 +1796,7 @@ TEST(WriteOpLimitTests, UpdateOverheadIncluded) {
     ASSERT(!batchOp.isFinished());
 
     targetedOwned.clear();
-    status = batchOp.targetBatch(&txn, targeter, false, &targeted);
+    status = batchOp.targetBatch(&opCtx, targeter, false, &targeted);
     ASSERT(status.isOK());
     ASSERT_EQUALS(targeted.size(), 1u);
     ASSERT_LESS_THAN(targeted.front()->getWrites().size(), 1000u);
diff --git a/src/mongo/s/write_ops/mock_ns_targeter.h b/src/mongo/s/write_ops/mock_ns_targeter.h
index 44bc5be18c2..a430e3caa7d 100644
--- a/src/mongo/s/write_ops/mock_ns_targeter.h
+++ b/src/mongo/s/write_ops/mock_ns_targeter.h
@@ -85,7 +85,9 @@ public:
     /**
      * Returns a ShardEndpoint for the doc from the mock ranges
      */
-    Status targetInsert(OperationContext* txn, const BSONObj& doc, ShardEndpoint** endpoint) const {
+    Status targetInsert(OperationContext* opCtx,
+                        const BSONObj& doc,
+                        ShardEndpoint** endpoint) const {
         std::vector<ShardEndpoint*> endpoints;
         Status status = targetQuery(doc, &endpoints);
         if (!status.isOK())
@@ -99,7 +101,7 @@ public:
      * Returns the first ShardEndpoint for the query from the mock ranges.  Only can handle
      * queries of the form { field : { $gte : <value>, $lt : <value> } }.
      */
-    Status targetUpdate(OperationContext* txn,
+    Status targetUpdate(OperationContext* opCtx,
                         const BatchedUpdateDocument& updateDoc,
                         std::vector<ShardEndpoint*>* endpoints) const {
         return targetQuery(updateDoc.getQuery(), endpoints);
@@ -109,7 +111,7 @@ public:
      * Returns the first ShardEndpoint for the query from the mock ranges.  Only can handle
      * queries of the form { field : { $gte : <value>, $lt : <value> } }.
      */
-    Status targetDelete(OperationContext* txn,
+    Status targetDelete(OperationContext* opCtx,
                         const BatchedDeleteDocument& deleteDoc,
                         std::vector<ShardEndpoint*>* endpoints) const {
         return targetQuery(deleteDoc.getQuery(), endpoints);
@@ -140,7 +142,7 @@ public:
         // No-op
     }
 
-    Status refreshIfNeeded(OperationContext* txn, bool* wasChanged) {
+    Status refreshIfNeeded(OperationContext* opCtx, bool* wasChanged) {
         // No-op
         if (wasChanged)
             *wasChanged = false;
diff --git a/src/mongo/s/write_ops/write_op.cpp b/src/mongo/s/write_ops/write_op.cpp
index 25f9f13b3aa..6f58a58a124 100644
--- a/src/mongo/s/write_ops/write_op.cpp
+++ b/src/mongo/s/write_ops/write_op.cpp
@@ -65,7 +65,7 @@ const WriteErrorDetail& WriteOp::getOpError() const {
     return *_error;
 }
 
-Status WriteOp::targetWrites(OperationContext* txn,
+Status WriteOp::targetWrites(OperationContext* opCtx,
                              const NSTargeter& targeter,
                              std::vector<TargetedWrite*>* targetedWrites) {
     bool isUpdate = _itemRef.getOpType() == BatchedCommandRequest::BatchType_Update;
@@ -77,16 +77,16 @@ Status WriteOp::targetWrites(OperationContext* txn,
     vector<ShardEndpoint*>& endpoints = endpointsOwned.mutableVector();
 
     if (isUpdate) {
-        targetStatus = targeter.targetUpdate(txn, *_itemRef.getUpdate(), &endpoints);
+        targetStatus = targeter.targetUpdate(opCtx, *_itemRef.getUpdate(), &endpoints);
     } else if (isDelete) {
-        targetStatus = targeter.targetDelete(txn, *_itemRef.getDelete(), &endpoints);
+        targetStatus = targeter.targetDelete(opCtx, *_itemRef.getDelete(), &endpoints);
     } else {
         dassert(_itemRef.getOpType() == BatchedCommandRequest::BatchType_Insert);
 
         ShardEndpoint* endpoint = NULL;
         // TODO: Remove the index targeting stuff once there is a command for it
         if (!isIndexInsert) {
-            targetStatus = targeter.targetInsert(txn, _itemRef.getDocument(), &endpoint);
+            targetStatus = targeter.targetInsert(opCtx, _itemRef.getDocument(), &endpoint);
         } else {
             // TODO: Retry index writes with stale version?
             targetStatus = targeter.targetCollection(&endpoints);
diff --git a/src/mongo/s/write_ops/write_op.h b/src/mongo/s/write_ops/write_op.h
index d56be517fe7..1be62c36d0e 100644
--- a/src/mongo/s/write_ops/write_op.h
+++ b/src/mongo/s/write_ops/write_op.h
@@ -122,7 +122,7 @@ public:
      * Returns !OK if the targeting process itself fails
      *             (no TargetedWrites will be added, state unchanged)
      */
-    Status targetWrites(OperationContext* txn,
+    Status targetWrites(OperationContext* opCtx,
                         const NSTargeter& targeter,
                         std::vector<TargetedWrite*>* targetedWrites);
 
diff --git a/src/mongo/s/write_ops/write_op_test.cpp b/src/mongo/s/write_ops/write_op_test.cpp
index c54d4f7070a..b780a79a344 100644
--- a/src/mongo/s/write_ops/write_op_test.cpp
+++ b/src/mongo/s/write_ops/write_op_test.cpp
@@ -83,7 +83,7 @@ TEST(WriteOpTests, TargetSingle) {
     // Basic targeting test
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
 
     ShardEndpoint endpoint(ShardId("shard"), ChunkVersion::IGNORED());
@@ -105,7 +105,7 @@ TEST(WriteOpTests, TargetSingle) {
 
     OwnedPointerVector<TargetedWrite> targetedOwned;
     vector<TargetedWrite*>& targeted = targetedOwned.mutableVector();
-    Status status = writeOp.targetWrites(&txn, targeter, &targeted);
+    Status status = writeOp.targetWrites(&opCtx, targeter, &targeted);
 
     ASSERT(status.isOK());
     ASSERT_EQUALS(writeOp.getWriteState(), WriteOpState_Pending);
@@ -141,7 +141,7 @@ TEST(WriteOpTests, TargetMultiOneShard) {
     // Multi-write targeting test where our query goes to one shard
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
 
     ShardEndpoint endpointA(ShardId("shardA"), ChunkVersion(10, 0, OID()));
@@ -167,7 +167,7 @@ TEST(WriteOpTests, TargetMultiOneShard) {
 
     OwnedPointerVector<TargetedWrite> targetedOwned;
     vector<TargetedWrite*>& targeted = targetedOwned.mutableVector();
-    Status status = writeOp.targetWrites(&txn, targeter, &targeted);
+    Status status = writeOp.targetWrites(&opCtx, targeter, &targeted);
 
     ASSERT(status.isOK());
     ASSERT_EQUALS(writeOp.getWriteState(), WriteOpState_Pending);
@@ -184,7 +184,7 @@ TEST(WriteOpTests, TargetMultiAllShards) {
     // Multi-write targeting test where our write goes to more than one shard
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
 
     ShardEndpoint endpointA(ShardId("shardA"), ChunkVersion(10, 0, OID()));
@@ -211,7 +211,7 @@ TEST(WriteOpTests, TargetMultiAllShards) {
 
     OwnedPointerVector<TargetedWrite> targetedOwned;
     vector<TargetedWrite*>& targeted = targetedOwned.mutableVector();
-    Status status = writeOp.targetWrites(&txn, targeter, &targeted);
+    Status status = writeOp.targetWrites(&opCtx, targeter, &targeted);
 
     ASSERT(status.isOK());
     ASSERT_EQUALS(writeOp.getWriteState(), WriteOpState_Pending);
@@ -236,7 +236,7 @@ TEST(WriteOpTests, ErrorSingle) {
     // Single error after targeting test
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
 
     ShardEndpoint endpoint(ShardId("shard"), ChunkVersion::IGNORED());
@@ -258,7 +258,7 @@ TEST(WriteOpTests, ErrorSingle) {
 
     OwnedPointerVector<TargetedWrite> targetedOwned;
     vector<TargetedWrite*>& targeted = targetedOwned.mutableVector();
-    Status status = writeOp.targetWrites(&txn, targeter, &targeted);
+    Status status = writeOp.targetWrites(&opCtx, targeter, &targeted);
 
     ASSERT(status.isOK());
     ASSERT_EQUALS(writeOp.getWriteState(), WriteOpState_Pending);
@@ -282,7 +282,7 @@ TEST(WriteOpTests, CancelSingle) {
     // Cancel single targeting test
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
 
     ShardEndpoint endpoint(ShardId("shard"), ChunkVersion::IGNORED());
@@ -304,7 +304,7 @@ TEST(WriteOpTests, CancelSingle) {
 
     OwnedPointerVector<TargetedWrite> targetedOwned;
     vector<TargetedWrite*>& targeted = targetedOwned.mutableVector();
-    Status status = writeOp.targetWrites(&txn, targeter, &targeted);
+    Status status = writeOp.targetWrites(&opCtx, targeter, &targeted);
 
     ASSERT(status.isOK());
     ASSERT_EQUALS(writeOp.getWriteState(), WriteOpState_Pending);
@@ -325,7 +325,7 @@ TEST(WriteOpTests, RetrySingleOp) {
     // Retry single targeting test
     //
 
-    OperationContextNoop txn;
+    OperationContextNoop opCtx;
     NamespaceString nss("foo.bar");
 
     ShardEndpoint endpoint(ShardId("shard"), ChunkVersion::IGNORED());
@@ -347,7 +347,7 @@ TEST(WriteOpTests, RetrySingleOp) {
 
     OwnedPointerVector<TargetedWrite> targetedOwned;
     vector<TargetedWrite*>& targeted = targetedOwned.mutableVector();
-    Status status = writeOp.targetWrites(&txn, targeter, &targeted);
+    Status status = writeOp.targetWrites(&opCtx, targeter, &targeted);
 
     ASSERT(status.isOK());
     ASSERT_EQUALS(writeOp.getWriteState(), WriteOpState_Pending);