diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/DeadServer.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/DeadServer.java
index 9467512fc66c..38f40b248262 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/DeadServer.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/DeadServer.java
@@ -75,6 +75,10 @@ synchronized void putIfAbsent(ServerName sn) {
     this.deadServers.putIfAbsent(sn, EnvironmentEdgeManager.currentTime());
   }
 
+  synchronized void putIfAbsent(ServerName sn, Long crashedTime) {
+    this.deadServers.putIfAbsent(sn, crashedTime);
+  }
+
   public synchronized int size() {
     return deadServers.size();
   }
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/HMaster.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/HMaster.java
index f8abca44e4c5..5f4aeee73ce9 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/HMaster.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/HMaster.java
@@ -1033,6 +1033,9 @@ private void finishActiveMasterInitialization() throws IOException, InterruptedE
     Map<Class<?>, List<Procedure<MasterProcedureEnv>>> procsByType = procedureExecutor
       .getActiveProceduresNoCopy().stream().collect(Collectors.groupingBy(p -> p.getClass()));
 
+    // This manager must be accessed AFTER hbase:meta is confirmed on line.. and must be initialised
+    // before assignment manager
+    this.tableStateManager = new TableStateManager(this);
     // Create Assignment Manager
     this.assignmentManager = createAssignmentManager(this, masterRegion);
     this.assignmentManager.start();
@@ -1053,11 +1056,10 @@ private void finishActiveMasterInitialization() throws IOException, InterruptedE
     // TODO: Generate the splitting and live Set in one pass instead of two as we currently do.
     this.regionServerTracker.upgrade(
       procsByType.getOrDefault(ServerCrashProcedure.class, Collections.emptyList()).stream()
-        .map(p -> (ServerCrashProcedure) p).map(p -> p.getServerName()).collect(Collectors.toSet()),
+        .map(p -> (ServerCrashProcedure) p).collect(
+          Collectors.toMap(ServerCrashProcedure::getServerName, Procedure::getSubmittedTime)),
       Sets.union(rsListStorage.getAll(), walManager.getLiveServersFromWALDir()),
       walManager.getSplittingServersFromWALDir());
-    // This manager must be accessed AFTER hbase:meta is confirmed on line..
-    this.tableStateManager = new TableStateManager(this);
 
     startupTaskGroup.addTask("Initializing ZK system trackers");
     initializeZKBasedSystemTrackers();
