Index: lib/sanitizer_common/tests/sanitizer_allocator_test.cc
===================================================================
--- lib/sanitizer_common/tests/sanitizer_allocator_test.cc
+++ lib/sanitizer_common/tests/sanitizer_allocator_test.cc
@@ -14,6 +14,7 @@
 #include "sanitizer_common/sanitizer_allocator.h"
 #include "sanitizer_common/sanitizer_allocator_internal.h"
 #include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_remote_address_space_view.h"
 
 #include "sanitizer_test_utils.h"
 #include "sanitizer_pthread_wrappers.h"
@@ -502,6 +503,11 @@
   //         TestMapUnmapCallback::unmap_count);
 }
 
+template <typename AddressSpaceView>
+using LargeMmapAllocatorASVT =
+    LargeMmapAllocator<NoOpMapUnmapCallback, DefaultLargeMmapAllocatorPtrArray,
+                       AddressSpaceView>;
+
 TEST(SanitizerCommon, LargeMmapAllocatorMapUnmapCallback) {
   TestMapUnmapCallback::map_count = 0;
   TestMapUnmapCallback::unmap_count = 0;
@@ -620,12 +626,19 @@
   a.Deallocate(&stats, p);
 }
 
-template
-<class PrimaryAllocator, class SecondaryAllocator, class AllocatorCache>
+template <template <class> class PrimaryAllocatorASVT,
+          template <class> class SecondaryAllocatorASVT,
+          template <class> class AllocatorCacheT>
 void TestCombinedAllocator() {
-  typedef
-      CombinedAllocator<PrimaryAllocator, AllocatorCache, SecondaryAllocator>
-      Allocator;
+  using AllocatorCache =
+      AllocatorCacheT<PrimaryAllocatorASVT<LocalAddressSpaceView>>;
+  using Allocator = CombinedAllocator<
+      PrimaryAllocatorASVT<LocalAddressSpaceView>, AllocatorCache,
+      SecondaryAllocatorASVT<LocalAddressSpaceView>, LocalAddressSpaceView>;
+  using AllocatorRemoteView = CombinedAllocator<
+      PrimaryAllocatorASVT<RemoteAddressSpaceView>,
+      AllocatorCacheT<PrimaryAllocatorASVT<RemoteAddressSpaceView>>,
+      SecondaryAllocatorASVT<RemoteAddressSpaceView>, RemoteAddressSpaceView>;
   Allocator *a = new Allocator;
   a->Init(kReleaseToOSIntervalNever);
   std::mt19937 r;
@@ -661,6 +674,7 @@
     // Test ForEachChunk(...)
     {
       std::set<void *> reported_chunks;
+      std::set<void *> reported_chunks_remote_view;
       auto cb = [](uptr chunk, void *arg) {
         auto reported_chunks_ptr = reinterpret_cast<std::set<void *> *>(arg);
         auto pair =
@@ -669,8 +683,30 @@
         ASSERT_TRUE(pair.second);
       };
       a->ForEachChunk(cb, reinterpret_cast<void *>(&reported_chunks));
+
+      // Test the RemoteAddressSpaceView functionality of the allocator.
+      {
+        // We need the data layout when instantiated with LocalAddressSpaceView
+        // or RemoteAddressSpaceView to be identical. Checking all of this is
+        // cumbersome and not maintainable so just check for size mismatch for
+        // now.
+        static_assert(sizeof(Allocator) == sizeof(AllocatorRemoteView),
+                      "size mismatch");
+        AllocatorRemoteView *a_remote_view =
+            reinterpret_cast<AllocatorRemoteView *>(a);
+        // Create in-process VMReadContext object.
+        ScopedRemoteAddressSpaceViewContext remote_view_context;
+
+        // Now try to enumerate the chunks again but this time using the
+        // `RemoteAddressSpaceView` implementation.
+        a_remote_view->ForEachChunk(
+            cb, reinterpret_cast<void *>(&reported_chunks_remote_view));
+      }
+
       for (const auto &allocated_ptr : allocated) {
         ASSERT_NE(reported_chunks.find(allocated_ptr), reported_chunks.end());
+        ASSERT_NE(reported_chunks_remote_view.find(allocated_ptr),
+                  reported_chunks_remote_view.end());
       }
     }
 
@@ -691,36 +727,31 @@
 
 #if SANITIZER_CAN_USE_ALLOCATOR64
 TEST(SanitizerCommon, CombinedAllocator64) {
-  TestCombinedAllocator<Allocator64,
-      LargeMmapAllocator<>,
-      SizeClassAllocatorLocalCache<Allocator64> > ();
+  TestCombinedAllocator<Allocator64ASVT, LargeMmapAllocatorASVT,
+                        SizeClassAllocatorLocalCache>();
 }
 
 TEST(SanitizerCommon, CombinedAllocator64Dynamic) {
-  TestCombinedAllocator<Allocator64Dynamic,
-      LargeMmapAllocator<>,
-      SizeClassAllocatorLocalCache<Allocator64Dynamic> > ();
+  TestCombinedAllocator<Allocator64DynamicASVT, LargeMmapAllocatorASVT,
+                        SizeClassAllocatorLocalCache>();
 }
 
 #if !SANITIZER_ANDROID
 TEST(SanitizerCommon, CombinedAllocator64Compact) {
-  TestCombinedAllocator<Allocator64Compact,
-      LargeMmapAllocator<>,
-      SizeClassAllocatorLocalCache<Allocator64Compact> > ();
+  TestCombinedAllocator<Allocator64CompactASVT, LargeMmapAllocatorASVT,
+                        SizeClassAllocatorLocalCache>();
 }
 #endif
 
 TEST(SanitizerCommon, CombinedAllocator64VeryCompact) {
-  TestCombinedAllocator<Allocator64VeryCompact,
-      LargeMmapAllocator<>,
-      SizeClassAllocatorLocalCache<Allocator64VeryCompact> > ();
+  TestCombinedAllocator<Allocator64VeryCompactASVT, LargeMmapAllocatorASVT,
+                        SizeClassAllocatorLocalCache>();
 }
 #endif
 
 TEST(SanitizerCommon, CombinedAllocator32Compact) {
-  TestCombinedAllocator<Allocator32Compact,
-      LargeMmapAllocator<>,
-      SizeClassAllocatorLocalCache<Allocator32Compact> > ();
+  TestCombinedAllocator<Allocator32CompactASVT, LargeMmapAllocatorASVT,
+                        SizeClassAllocatorLocalCache>();
 }
 
 template <class AllocatorCache>
@@ -905,8 +936,10 @@
   reinterpret_cast<std::set<uptr> *>(arg)->insert(chunk);
 }
 
