A per-heap RegionTree needs no lock.

third_party/WebKit/Source/platform/heap/PageMemory.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/heap/PageMemory.h"
 
 #include "platform/heap/Heap.h"
 #include "wtf/AddressSanitizer.h"
 #include "wtf/Assertions.h"
 #include "wtf/Atomics.h"
@@ skipping 54 matching lines @@
   size = (size + WTF::kPageAllocationGranularityOffsetMask) &
          WTF::kPageAllocationGranularityBaseMask;
   Address base = static_cast<Address>(
       WTF::AllocPages(nullptr, size, blinkPageSize, WTF::PageInaccessible));
   if (!base)
     blinkGCOutOfMemory();
   return new PageMemoryRegion(base, size, numPages, regionTree);
 }
 
 PageMemoryRegion* RegionTree::lookup(Address address) {
-  MutexLocker locker(m_mutex);
   RegionTreeNode* current = m_root;
   while (current) {
     Address base = current->m_region->base();
     if (address < base) {
       current = current->m_left;
       continue;
     }
     if (address >= base + current->m_region->size()) {
       current = current->m_right;
       continue;
     }
     ASSERT(current->m_region->contains(address));
     return current->m_region;
   }
   return nullptr;
 }
 
 void RegionTree::add(PageMemoryRegion* region) {
   ASSERT(region);
   RegionTreeNode* newTree = new RegionTreeNode(region);
-  MutexLocker locker(m_mutex);
   newTree->addTo(&m_root);
 }
 
 void RegionTreeNode::addTo(RegionTreeNode** context) {
   Address base = m_region->base();
   for (RegionTreeNode* current = *context; current; current = *context) {
     ASSERT(!current->m_region->contains(base));
     context = (base < current->m_region->base()) ? &current->m_left
                                                  : &current->m_right;
   }
   *context = this;
 }
 
 void RegionTree::remove(PageMemoryRegion* region) {
-  // Deletion of large objects (and thus their regions) can happen
-  // concurrently on sweeper threads.  Removal can also happen during thread
-  // shutdown, but that case is safe.  Regardless, we make all removals
-  // mutually exclusive.
-  MutexLocker locker(m_mutex);
   ASSERT(region);
   ASSERT(m_root);
   Address base = region->base();
   RegionTreeNode** context = &m_root;
   RegionTreeNode* current = m_root;
   for (; current; current = *context) {
     if (region == current->m_region)
       break;
     context = (base < current->m_region->base()) ? &current->m_left
                                                  : &current->m_right;
@@ skipping 50 matching lines @@
   size_t allocationSize = payloadSize + 2 * blinkGuardPageSize;
   PageMemoryRegion* pageMemoryRegion =
       PageMemoryRegion::allocateLargePage(allocationSize, regionTree);
   PageMemory* storage =
       setupPageMemoryInRegion(pageMemoryRegion, 0, payloadSize);
   RELEASE_ASSERT(storage->commit());
   return storage;
 }
 
 }  // namespace blink