@@ -2007,7 +2009,7 @@ private void balanceThrottling(long nextBalanceStartTime, int maxRegionsInTransi
     // But if there are zero regions in transition, it can skip sleep to speed up.
     while (
       !interrupted && EnvironmentEdgeManager.currentTime() < nextBalanceStartTime
-        && this.assignmentManager.getRegionStates().hasRegionsInTransition()
+        && this.assignmentManager.getRegionTransitScheduledCount() > 0
     ) {
       try {
         Thread.sleep(100);
@@ -2019,8 +2021,7 @@ private void balanceThrottling(long nextBalanceStartTime, int maxRegionsInTransi
     // Throttling by max number regions in transition
     while (
       !interrupted && maxRegionsInTransition > 0
-        && this.assignmentManager.getRegionStates().getRegionsInTransitionCount()
-            >= maxRegionsInTransition
+        && this.assignmentManager.getRegionTransitScheduledCount() >= maxRegionsInTransition
         && EnvironmentEdgeManager.currentTime() <= cutoffTime
     ) {
       try {
@@ -2099,7 +2100,7 @@ public BalanceResponse balance(BalanceRequest request) throws IOException {
 
     synchronized (this.balancer) {
       // Only allow one balance run at at time.
-      if (this.assignmentManager.hasRegionsInTransition()) {
+      if (this.assignmentManager.getRegionTransitScheduledCount() > 0) {
         List<RegionStateNode> regionsInTransition = assignmentManager.getRegionsInTransition();
         // if hbase:meta region is in transition, result of assignment cannot be recorded
         // ignore the force flag in that case
@@ -2114,8 +2115,8 @@ public BalanceResponse balance(BalanceRequest request) throws IOException {
 
         if (!request.isIgnoreRegionsInTransition() || metaInTransition) {
           LOG.info("Not running balancer (ignoreRIT=false" + ", metaRIT=" + metaInTransition
-            + ") because " + regionsInTransition.size() + " region(s) in transition: " + toPrint
-            + (truncated ? "(truncated list)" : ""));
+            + ") because " + assignmentManager.getRegionTransitScheduledCount()
+            + " region(s) in transition: " + toPrint + (truncated ? "(truncated list)" : ""));
           return responseBuilder.build();
         }
       }
@@ -2251,7 +2252,7 @@ public boolean normalizeRegions(final NormalizeTableFilterParams ntfp,
     if (skipRegionManagementAction("region normalizer")) {
       return false;
     }
-    if (assignmentManager.hasRegionsInTransition()) {
+    if (assignmentManager.getRegionTransitScheduledCount() > 0) {
       return false;
     }
 
@@ -3081,7 +3082,7 @@ public ClusterMetrics getClusterMetricsWithoutCoprocessor(EnumSet<Option> option
         case REGIONS_IN_TRANSITION: {
           if (assignmentManager != null) {
             builder.setRegionsInTransition(
-              assignmentManager.getRegionStates().getRegionsStateInTransition());
+              new ArrayList<>(assignmentManager.getRegionsStateInTransition()));
           }
           break;
         }
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/RegionServerTracker.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/RegionServerTracker.java
index a09f6689a5c1..ff1bff804ee5 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/RegionServerTracker.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/RegionServerTracker.java
@@ -24,6 +24,7 @@
 import java.io.InterruptedIOException;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -116,14 +117,15 @@ private RegionServerInfo getServerInfo(ServerName serverName)
    * In this method, we will also construct the region server sets in {@link ServerManager}. If a
    * region server is dead between the crash of the previous master instance and the start of the
    * current master instance, we will schedule a SCP for it. This is done in
-   * {@link ServerManager#findDeadServersAndProcess(Set, Set)}, we call it here under the lock
+   * {@link ServerManager#findDeadServersAndProcess(Map, Set)}, we call it here under the lock
    * protection to prevent concurrency issues with server expiration operation.
    * @param deadServersFromPE          the region servers which already have SCP associated.
    * @param liveServersBeforeRestart   the live region servers we recorded before master restarts.
    * @param splittingServersFromWALDir Servers whose WALs are being actively 'split'.
    */
-  public void upgrade(Set<ServerName> deadServersFromPE, Set<ServerName> liveServersBeforeRestart,
-    Set<ServerName> splittingServersFromWALDir) throws KeeperException, IOException {
+  public void upgrade(Map<ServerName, Long> deadServersFromPE,
+    Set<ServerName> liveServersBeforeRestart, Set<ServerName> splittingServersFromWALDir)
+    throws KeeperException, IOException {
     LOG.info(
       "Upgrading RegionServerTracker to active master mode; {} have existing"
         + "ServerCrashProcedures, {} possibly 'live' servers, and {} 'splitting'.",
@@ -131,7 +133,7 @@ public void upgrade(Set<ServerName> deadServersFromPE, Set<ServerName> liveServe
     // deadServersFromPE is made from a list of outstanding ServerCrashProcedures.
     // splittingServersFromWALDir are being actively split -- the directory in the FS ends in
     // '-SPLITTING'. Each splitting server should have a corresponding SCP. Log if not.
-    splittingServersFromWALDir.stream().filter(s -> !deadServersFromPE.contains(s))
+    splittingServersFromWALDir.stream().filter(s -> !deadServersFromPE.containsKey(s))
       .forEach(s -> LOG.error("{} has no matching ServerCrashProcedure", s));
     // create ServerNode for all possible live servers from wal directory and master local region
     liveServersBeforeRestart
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/ServerManager.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/ServerManager.java
index b99f0448e8f0..2038f5474398 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/ServerManager.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/ServerManager.java
@@ -440,7 +440,7 @@ boolean checkAndRecordNewServer(final ServerName serverName, final ServerMetrics
    * @param deadServersFromPE     the region servers which already have a SCP associated.
    * @param liveServersFromWALDir the live region servers from wal directory.
    */
-  void findDeadServersAndProcess(Set<ServerName> deadServersFromPE,
+  void findDeadServersAndProcess(Map<ServerName, Long> deadServersFromPE,
     Set<ServerName> liveServersFromWALDir) {
     deadServersFromPE.forEach(deadservers::putIfAbsent);
     liveServersFromWALDir.stream().filter(sn -> !onlineServers.containsKey(sn))
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/AssignmentManager.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/AssignmentManager.java
index 8c37385757a7..9d60a2fa728a 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/AssignmentManager.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/AssignmentManager.java
@@ -22,11 +22,15 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.Comparator;
+import java.util.Date;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
@@ -232,12 +236,15 @@ public class AssignmentManager {
 
   private final int forceRegionRetainmentRetries;
 
+  private final RegionInTransitionTracker regionInTransitionTracker;
+
   public AssignmentManager(MasterServices master, MasterRegion masterRegion) {
     this(master, masterRegion, new RegionStateStore(master, masterRegion));
   }
 
   AssignmentManager(MasterServices master, MasterRegion masterRegion, RegionStateStore stateStore) {
     this.master = master;
+    regionInTransitionTracker = new RegionInTransitionTracker(master.getTableStateManager());
     this.regionStateStore = stateStore;
     this.metrics = new MetricsAssignmentManager();
     this.masterRegion = masterRegion;
@@ -331,6 +338,8 @@ public void start() throws IOException, KeeperException {
             regionNode.setLastHost(lastHost);
             regionNode.setRegionLocation(regionLocation);
             regionNode.setOpenSeqNum(openSeqNum);
+            regionInTransitionTracker.handleRegionStateNodeOperation(regionNode);
+
             if (regionNode.getProcedure() != null) {
               regionNode.getProcedure().stateLoaded(this, regionNode);
             }
@@ -382,7 +391,7 @@ public void setupRIT(List<TransitRegionStateProcedure> procs) {
           return;
         }
       }
-      LOG.info("Attach {} to {} to restore RIT", proc, regionNode);
+      LOG.info("Attach {} to {} to restore", proc, regionNode);
       regionNode.setProcedure(proc);
     });
   }
@@ -411,6 +420,7 @@ public void stop() {
 
     // Stop the RegionStateStore
     regionStates.clear();
+    regionInTransitionTracker.stop();
 
     // Update meta events (for testing)
     if (hasProcExecutor) {
@@ -1093,7 +1103,7 @@ private int submitUnassignProcedure(TableName tableName,
       regionNode.lock();
       try {
         if (shouldSubmit.apply(regionNode)) {
-          if (regionNode.isInTransition()) {
+          if (regionNode.isTransitionScheduled()) {
             logRIT.accept(regionNode);
             inTransitionCount++;
             continue;
@@ -1702,10 +1712,8 @@ public boolean isRegionTwiceOverThreshold(final RegionInfo regionInfo) {
     }
 
     protected void update(final AssignmentManager am) {
-      final RegionStates regionStates = am.getRegionStates();
       this.statTimestamp = EnvironmentEdgeManager.currentTime();
-      update(regionStates.getRegionsStateInTransition(), statTimestamp);
-      update(regionStates.getRegionFailedOpen(), statTimestamp);
+      update(am.getRegionsStateInTransition(), statTimestamp);
 
       if (LOG.isDebugEnabled() && ritsOverThreshold != null && !ritsOverThreshold.isEmpty()) {
         LOG.debug("RITs over threshold: {}",
@@ -1873,6 +1881,20 @@ public void visitRegionState(Result result, final RegionInfo regionInfo, final S
       if (regionNode.getProcedure() != null) {
         regionNode.getProcedure().stateLoaded(AssignmentManager.this, regionNode);
       }
+      // add regions to RIT while visiting the meta
+      regionInTransitionTracker.handleRegionStateNodeOperation(regionNode);
+      // If region location of region belongs to a dead server mark the region crashed
+      if (
+        regionNode.getRegionLocation() != null
+          && master.getServerManager().isServerDead(regionNode.getRegionLocation())
+      ) {
+        Date timeOfCrash =
+          master.getServerManager().getDeadServers().getTimeOfDeath(regionNode.getRegionLocation());
+        if (timeOfCrash != null) {
+          regionNode.crashed(timeOfCrash.getTime());
+        }
+        regionInTransitionTracker.regionCrashed(regionNode);
+      }
     }
   };
 
@@ -2046,15 +2068,52 @@ public Pair<Integer, Integer> getReopenStatus(TableName tableName) {
     return new Pair<Integer, Integer>(ritCount, states.size());
   }
 
+  // This comparator sorts the RegionStates by time stamp then Region name.
+  // Comparing by timestamp alone can lead us to discard different RegionStates that happen
+  // to share a timestamp.
+  private final static class RegionStateStampComparator implements Comparator<RegionState> {
+    @Override
+    public int compare(final RegionState l, final RegionState r) {
+      int stampCmp = Long.compare(l.getStamp(), r.getStamp());
+      return stampCmp != 0 ? stampCmp : RegionInfo.COMPARATOR.compare(l.getRegion(), r.getRegion());
+    }
+  }
+
+  public final static RegionStateStampComparator REGION_STATE_STAMP_COMPARATOR =
+    new RegionStateStampComparator();
+
   // ============================================================================================
   // TODO: Region State In Transition
   // ============================================================================================
   public boolean hasRegionsInTransition() {
-    return regionStates.hasRegionsInTransition();
+    return regionInTransitionTracker.hasRegionsInTransition();
   }
 
   public List<RegionStateNode> getRegionsInTransition() {
-    return regionStates.getRegionsInTransition();
+    return regionInTransitionTracker.getRegionsInTransition();
+  }
+
+  public boolean isRegionInTransition(final RegionInfo regionInfo) {
+    return regionInTransitionTracker.isRegionInTransition(regionInfo);
+  }
+
+  public int getRegionTransitScheduledCount() {
+    return regionStates.getRegionTransitScheduledCount();
+  }
+
+  /**
+   * Get the number of regions in transition.
+   */
+  public int getRegionsInTransitionCount() {
+    return regionInTransitionTracker.getRegionsInTransition().size();
+  }
+
+  public SortedSet<RegionState> getRegionsStateInTransition() {
+    final SortedSet<RegionState> rit = new TreeSet<RegionState>(REGION_STATE_STAMP_COMPARATOR);
+    for (RegionStateNode node : getRegionsInTransition()) {
+      rit.add(node.toRegionState());
+    }
+    return rit;
   }
 
   public List<RegionInfo> getAssignedRegions() {
@@ -2122,6 +2181,8 @@ private CompletableFuture<Void> transitStateAndUpdate(RegionStateNode regionNode
       if (e != null) {
         // revert
         regionNode.setState(state);
+      } else {
+        regionInTransitionTracker.handleRegionStateNodeOperation(regionNode);
       }
     });
     return future;
@@ -2170,6 +2231,7 @@ CompletableFuture<Void> regionFailedOpen(RegionStateNode regionNode, boolean giv
         if (regionLocation != null) {
           regionStates.removeRegionFromServer(regionLocation, regionNode);
         }
+        regionInTransitionTracker.handleRegionStateNodeOperation(regionNode);
       } else {
         // revert
         regionNode.setState(state);
@@ -2230,6 +2292,7 @@ CompletableFuture<Void> persistToMeta(RegionStateNode regionNode) {
         // on table that contains state.
         setMetaAssigned(regionInfo, true);
       }
+      regionInTransitionTracker.handleRegionStateNodeOperation(regionNode);
     });
   }
 
@@ -2247,6 +2310,7 @@ public CompletableFuture<Void> regionClosedAbnormally(RegionStateNode regionNode
           regionNode.setLastHost(regionLocation);
           regionStates.removeRegionFromServer(regionLocation, regionNode);
         }
+        regionInTransitionTracker.handleRegionStateNodeOperation(regionNode);
       } else {
         // revert
         regionNode.setState(state);
@@ -2260,6 +2324,20 @@ public CompletableFuture<Void> regionClosedAbnormally(RegionStateNode regionNode
   // The above methods can only be called in TransitRegionStateProcedure(and related procedures)
   // ============================================================================================
 
+  // As soon as a server a crashed, region hosting on that are un-available, this method helps to
+  // track those un-available regions. This method can only be called from ServerCrashProcedure.
+  public void markRegionsAsCrashed(List<RegionInfo> regionsOnCrashedServer,
+    ServerCrashProcedure scp) {
+    ServerName crashedServerName = scp.getServerName();
+    for (RegionInfo regionInfo : regionsOnCrashedServer) {
+      RegionStateNode node = regionStates.getOrCreateRegionStateNode(regionInfo);
+      if (node.getRegionLocation() == crashedServerName) {
+        node.crashed(scp.getSubmittedTime());
+        regionInTransitionTracker.regionCrashed(node);
+      }
+    }
+  }
+
   public void markRegionAsSplit(final RegionInfo parent, final ServerName serverName,
     final RegionInfo daughterA, final RegionInfo daughterB) throws IOException {
     // Update hbase:meta. Parent will be marked offline and split up in hbase:meta.
@@ -2284,6 +2362,9 @@ public void markRegionAsSplit(final RegionInfo parent, final ServerName serverNa
     // it is a split parent. And usually only one of them can match, as after restart, the region
     // state will be changed from SPLIT to CLOSED.
     regionStateStore.splitRegion(parent, daughterA, daughterB, serverName, td);
+    regionInTransitionTracker.handleRegionStateNodeOperation(node);
+    regionInTransitionTracker.handleRegionStateNodeOperation(nodeA);
+    regionInTransitionTracker.handleRegionStateNodeOperation(nodeB);
     if (shouldAssignFavoredNodes(parent)) {
       List<ServerName> onlineServers = this.master.getServerManager().getOnlineServersList();
       getFavoredNodePromoter().generateFavoredNodesForDaughter(onlineServers, parent, daughterA,
@@ -2303,12 +2384,14 @@ public void markRegionAsSplit(final RegionInfo parent, final ServerName serverNa
   public void markRegionAsMerged(final RegionInfo child, final ServerName serverName,
     RegionInfo[] mergeParents) throws IOException {
     final RegionStateNode node = regionStates.getOrCreateRegionStateNode(child);
-    node.setState(State.MERGED);
     for (RegionInfo ri : mergeParents) {
       regionStates.deleteRegion(ri);
+      regionInTransitionTracker.handleRegionDelete(ri);
     }
+
     TableDescriptor td = master.getTableDescriptors().get(child.getTable());
     regionStateStore.mergeRegions(child, mergeParents, serverName, td);
+    regionInTransitionTracker.handleRegionStateNodeOperation(node);
     if (shouldAssignFavoredNodes(child)) {
       getFavoredNodePromoter().generateFavoredNodesForMergedRegion(child, mergeParents);
     }
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/AssignmentManagerUtil.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/AssignmentManagerUtil.java
index cab8004770df..3f8b50e0913b 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/AssignmentManagerUtil.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/AssignmentManagerUtil.java
@@ -154,7 +154,7 @@ private static TransitRegionStateProcedure[] createAssignProcedures(MasterProced
           regionNode.lock();
           try {
             if (ignoreIfInTransition) {
-              if (regionNode.isInTransition()) {
+              if (regionNode.isTransitionScheduled()) {
                 return null;
               }
             } else {
@@ -162,7 +162,7 @@ private static TransitRegionStateProcedure[] createAssignProcedures(MasterProced
               // created, or has been successfully closed so should not be on any servers, so SCP
               // will
               // not process it either.
-              assert !regionNode.isInTransition();
+              assert !regionNode.isTransitionScheduled();
             }
             regionNode.setProcedure(proc);
           } finally {
@@ -184,7 +184,7 @@ private static TransitRegionStateProcedure[] createAssignProcedures(MasterProced
         // apply ignoreRITs to replica regions as well.
         if (
           !ignoreIfInTransition || !env.getAssignmentManager().getRegionStates()
-            .getOrCreateRegionStateNode(ri).isInTransition()
+            .getOrCreateRegionStateNode(ri).isTransitionScheduled()
         ) {
           replicaRegionInfos.add(ri);
         }
@@ -232,7 +232,7 @@ private static TransitRegionStateProcedure[] createRoundRobinAssignProcedures(
       for (RegionInfo region : regionsAndReplicas) {
         if (
           env.getAssignmentManager().getRegionStates().getOrCreateRegionStateNode(region)
-            .isInTransition()
+            .isTransitionScheduled()
         ) {
           return null;
         }
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/RegionInTransitionTracker.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/RegionInTransitionTracker.java
new file mode 100644
index 000000000000..f8883acd3d40
--- /dev/null
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/RegionInTransitionTracker.java
@@ -0,0 +1,122 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.hbase.master.assignment;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ConcurrentSkipListMap;
+import org.apache.hadoop.hbase.client.RegionInfo;
+import org.apache.hadoop.hbase.client.TableState;
+import org.apache.hadoop.hbase.master.RegionState;
+import org.apache.hadoop.hbase.master.TableStateManager;
+import org.apache.yetus.audience.InterfaceAudience;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@InterfaceAudience.Private
+public class RegionInTransitionTracker {
+  private static final Logger LOG = LoggerFactory.getLogger(RegionInTransitionTracker.class);
+
+  private final List<RegionState.State> DISABLE_TABLE_REGION_STATE =
+    List.of(RegionState.State.OFFLINE, RegionState.State.CLOSED);
+
+  private final List<RegionState.State> ENABLE_TABLE_REGION_STATE = List.of(RegionState.State.OPEN);
+
+  private final ConcurrentSkipListMap<RegionInfo, RegionStateNode> regionInTransition =
+    new ConcurrentSkipListMap<>(RegionInfo.COMPARATOR);
+
+  private final TableStateManager tableStateManager;
+
+  public RegionInTransitionTracker(TableStateManager tableStateManager) {
+    this.tableStateManager = tableStateManager;
+  }
+
+  public boolean isRegionInTransition(final RegionInfo regionInfo) {
+    return regionInTransition.containsKey(regionInfo);
+  }
+
+  public void regionCrashed(RegionStateNode regionStateNode) {
+    if (regionStateNode.getRegionInfo().getReplicaId() != RegionInfo.DEFAULT_REPLICA_ID) {
+      return;
+    }
+
+    if (addRegionInTransition(regionStateNode)) {
+      LOG.debug("{} added to RIT list because hosting region server is crashed ",
+        regionStateNode.getRegionInfo().getEncodedName());
+    }
+  }
+
+  public void handleRegionStateNodeOperation(RegionStateNode regionStateNode) {
+    // only consider default replica for availability
+    if (regionStateNode.getRegionInfo().getReplicaId() != RegionInfo.DEFAULT_REPLICA_ID) {
+      return;
+    }
+
+    RegionState.State currentState = regionStateNode.getState();
+    boolean isTableEnabled = tableStateManager.isTableState(regionStateNode.getTable(),
+      TableState.State.ENABLED, TableState.State.ENABLING);
+    List<RegionState.State> terminalStates =
+      isTableEnabled ? ENABLE_TABLE_REGION_STATE : DISABLE_TABLE_REGION_STATE;
+
+    // if region is merged or split it should not be in RIT list
+    if (
+      currentState == RegionState.State.SPLIT || currentState == RegionState.State.MERGED
+        || regionStateNode.getRegionInfo().isSplit()
+    ) {
+      if (removeRegionInTransition(regionStateNode.getRegionInfo())) {
+        LOG.debug("Removed {} from RIT list as it is split or merged",
+          regionStateNode.getRegionInfo().getEncodedName());
+      }
+    } else if (!terminalStates.contains(currentState)) {
+      if (addRegionInTransition(regionStateNode)) {
+        LOG.debug("{} added to RIT list because it is in-between state, region state : {} ",
+          regionStateNode.getRegionInfo().getEncodedName(), currentState);
+      }
+    } else {
+      if (removeRegionInTransition(regionStateNode.getRegionInfo())) {
+        LOG.debug("Removed {} from RIT list as reached to terminal state {}",
+          regionStateNode.getRegionInfo().getEncodedName(), currentState);
+      }
+    }
+  }
+
+  public void handleRegionDelete(RegionInfo regionInfo) {
+    removeRegionInTransition(regionInfo);
+  }
+
+  private boolean addRegionInTransition(final RegionStateNode regionStateNode) {
+    return regionInTransition.putIfAbsent(regionStateNode.getRegionInfo(), regionStateNode) == null;
+  }
+
+  private boolean removeRegionInTransition(final RegionInfo regionInfo) {
+    return regionInTransition.remove(regionInfo) != null;
+  }
+
+  public void stop() {
+    regionInTransition.clear();
+  }
+
+  public boolean hasRegionsInTransition() {
+    return !regionInTransition.isEmpty();
+  }
+
+  public List<RegionStateNode> getRegionsInTransition() {
+    return new ArrayList<>(regionInTransition.values());
+  }
+
+}
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/RegionStateNode.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/RegionStateNode.java
index 402c22ac9ed6..fc6fc54ea368 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/RegionStateNode.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/RegionStateNode.java
@@ -18,7 +18,7 @@
 package org.apache.hadoop.hbase.master.assignment;
 
 import java.util.Arrays;
-import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.atomic.AtomicInteger;
 import org.apache.hadoop.hbase.HConstants;
 import org.apache.hadoop.hbase.ServerName;
 import org.apache.hadoop.hbase.TableName;
@@ -68,6 +68,7 @@
 public class RegionStateNode implements Comparable<RegionStateNode> {
 
   private static final Logger LOG = LoggerFactory.getLogger(RegionStateNode.class);
+  private final AtomicInteger trspCounter;
 
   private static final class AssignmentProcedureEvent extends ProcedureEvent<RegionInfo> {
     public AssignmentProcedureEvent(final RegionInfo regionInfo) {
@@ -78,7 +79,6 @@ public AssignmentProcedureEvent(final RegionInfo regionInfo) {
   private final RegionStateNodeLock lock;
   private final RegionInfo regionInfo;
   private final ProcedureEvent<?> event;
-  private final ConcurrentMap<RegionInfo, RegionStateNode> ritMap;
 
   // volatile only for getLastUpdate and test usage, the upper layer should sync on the
   // RegionStateNode before accessing usually.
@@ -96,17 +96,17 @@ public AssignmentProcedureEvent(final RegionInfo regionInfo) {
 
   /**
    * Updated whenever a call to {@link #setRegionLocation(ServerName)} or
-   * {@link #setState(RegionState.State, RegionState.State...)}.
+   * {@link #setState(RegionState.State, RegionState.State...)} or {@link #crashed(long)}.
    */
   private volatile long lastUpdate = 0;
 
   private volatile long openSeqNum = HConstants.NO_SEQNUM;
 
-  RegionStateNode(RegionInfo regionInfo, ConcurrentMap<RegionInfo, RegionStateNode> ritMap) {
+  RegionStateNode(RegionInfo regionInfo, AtomicInteger trspCounter) {
     this.regionInfo = regionInfo;
     this.event = new AssignmentProcedureEvent(regionInfo);
-    this.ritMap = ritMap;
     this.lock = new RegionStateNodeLock(regionInfo);
+    this.trspCounter = trspCounter;
   }
 
   /**
@@ -161,7 +161,7 @@ public boolean isStuck() {
     return isInState(State.FAILED_OPEN) && getProcedure() != null;
   }
 
-  public boolean isInTransition() {
+  public boolean isTransitionScheduled() {
     return getProcedure() != null;
   }
 
@@ -190,6 +190,10 @@ public void setLastHost(final ServerName serverName) {
     this.lastHost = serverName;
   }
 
+  public void crashed(long crashTime) {
+    this.lastUpdate = crashTime;
+  }
+
   public void setOpenSeqNum(final long seqId) {
     this.openSeqNum = seqId;
   }
@@ -207,14 +211,14 @@ public ServerName setRegionLocation(final ServerName serverName) {
   public TransitRegionStateProcedure setProcedure(TransitRegionStateProcedure proc) {
     assert this.procedure == null;
     this.procedure = proc;
-    ritMap.put(regionInfo, this);
+    trspCounter.incrementAndGet();
     return proc;
   }
 
   public void unsetProcedure(TransitRegionStateProcedure proc) {
     assert this.procedure == proc;
+    trspCounter.decrementAndGet();
     this.procedure = null;
-    ritMap.remove(regionInfo, this);
   }
 
   public TransitRegionStateProcedure getProcedure() {
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/RegionStates.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/RegionStates.java
index b3de79c18264..fed632e376d4 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/RegionStates.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/RegionStates.java
@@ -20,13 +20,10 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.Comparator;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.SortedSet;
-import java.util.TreeSet;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentSkipListMap;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -54,22 +51,10 @@
 public class RegionStates {
   private static final Logger LOG = LoggerFactory.getLogger(RegionStates.class);
 
-  // This comparator sorts the RegionStates by time stamp then Region name.
-  // Comparing by timestamp alone can lead us to discard different RegionStates that happen
-  // to share a timestamp.
-  private static class RegionStateStampComparator implements Comparator<RegionState> {
-    @Override
-    public int compare(final RegionState l, final RegionState r) {
-      int stampCmp = Long.compare(l.getStamp(), r.getStamp());
-      return stampCmp != 0 ? stampCmp : RegionInfo.COMPARATOR.compare(l.getRegion(), r.getRegion());
-    }
-  }
-
-  public final static RegionStateStampComparator REGION_STATE_STAMP_COMPARATOR =
-    new RegionStateStampComparator();
-
   private final Object regionsMapLock = new Object();
 
+  private final AtomicInteger trspCounter = new AtomicInteger(0);
+
   // TODO: Replace the ConcurrentSkipListMaps
   /**
    * A Map from {@link RegionInfo#getRegionName()} to {@link RegionStateNode}
@@ -84,9 +69,6 @@ public int compare(final RegionState l, final RegionState r) {
   private final ConcurrentSkipListMap<String, RegionStateNode> encodedRegionsMap =
     new ConcurrentSkipListMap<>();
 
-  private final ConcurrentSkipListMap<RegionInfo, RegionStateNode> regionInTransition =
-    new ConcurrentSkipListMap<>(RegionInfo.COMPARATOR);
-
   /**
    * Regions marked as offline on a read of hbase:meta. Unused or at least, once offlined, regions
    * have no means of coming on line again. TODO.
@@ -109,14 +91,12 @@ public RegionStates() {
   public void clear() {
     regionsMap.clear();
     encodedRegionsMap.clear();
-    regionInTransition.clear();
     regionOffline.clear();
     serverMap.clear();
   }
 
   public boolean isRegionInRegionStates(final RegionInfo hri) {
-    return (regionsMap.containsKey(hri.getRegionName()) || regionInTransition.containsKey(hri)
-      || regionOffline.containsKey(hri));
+    return (regionsMap.containsKey(hri.getRegionName()) || regionOffline.containsKey(hri));
   }
 
   // ==========================================================================
@@ -125,7 +105,7 @@ public boolean isRegionInRegionStates(final RegionInfo hri) {
   RegionStateNode createRegionStateNode(RegionInfo regionInfo) {
     synchronized (regionsMapLock) {
       RegionStateNode node = regionsMap.computeIfAbsent(regionInfo.getRegionName(),
-        key -> new RegionStateNode(regionInfo, regionInTransition));
+        key -> new RegionStateNode(regionInfo, trspCounter));
 
       if (encodedRegionsMap.get(regionInfo.getEncodedName()) != node) {
         encodedRegionsMap.put(regionInfo.getEncodedName(), node);
@@ -157,12 +137,6 @@ public void deleteRegion(final RegionInfo regionInfo) {
       regionsMap.remove(regionInfo.getRegionName());
       encodedRegionsMap.remove(regionInfo.getEncodedName());
     }
-    // See HBASE-20860
-    // After master restarts, merged regions' RIT state may not be cleaned,
-    // making sure they are cleaned here
-    if (regionInTransition.containsKey(regionInfo)) {
-      regionInTransition.remove(regionInfo);
-    }
     // Remove from the offline regions map too if there.
     if (this.regionOffline.containsKey(regionInfo)) {
       if (LOG.isTraceEnabled()) LOG.trace("Removing from regionOffline Map: " + regionInfo);
@@ -459,7 +433,7 @@ public void updateRegionState(RegionInfo regionInfo, State state) {
   public List<RegionInfo> getAssignedRegions() {
     final List<RegionInfo> result = new ArrayList<RegionInfo>();
     for (RegionStateNode node : regionsMap.values()) {
-      if (!node.isInTransition()) {
+      if (!node.isTransitionScheduled()) {
         result.add(node.getRegionInfo());
       }
     }
@@ -618,59 +592,6 @@ private boolean isTableDisabled(final TableStateManager tableStateManager,
       TableState.State.DISABLING);
   }
 
-  // ==========================================================================
-  // Region in transition helpers
-  // ==========================================================================
-  public boolean hasRegionsInTransition() {
-    return !regionInTransition.isEmpty();
-  }
-
-  public boolean isRegionInTransition(final RegionInfo regionInfo) {
-    final RegionStateNode node = regionInTransition.get(regionInfo);
-    return node != null ? node.isInTransition() : false;
-  }
-
-  public RegionState getRegionTransitionState(RegionInfo hri) {
-    RegionStateNode node = regionInTransition.get(hri);
-    if (node == null) {
-      return null;
-    }
-
-    node.lock();
-    try {
-      return node.isInTransition() ? node.toRegionState() : null;
-    } finally {
-      node.unlock();
-    }
-  }
-
-  public List<RegionStateNode> getRegionsInTransition() {
-    return new ArrayList<RegionStateNode>(regionInTransition.values());
-  }
-
-  /**
-   * Get the number of regions in transition.
-   */
-  public int getRegionsInTransitionCount() {
-    return regionInTransition.size();
-  }
-
-  public List<RegionState> getRegionsStateInTransition() {
-    final List<RegionState> rit = new ArrayList<RegionState>(regionInTransition.size());
-    for (RegionStateNode node : regionInTransition.values()) {
-      rit.add(node.toRegionState());
-    }
-    return rit;
-  }
-
-  public SortedSet<RegionState> getRegionsInTransitionOrderedByTimestamp() {
-    final SortedSet<RegionState> rit = new TreeSet<RegionState>(REGION_STATE_STAMP_COMPARATOR);
-    for (RegionStateNode node : regionInTransition.values()) {
-      rit.add(node.toRegionState());
-    }
-    return rit;
-  }
-
   // ==========================================================================
   // Region offline helpers
   // ==========================================================================
@@ -680,6 +601,10 @@ public void addToOfflineRegions(final RegionStateNode regionNode) {
     regionOffline.put(regionNode.getRegionInfo(), regionNode);
   }
 
+  public int getRegionTransitScheduledCount() {
+    return trspCounter.get();
+  }
+
   // ==========================================================================
   // Region FAIL_OPEN helpers
   // ==========================================================================
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/FlushRegionProcedure.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/FlushRegionProcedure.java
index af482aeff281..091fdc791bfa 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/FlushRegionProcedure.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/FlushRegionProcedure.java
@@ -95,7 +95,7 @@ protected Procedure<MasterProcedureEnv>[] execute(MasterProcedureEnv env)
     }
     regionNode.lock();
     try {
-      if (!regionNode.isInState(State.OPEN) || regionNode.isInTransition()) {
+      if (!regionNode.isInState(State.OPEN) || regionNode.isTransitionScheduled()) {
         LOG.info("State of region {} is not OPEN or in transition. Skip {} ...", region, this);
         return null;
       }
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ProcedureSyncWait.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ProcedureSyncWait.java
index 122c901fd734..38cb6a944b9f 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ProcedureSyncWait.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ProcedureSyncWait.java
@@ -31,8 +31,8 @@
 import org.apache.hadoop.hbase.client.RegionInfoBuilder;
 import org.apache.hadoop.hbase.exceptions.TimeoutIOException;
 import org.apache.hadoop.hbase.master.RegionState;
+import org.apache.hadoop.hbase.master.assignment.AssignmentManager;
 import org.apache.hadoop.hbase.master.assignment.RegionStateNode;
-import org.apache.hadoop.hbase.master.assignment.RegionStates;
 import org.apache.hadoop.hbase.procedure2.Procedure;
 import org.apache.hadoop.hbase.procedure2.ProcedureExecutor;
 import org.apache.hadoop.hbase.quotas.MasterQuotaManager;
@@ -246,13 +246,14 @@ protected static void waitMetaRegions(final MasterProcedureEnv env) throws IOExc
 
   protected static void waitRegionInTransition(final MasterProcedureEnv env,
     final List<RegionInfo> regions) throws IOException {
-    final RegionStates states = env.getAssignmentManager().getRegionStates();
+    final AssignmentManager assignmentManager = env.getAssignmentManager();
     for (final RegionInfo region : regions) {
       ProcedureSyncWait.waitFor(env, "regions " + region.getRegionNameAsString() + " in transition",
         new ProcedureSyncWait.Predicate<Boolean>() {
           @Override
           public Boolean evaluate() throws IOException {
-            return !states.isRegionInTransition(region);
+            return !assignmentManager.getRegionStates().getRegionStateNode(region)
+              .isTransitionScheduled();
           }
         });
     }
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ReopenTableRegionsProcedure.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ReopenTableRegionsProcedure.java
index 03f04792af55..6e3491a24a88 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ReopenTableRegionsProcedure.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ReopenTableRegionsProcedure.java
@@ -184,7 +184,7 @@ private boolean canSchedule(MasterProcedureEnv env, HRegionLocation loc) {
     // If the region node is null, then at least in the next round we can remove this region to make
     // progress. And the second condition is a normal one, if there are no TRSP with it then we can
     // schedule one to make progress.
-    return regionNode == null || !regionNode.isInTransition();
+    return regionNode == null || !regionNode.isTransitionScheduled();
   }
 
   @Override
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ServerCrashProcedure.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ServerCrashProcedure.java
index 3fa5358635ad..1cfccaf39252 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ServerCrashProcedure.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ServerCrashProcedure.java
@@ -208,6 +208,7 @@ protected Flow executeFromState(MasterProcedureEnv env, ServerCrashState state)
             if (LOG.isTraceEnabled()) {
               this.regionsOnCrashedServer.stream().forEach(ri -> LOG.trace(ri.getShortNameToLog()));
             }
+            env.getAssignmentManager().markRegionsAsCrashed(regionsOnCrashedServer, this);
           }
           if (!this.shouldSplitWal) {
             setNextState(ServerCrashState.SERVER_CRASH_ASSIGN);
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/rsgroup/RSGroupInfoManagerImpl.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/rsgroup/RSGroupInfoManagerImpl.java
index 5332c6e84506..783d7c7dd335 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/rsgroup/RSGroupInfoManagerImpl.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/rsgroup/RSGroupInfoManagerImpl.java
@@ -1191,8 +1191,8 @@ public BalanceResponse balanceRSGroup(String groupName, BalanceRequest request)
       Map<String, RegionState> groupRIT = rsGroupGetRegionsInTransition(groupName);
       if (groupRIT.size() > 0 && !request.isIgnoreRegionsInTransition()) {
         LOG.debug("Not running balancer because {} region(s) in transition: {}", groupRIT.size(),
-          StringUtils.abbreviate(masterServices.getAssignmentManager().getRegionStates()
-            .getRegionsInTransition().toString(), 256));
+          StringUtils.abbreviate(
+            masterServices.getAssignmentManager().getRegionsInTransition().toString(), 256));
         return responseBuilder.build();
       }
 
diff --git a/hbase-server/src/main/resources/hbase-webapps/master/assignmentManagerStatus.jsp b/hbase-server/src/main/resources/hbase-webapps/master/assignmentManagerStatus.jsp
index 0966d04316b4..4f73a68941e7 100644
--- a/hbase-server/src/main/resources/hbase-webapps/master/assignmentManagerStatus.jsp
+++ b/hbase-server/src/main/resources/hbase-webapps/master/assignmentManagerStatus.jsp
@@ -32,7 +32,7 @@
   AssignmentManager assignmentManager = master.getAssignmentManager();
   int limit = 100;
 
-  SortedSet<RegionState> rit = assignmentManager.getRegionStates().getRegionsInTransitionOrderedByTimestamp();
+  SortedSet<RegionState> rit = assignmentManager.getRegionsStateInTransition();
 
 if (!rit.isEmpty()) {
   long currentTime = System.currentTimeMillis();
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/HBaseTestingUtil.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/HBaseTestingUtil.java
index 882b573ad4e1..c885d9868844 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/HBaseTestingUtil.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/HBaseTestingUtil.java
@@ -3435,9 +3435,8 @@ public ExplainingPredicate<IOException> predicateNoRegionsInTransition() {
     return new ExplainingPredicate<IOException>() {
       @Override
       public String explainFailure() throws IOException {
-        final RegionStates regionStates =
-          getMiniHBaseCluster().getMaster().getAssignmentManager().getRegionStates();
-        return "found in transition: " + regionStates.getRegionsInTransition().toString();
+        final AssignmentManager am = getMiniHBaseCluster().getMaster().getAssignmentManager();
+        return "found in transition: " + am.getRegionsInTransition().toString();
       }
 
       @Override
@@ -3451,6 +3450,34 @@ public boolean evaluate() throws IOException {
     };
   }
 
+  /**
+   * Returns a {@link Predicate} for checking that there are no procedure to region transition in
+   * master
+   */
+  public ExplainingPredicate<IOException> predicateNoRegionTransitScheduled() {
+    return new ExplainingPredicate<IOException>() {
+      @Override
+      public String explainFailure() throws IOException {
+        final AssignmentManager am = getMiniHBaseCluster().getMaster().getAssignmentManager();
+        return "Number of procedure scheduled for region transit: "
+          + am.getRegionTransitScheduledCount();
+      }
+
+      @Override
+      public boolean evaluate() throws IOException {
+        HMaster master = getMiniHBaseCluster().getMaster();
+        if (master == null) {
+          return false;
+        }
+        AssignmentManager am = master.getAssignmentManager();
+        if (am == null) {
+          return false;
+        }
+        return am.getRegionTransitScheduledCount() == 0;
+      }
+    };
+  }
+
   /**
    * Returns a {@link Predicate} for checking that table is enabled
    */
@@ -3528,6 +3555,14 @@ public void waitUntilNoRegionsInTransition(final long timeout) throws IOExceptio
     waitFor(timeout, predicateNoRegionsInTransition());
   }
 
+  /**
+   * Wait until no regions in transition.
+   * @param timeout How long to wait.
+   */
+  public void waitUntilNoRegionTransitScheduled(final long timeout) throws IOException {
+    waitFor(timeout, predicateNoRegionTransitScheduled());
+  }
+
   /**
    * Wait until no regions in transition. (time limit 15min)
    */
@@ -3535,6 +3570,13 @@ public void waitUntilNoRegionsInTransition() throws IOException {
     waitUntilNoRegionsInTransition(15 * 60000);
   }
 
+  /**
+   * Wait until no TRSP is present
+   */
+  public void waitUntilNoRegionTransitScheduled() throws IOException {
+    waitUntilNoRegionTransitScheduled(15 * 60000);
+  }
+
   /**
    * Wait until labels is ready in VisibilityLabelsCache.
    */
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncRegionAdminApi.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncRegionAdminApi.java
index 2455590ec254..d3b4f51e1d21 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncRegionAdminApi.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncRegionAdminApi.java
@@ -94,12 +94,12 @@ public void testAssignRegionAndUnassignRegion() throws Exception {
       // Expected
       assertThat(e.getCause(), instanceOf(DoNotRetryRegionException.class));
     }
-    assertFalse(am.getRegionStates().getRegionStateNode(hri).isInTransition());
+    assertFalse(am.getRegionStates().getRegionStateNode(hri).isTransitionScheduled());
     assertTrue(regionStates.getRegionState(hri).isOpened());
 
     // unassign region
     admin.unassign(hri.getRegionName(), true).get();
-    assertFalse(am.getRegionStates().getRegionStateNode(hri).isInTransition());
+    assertFalse(am.getRegionStates().getRegionStateNode(hri).isTransitionScheduled());
     assertTrue(regionStates.getRegionState(hri).isClosed());
   }
 
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestSplitOrMergeStatus.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestSplitOrMergeStatus.java
index a4b0a87a13ab..cd9ff64f55d1 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestSplitOrMergeStatus.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestSplitOrMergeStatus.java
@@ -193,8 +193,8 @@ public void testSplitRegionReplicaRitRecovery() throws Exception {
     ProcedureTestingUtility.waitProcedure(procExec, procId2);
     AssignmentTestingUtil.killRs(TEST_UTIL, serverName);
     Threads.sleepWithoutInterrupt(5000);
-    boolean hasRegionsInTransition = TEST_UTIL.getMiniHBaseCluster().getMaster()
-      .getAssignmentManager().getRegionStates().hasRegionsInTransition();
+    boolean hasRegionsInTransition =
+      TEST_UTIL.getMiniHBaseCluster().getMaster().getAssignmentManager().hasRegionsInTransition();
     assertEquals(false, hasRegionsInTransition);
   }
 
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestAssignmentManagerMetrics.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestAssignmentManagerMetrics.java
index 9d0673e654b9..b503595a4472 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestAssignmentManagerMetrics.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestAssignmentManagerMetrics.java
@@ -154,7 +154,7 @@ public void testRITAssignmentManagerMetrics() throws Exception {
       // Sleep 5 seconds, wait for doMetrics chore catching up
       // the rit count consists of rit and failed opens. see RegionInTransitionStat#update
       // Waiting for the completion of rit makes the assert stable.
-      TEST_UTIL.waitUntilNoRegionsInTransition();
+      TEST_UTIL.waitUntilNoRegionTransitScheduled();
       Thread.sleep(MSG_INTERVAL * 5);
       METRICS_HELPER.assertGauge(MetricsAssignmentManagerSource.RIT_COUNT_NAME, 1, amSource);
       METRICS_HELPER.assertGauge(MetricsAssignmentManagerSource.RIT_COUNT_OVER_THRESHOLD_NAME, 1,
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestMasterBalanceThrottling.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestMasterBalanceThrottling.java
index bb2566ccc459..09d9867f5d9d 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestMasterBalanceThrottling.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestMasterBalanceThrottling.java
@@ -126,8 +126,8 @@ private Thread startBalancerChecker(final HMaster master, final AtomicInteger ma
       @Override
       public void run() {
         while (!stop.get()) {
-          maxCount.set(Math.max(maxCount.get(),
-            master.getAssignmentManager().getRegionStates().getRegionsInTransitionCount()));
+          maxCount.set(
+            Math.max(maxCount.get(), master.getAssignmentManager().getRegionsInTransitionCount()));
           try {
             Thread.sleep(10);
           } catch (InterruptedException e) {
@@ -142,7 +142,7 @@ public void run() {
   }
 
   private void unbalance(HMaster master, TableName tableName) throws Exception {
-    while (master.getAssignmentManager().getRegionStates().getRegionsInTransitionCount() > 0) {
+    while (master.getAssignmentManager().getRegionsInTransitionCount() > 0) {
       Thread.sleep(100);
     }
     HRegionServer biasedServer = TEST_UTIL.getMiniHBaseCluster().getRegionServer(0);
@@ -150,7 +150,7 @@ private void unbalance(HMaster master, TableName tableName) throws Exception {
       master.move(regionInfo.getEncodedNameAsBytes(),
         Bytes.toBytes(biasedServer.getServerName().getServerName()));
     }
-    while (master.getAssignmentManager().getRegionStates().getRegionsInTransitionCount() > 0) {
+    while (master.getAssignmentManager().getRegionsInTransitionCount() > 0) {
       Thread.sleep(100);
     }
   }
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestMasterDryRunBalancer.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestMasterDryRunBalancer.java
index 267a1380257c..c8da2759e65d 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestMasterDryRunBalancer.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestMasterDryRunBalancer.java
@@ -119,6 +119,6 @@ private void assertServerContainsAllRegions(ServerName serverName, TableName tab
 
   private void waitForRegionsToSettle(HMaster master) {
     Waiter.waitFor(TEST_UTIL.getConfiguration(), 60_000,
-      () -> master.getAssignmentManager().getRegionStates().getRegionsInTransitionCount() <= 0);
+      () -> master.getAssignmentManager().getRegionsInTransitionCount() <= 0);
   }
 }
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/AssignmentTestingUtil.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/AssignmentTestingUtil.java
index 619f2fc259fc..e938172d0d49 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/AssignmentTestingUtil.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/AssignmentTestingUtil.java
@@ -50,7 +50,7 @@ private AssignmentTestingUtil() {
 
   public static void waitForRegionToBeInTransition(final HBaseTestingUtil util,
     final RegionInfo hri) throws Exception {
-    while (!getMaster(util).getAssignmentManager().getRegionStates().isRegionInTransition(hri)) {
+    while (!getMaster(util).getAssignmentManager().isRegionInTransition(hri)) {
       Threads.sleep(10);
     }
   }
@@ -141,7 +141,7 @@ public static boolean waitForAssignment(AssignmentManager am, RegionInfo regionI
     RegionStateNode regionNode = am.getRegionStates().getRegionStateNode(regionInfo);
     // Wait until the region has already been open, or we have a TRSP along with it.
     Waiter.waitFor(am.getConfiguration(), 30000,
-      () -> regionNode.isInState(State.OPEN) || regionNode.isInTransition());
+      () -> regionNode.isInState(State.OPEN) || regionNode.isTransitionScheduled());
     TransitRegionStateProcedure proc = regionNode.getProcedure();
     regionNode.lock();
     try {
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/MockMasterServices.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/MockMasterServices.java
index 6bc4c9d14e6f..80504432e88d 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/MockMasterServices.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/MockMasterServices.java
@@ -117,12 +117,12 @@ public MockMasterServices(Configuration conf) throws IOException, ReplicationExc
         ? null
         : new SplitWALManager(this);
     this.masterRegion = MasterRegionFactory.create(this);
+    this.tableStateManager = mock(TableStateManager.class);
     // Mock an AM.
     this.assignmentManager =
       new AssignmentManager(this, masterRegion, new MockRegionStateStore(this, masterRegion));
     this.balancer = LoadBalancerFactory.getLoadBalancer(conf);
     this.serverManager = new ServerManager(this, new DummyRegionServerList());
-    this.tableStateManager = mock(TableStateManager.class);
     when(this.tableStateManager.getTableState(any())).thenReturn(new TableState(
       TableName.valueOf("AnyTableNameSetInMockMasterServcies"), TableState.State.ENABLED));
 
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestAssignmentManagerBase.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestAssignmentManagerBase.java
index 5f4555342726..e207b5ed8150 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestAssignmentManagerBase.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestAssignmentManagerBase.java
@@ -280,7 +280,7 @@ protected TransitRegionStateProcedure createUnassignProcedure(RegionInfo hri) {
     TransitRegionStateProcedure proc;
     regionNode.lock();
     try {
-      assertFalse(regionNode.isInTransition());
+      assertFalse(regionNode.isTransitionScheduled());
       proc = TransitRegionStateProcedure
         .unassign(master.getMasterProcedureExecutor().getEnvironment(), hri);
       regionNode.setProcedure(proc);
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestAssignmentManagerUtil.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestAssignmentManagerUtil.java
index 69381b37e38c..f6cdc14b0911 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestAssignmentManagerUtil.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestAssignmentManagerUtil.java
@@ -128,6 +128,6 @@ public void testCreateUnassignProceduresForMergeFail() throws IOException {
     IntStream.range(0, REGION_REPLICATION)
       .mapToObj(i -> RegionReplicaUtil.getRegionInfoForReplica(regionA, i))
       .map(AM.getRegionStates()::getRegionStateNode).forEachOrdered(
-        rn -> assertFalse("Should have unset the proc for " + rn, rn.isInTransition()));
+        rn -> assertFalse("Should have unset the proc for " + rn, rn.isTransitionScheduled()));
   }
 }
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestTransitRegionStateProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestTransitRegionStateProcedure.java
index 286bbbf9323a..a62c83eca0d1 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestTransitRegionStateProcedure.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestTransitRegionStateProcedure.java
@@ -99,15 +99,15 @@ private void testRecoveryAndDoubleExcution(TransitRegionStateProcedure proc) thr
     HMaster master = UTIL.getHBaseCluster().getMaster();
     AssignmentManager am = master.getAssignmentManager();
     RegionStateNode regionNode = am.getRegionStates().getRegionStateNode(proc.getRegion());
-    assertFalse(regionNode.isInTransition());
+    assertFalse(regionNode.isTransitionScheduled());
     regionNode.setProcedure(proc);
-    assertTrue(regionNode.isInTransition());
+    assertTrue(regionNode.isTransitionScheduled());
     ProcedureExecutor<MasterProcedureEnv> procExec = master.getMasterProcedureExecutor();
     ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(procExec, true);
     long procId = procExec.submitProcedure(proc);
     MasterProcedureTestingUtility.testRecoveryAndDoubleExecution(procExec, procId);
     regionNode = am.getRegionStates().getRegionStateNode(proc.getRegion());
-    assertFalse(regionNode.isInTransition());
+    assertFalse(regionNode.isTransitionScheduled());
   }
 
   @Test
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/balancer/TestFavoredStochasticLoadBalancer.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/balancer/TestFavoredStochasticLoadBalancer.java
index dcd785215027..dcaebbd84356 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/balancer/TestFavoredStochasticLoadBalancer.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/balancer/TestFavoredStochasticLoadBalancer.java
@@ -51,6 +51,7 @@
 import org.apache.hadoop.hbase.master.HMaster;
 import org.apache.hadoop.hbase.master.LoadBalancer;
 import org.apache.hadoop.hbase.master.ServerManager;
+import org.apache.hadoop.hbase.master.assignment.AssignmentManager;
 import org.apache.hadoop.hbase.master.assignment.RegionStateNode;
 import org.apache.hadoop.hbase.master.assignment.RegionStates;
 import org.apache.hadoop.hbase.regionserver.HRegion;
@@ -262,7 +263,9 @@ public void testBalancerWithoutFavoredNodes() throws Exception {
 
     // Balancer should unassign the region
     assertTrue("Balancer did not run", admin.balance());
-    TEST_UTIL.waitUntilNoRegionsInTransition();
+    TEST_UTIL.waitUntilNoRegionTransitScheduled();
+    assertEquals("One region should be unassigned", 1,
+      master.getAssignmentManager().getRegionsInTransitionCount());
 
     admin.assign(region.getEncodedNameAsBytes());
     TEST_UTIL.waitUntilNoRegionsInTransition(60000);
@@ -380,7 +383,8 @@ public void testAllFavoredNodesDead() throws Exception {
     // Lets kill all the RS that are favored nodes for this region.
     stopServersAndWaitUntilProcessed(currentFN);
 
-    final RegionStates regionStates = master.getAssignmentManager().getRegionStates();
+    final AssignmentManager am = master.getAssignmentManager();
+    final RegionStates regionStates = am.getRegionStates();
     TEST_UTIL.waitFor(10000, new Waiter.Predicate<Exception>() {
       @Override
       public boolean evaluate() throws Exception {
@@ -401,7 +405,7 @@ public boolean evaluate() throws Exception {
     FavoredNodeAssignmentHelper helper = new FavoredNodeAssignmentHelper(serversForNewFN, conf);
     helper.initialize();
 
-    for (RegionStateNode regionState : regionStates.getRegionsInTransition()) {
+    for (RegionStateNode regionState : am.getRegionsInTransition()) {
       RegionInfo regionInfo = regionState.getRegionInfo();
       List<ServerName> newFavoredNodes = helper.generateFavoredNodes(regionInfo);
       assertNotNull(newFavoredNodes);
@@ -442,7 +446,8 @@ public void testAllFavoredNodesDeadMasterRestarted() throws Exception {
     // Lets kill all the RS that are favored nodes for this region.
     stopServersAndWaitUntilProcessed(currentFN);
 
-    final RegionStates regionStatesBeforeMaster = master.getAssignmentManager().getRegionStates();
+    final AssignmentManager am = master.getAssignmentManager();
+    final RegionStates regionStatesBeforeMaster = am.getRegionStates();
     TEST_UTIL.waitFor(10000, new Waiter.Predicate<Exception>() {
       @Override
       public boolean evaluate() throws Exception {
@@ -454,7 +459,7 @@ public boolean evaluate() throws Exception {
       regionStatesBeforeMaster.getRegionState(region).isFailedOpen());
 
     List<RegionInfo> rit = Lists.newArrayList();
-    for (RegionStateNode regionState : regionStatesBeforeMaster.getRegionsInTransition()) {
+    for (RegionStateNode regionState : am.getRegionsInTransition()) {
       RegionInfo regionInfo = regionState.getRegionInfo();
       LOG.debug("Region in transition after stopping FN's: " + regionInfo);
       rit.add(regionInfo);
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/http/TestMasterStatusUtil.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/http/TestMasterStatusUtil.java
index 7e576acae7ba..0ec94c917193 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/http/TestMasterStatusUtil.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/http/TestMasterStatusUtil.java
@@ -98,7 +98,7 @@ public void setupBasicMocks() {
     regionsInTransition
       .add(new RegionState(FAKE_HRI, RegionState.State.CLOSING, 12345L, FAKE_HOST));
     Mockito.doReturn(rs).when(am).getRegionStates();
-    Mockito.doReturn(regionsInTransition).when(rs).getRegionsInTransition();
+    Mockito.doReturn(regionsInTransition).when(am).getRegionsInTransition();
     Mockito.doReturn(am).when(master).getAssignmentManager();
     Mockito.doReturn(serverManager).when(master).getServerManager();
 
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHRegionFileSystem.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHRegionFileSystem.java
index ccb807c44f37..db2e55aaf5d8 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHRegionFileSystem.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHRegionFileSystem.java
@@ -116,8 +116,7 @@ public void testBlockStoragePolicy() throws Exception {
       cfdA.setValue(HStore.BLOCK_STORAGE_POLICY_KEY, "ONE_SSD");
       admin.modifyColumnFamily(TABLE_NAME, cfdA.build());
       while (
-        TEST_UTIL.getMiniHBaseCluster().getMaster().getAssignmentManager().getRegionStates()
-          .hasRegionsInTransition()
+        TEST_UTIL.getMiniHBaseCluster().getMaster().getAssignmentManager().hasRegionsInTransition()
       ) {
         Thread.sleep(200);
         LOG.debug("Waiting on table to finish schema altering");
@@ -127,8 +126,7 @@ public void testBlockStoragePolicy() throws Exception {
       cfdB.setStoragePolicy("ALL_SSD");
       admin.modifyColumnFamily(TABLE_NAME, cfdB.build());
       while (
-        TEST_UTIL.getMiniHBaseCluster().getMaster().getAssignmentManager().getRegionStates()
-          .hasRegionsInTransition()
+        TEST_UTIL.getMiniHBaseCluster().getMaster().getAssignmentManager().hasRegionsInTransition()
       ) {
         Thread.sleep(200);
         LOG.debug("Waiting on table to finish schema altering");
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionMergeTransactionOnCluster.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionMergeTransactionOnCluster.java
index 041210edcf00..d55a2263ac36 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionMergeTransactionOnCluster.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionMergeTransactionOnCluster.java
@@ -58,7 +58,6 @@
 import org.apache.hadoop.hbase.master.MasterRpcServices;
 import org.apache.hadoop.hbase.master.RegionState;
 import org.apache.hadoop.hbase.master.assignment.AssignmentManager;
-import org.apache.hadoop.hbase.master.assignment.RegionStates;
 import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility;
 import org.apache.hadoop.hbase.regionserver.storefiletracker.StoreFileTracker;
 import org.apache.hadoop.hbase.regionserver.storefiletracker.StoreFileTrackerFactory;
@@ -165,15 +164,17 @@ public void testWholesomeMerge() throws Exception {
         : mergedRegions.getSecond();
       SingleProcessHBaseCluster cluster = TEST_UTIL.getHBaseCluster();
       AssignmentManager am = cluster.getMaster().getAssignmentManager();
-      RegionStates regionStates = am.getRegionStates();
 
-      // We should not be able to assign it again
+      // We should not be able to assign it again, but we are able to do it here. Assertions are
+      // poor here and missing that assign is possible here. Created HBASE-29692 for resolving this.
       am.assign(hri);
-      assertFalse("Merged region can't be assigned", regionStates.isRegionInTransition(hri));
+      assertFalse("Merged region can't be assigned",
+        am.getRegionStates().getRegionStateNode(hri).isTransitionScheduled());
 
       // We should not be able to unassign it either
       am.unassign(hri);
-      assertFalse("Merged region can't be unassigned", regionStates.isRegionInTransition(hri));
+      assertFalse("Merged region can't be unassigned",
+        am.getRegionStates().getRegionStateNode(hri).isTransitionScheduled());
 
       table.close();
     } finally {
@@ -569,11 +570,11 @@ public ReportRegionStateTransitionResponse reportRegionStateTransition(RpcContro
         enabled.get() && req.getTransition(0).getTransitionCode() == TransitionCode.READY_TO_MERGE
           && !resp.hasErrorMessage()
       ) {
-        RegionStates regionStates = myMaster.getAssignmentManager().getRegionStates();
-        for (RegionState regionState : regionStates.getRegionsStateInTransition()) {
+        AssignmentManager am = myMaster.getAssignmentManager();
+        for (RegionState regionState : am.getRegionsStateInTransition()) {
           // Find the merging_new region and remove it
           if (regionState.isMergingNew()) {
-            regionStates.deleteRegion(regionState.getRegion());
+            am.getRegionStates().deleteRegion(regionState.getRegion());
           }
         }
       }
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestSplitTransactionOnCluster.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestSplitTransactionOnCluster.java
index 77bd2a29f4ae..5c81bd8cd0d5 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestSplitTransactionOnCluster.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestSplitTransactionOnCluster.java
@@ -912,7 +912,7 @@ public void testSplitRegionWithNoStoreFiles() throws Exception {
       } catch (DoNotRetryIOException e) {
         // Expected
       }
-      assertFalse("Split region can't be assigned", regionStates.isRegionInTransition(hri));
+      assertFalse("Split region can't be assigned", am.isRegionInTransition(hri));
       assertTrue(regionStates.isRegionInState(hri, State.SPLIT));
 
       // We should not be able to unassign it either
@@ -922,7 +922,7 @@ public void testSplitRegionWithNoStoreFiles() throws Exception {
       } catch (DoNotRetryIOException e) {
         // Expected
       }
-      assertFalse("Split region can't be unassigned", regionStates.isRegionInTransition(hri));
+      assertFalse("Split region can't be unassigned", am.isRegionInTransition(hri));
       assertTrue(regionStates.isRegionInState(hri, State.SPLIT));
     } finally {
       admin.balancerSwitch(true, false);
@@ -1144,12 +1144,11 @@ public ReportRegionStateTransitionResponse reportRegionStateTransition(RpcContro
           && req.getTransition(0).getTransitionCode().equals(TransitionCode.READY_TO_SPLIT)
           && !resp.hasErrorMessage()
       ) {
-        RegionStates regionStates = myMaster.getAssignmentManager().getRegionStates();
-        for (RegionStateNode regionState : regionStates.getRegionsInTransition()) {
-          /*
-           * TODO!!!! // Find the merging_new region and remove it if (regionState.isSplittingNew())
-           * { regionStates.deleteRegion(regionState.getRegion()); }
-           */
+        AssignmentManager am = myMaster.getAssignmentManager();
+        for (RegionStateNode regionState : am.getRegionsInTransition()) {
+          if (regionState.toRegionState().isSplittingNew()) {
+            am.getRegionStates().deleteRegion(regionState.toRegionState().getRegion());
+          }
         }
       }
       return resp;
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsOfflineMode.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsOfflineMode.java
index ffdf35aca731..7d8af16b9a1c 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsOfflineMode.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsOfflineMode.java
@@ -136,7 +136,7 @@ public boolean evaluate() throws Exception {
       @Override
       public boolean evaluate() throws Exception {
         return groupRS.getNumberOfOnlineRegions() < 1
-          && master.getAssignmentManager().getRegionStates().getRegionsInTransitionCount() < 1;
+          && master.getAssignmentManager().getRegionsInTransitionCount() < 1;
       }
     });
     // Move table to group and wait.
diff --git a/hbase-testing-util/src/main/java/org/apache/hadoop/hbase/HBaseTestingUtility.java b/hbase-testing-util/src/main/java/org/apache/hadoop/hbase/HBaseTestingUtility.java
index dc4bc1816acc..1dea0ba4c367 100644
--- a/hbase-testing-util/src/main/java/org/apache/hadoop/hbase/HBaseTestingUtility.java
+++ b/hbase-testing-util/src/main/java/org/apache/hadoop/hbase/HBaseTestingUtility.java
@@ -3875,9 +3875,8 @@ public ExplainingPredicate<IOException> predicateNoRegionsInTransition() {
     return new ExplainingPredicate<IOException>() {
       @Override
       public String explainFailure() throws IOException {
-        final RegionStates regionStates =
-          getMiniHBaseCluster().getMaster().getAssignmentManager().getRegionStates();
-        return "found in transition: " + regionStates.getRegionsInTransition().toString();
+        final AssignmentManager am = getMiniHBaseCluster().getMaster().getAssignmentManager();
+        return "found in transition: " + am.getRegionsInTransition().toString();
       }
 
       @Override