-template <class Allocator>
+template <template <class> class AllocatorASVT>
 void TestSizeClassAllocatorIteration() {
+  using Allocator = AllocatorASVT<LocalAddressSpaceView>;
+  using AllocatorRemoteView = AllocatorASVT<RemoteAddressSpaceView>;
   Allocator *a = new Allocator;
   a->Init(kReleaseToOSIntervalNever);
   SizeClassAllocatorLocalCache<Allocator> cache;
@@ -933,14 +966,41 @@
   }
 
   std::set<uptr> reported_chunks;
+  std::set<uptr> reported_chunks_remote_view;
   a->ForceLock();
   a->ForEachChunk(IterationTestCallback, &reported_chunks);
   a->ForceUnlock();
 
+  // Test the RemoteAddressSpaceView functionality of the
+  // allocator. This is done outside the lock because in the
+  // RemoteAddressSpaceView case there is no guarantee that the remote allocator
+  // is locked.
+  {
+    // We need the data layout when instantiated with LocalAddressSpaceView
+    // or RemoteAddressSpaceView to be identical. Checking all of this is
+    // cumbersome and not maintainable so just check for size mismatch for
+    // now.
+    static_assert(sizeof(Allocator) == sizeof(AllocatorRemoteView),
+                  "size mismatch");
+    AllocatorRemoteView *a_remote_view =
+        reinterpret_cast<AllocatorRemoteView *>(a);
+
+    // Create in-process VMReadContext object.
+    ScopedRemoteAddressSpaceViewContext remote_view_context;
+
+    // Now try to enumerate the chunks again but this time using the
+    // `RemoteAddressSpaceView` implementation.
+    a_remote_view->ForEachChunk(IterationTestCallback,
+                                &reported_chunks_remote_view);
+  }
+
   for (uptr i = 0; i < allocated.size(); i++) {
     // Don't use EXPECT_NE. Reporting the first mismatch is enough.
     ASSERT_NE(reported_chunks.find(reinterpret_cast<uptr>(allocated[i])),
               reported_chunks.end());
+    ASSERT_NE(
+        reported_chunks_remote_view.find(reinterpret_cast<uptr>(allocated[i])),
+        reported_chunks_remote_view.end());
   }
 
   a->TestOnlyUnmap();
@@ -952,20 +1012,22 @@
 // to run them all at the same time. FIXME: Make them not flaky and reenable.
 #if !SANITIZER_WINDOWS
 TEST(SanitizerCommon, SizeClassAllocator64Iteration) {
-  TestSizeClassAllocatorIteration<Allocator64>();
+  TestSizeClassAllocatorIteration<Allocator64ASVT>();
 }
 TEST(SanitizerCommon, SizeClassAllocator64DynamicIteration) {
-  TestSizeClassAllocatorIteration<Allocator64Dynamic>();
+  TestSizeClassAllocatorIteration<Allocator64DynamicASVT>();
 }
 #endif
 #endif
 
 TEST(SanitizerCommon, SizeClassAllocator32Iteration) {
-  TestSizeClassAllocatorIteration<Allocator32Compact>();
+  TestSizeClassAllocatorIteration<Allocator32CompactASVT>();
 }
 
 TEST(SanitizerCommon, LargeMmapAllocatorIteration) {
-  LargeMmapAllocator<NoOpMapUnmapCallback> a;
+  LargeMmapAllocatorASVT<LocalAddressSpaceView> a;
+  using LargeMmapAllocatorRemoteView =
+      LargeMmapAllocatorASVT<RemoteAddressSpaceView>;
   a.Init();
   AllocatorStats stats;
   stats.Init();
@@ -978,14 +1040,39 @@
     allocated[i] = (char *)a.Allocate(&stats, size, 1);
 
   std::set<uptr> reported_chunks;
+  std::set<uptr> reported_chunks_remote_view;
   a.ForceLock();
   a.ForEachChunk(IterationTestCallback, &reported_chunks);
   a.ForceUnlock();
 
+  // Test the RemoteAddressSpaceView functionality of the allocator.
+  {
+    // We need the data layout when instantiated with LocalAddressSpaceView
+    // or RemoteAddressSpaceView to be identical. Checking all of this is
+    // cumbersome and not maintainable so just check for size mismatch for
+    // now.
+    static_assert(sizeof(a) == sizeof(LargeMmapAllocatorRemoteView),
+                  "size mismatch");
+    LargeMmapAllocatorRemoteView *a_remote_view =
+        reinterpret_cast<LargeMmapAllocatorRemoteView *>(&a);
+
+    // Create in-process VMReadContext object.
+    ScopedRemoteAddressSpaceViewContext remote_view_context;
+
+    // Now try to enumerate the chunks again but this time using the
+    // `RemoteAddressSpaceView` implementation.
+    a_remote_view->ForEachChunk(
+        IterationTestCallback,
+        reinterpret_cast<void *>(&reported_chunks_remote_view));
+  }
+
   for (uptr i = 0; i < kNumAllocs; i++) {
     // Don't use EXPECT_NE. Reporting the first mismatch is enough.
     ASSERT_NE(reported_chunks.find(reinterpret_cast<uptr>(allocated[i])),
               reported_chunks.end());
+    ASSERT_NE(
+        reported_chunks_remote_view.find(reinterpret_cast<uptr>(allocated[i])),
+        reported_chunks_remote_view.end());
   }
   for (uptr i = 0; i < kNumAllocs; i++)
     a.Deallocate(&stats, allocated[i]);