diff --git a/src/dawn/native/Toggles.cpp b/src/dawn/native/Toggles.cpp
index 35a5cea..ae42d83 100644
--- a/src/dawn/native/Toggles.cpp
+++ b/src/dawn/native/Toggles.cpp
@@ -568,7 +568,9 @@
       "Some chrome tests run with swiftshader, they don't care about the pixel output. This toggle "
       "allows skipping expensive draw operations for them.",
       "https://crbug.com/chromium/331688266", ToggleStage::Device}},
-
+    {Toggle::D3D11UseUnmonitoredFence,
+     {"d3d11_use_unmonitored_fence", "Use d3d11 unmonitored fence.",
+      "https://crbug.com/chromium/335553337", ToggleStage::Device}},
     // Comment to separate the }} so it is clearer what to copy-paste to add a toggle.
 }};
 }  // anonymous namespace
diff --git a/src/dawn/native/Toggles.h b/src/dawn/native/Toggles.h
index 05065dc..2c1909d 100644
--- a/src/dawn/native/Toggles.h
+++ b/src/dawn/native/Toggles.h
@@ -141,6 +141,8 @@
     ClearColorWithDraw,
     VulkanSkipDraw,
 
+    D3D11UseUnmonitoredFence,
+
     EnumCount,
     InvalidEnum = EnumCount,
 };
diff --git a/src/dawn/native/d3d11/CommandRecordingContextD3D11.cpp b/src/dawn/native/d3d11/CommandRecordingContextD3D11.cpp
index 14f23bf..2fc2ead 100644
--- a/src/dawn/native/d3d11/CommandRecordingContextD3D11.cpp
+++ b/src/dawn/native/d3d11/CommandRecordingContextD3D11.cpp
@@ -113,6 +113,10 @@
     return Get()->mD3D11DeviceContext4->Wait(pFence, Value);
 }
 
+void ScopedCommandRecordingContext::Flush1(D3D11_CONTEXT_TYPE ContextType, HANDLE hEvent) const {
+    return Get()->mD3D11DeviceContext4->Flush1(ContextType, hEvent);
+}
+
 void ScopedCommandRecordingContext::WriteUniformBuffer(uint32_t offset, uint32_t element) const {
     DAWN_ASSERT(offset < CommandRecordingContext::kMaxNumBuiltinElements);
     if (Get()->mUniformBufferData[offset] != element) {
diff --git a/src/dawn/native/d3d11/CommandRecordingContextD3D11.h b/src/dawn/native/d3d11/CommandRecordingContextD3D11.h
index b34acf7..59ea471 100644
--- a/src/dawn/native/d3d11/CommandRecordingContextD3D11.h
+++ b/src/dawn/native/d3d11/CommandRecordingContextD3D11.h
@@ -151,6 +151,7 @@
     void Unmap(ID3D11Resource* pResource, UINT Subresource) const;
     HRESULT Signal(ID3D11Fence* pFence, UINT64 Value) const;
     HRESULT Wait(ID3D11Fence* pFence, UINT64 Value) const;
+    void Flush1(D3D11_CONTEXT_TYPE ContextType, HANDLE hEvent) const;
 
     // Write the built-in variable value to the uniform buffer.
     void WriteUniformBuffer(uint32_t offset, uint32_t element) const;
diff --git a/src/dawn/native/d3d11/QueueD3D11.cpp b/src/dawn/native/d3d11/QueueD3D11.cpp
index 42070e5..0f0dd32 100644
--- a/src/dawn/native/d3d11/QueueD3D11.cpp
+++ b/src/dawn/native/d3d11/QueueD3D11.cpp
@@ -27,9 +27,13 @@
 
 #include "dawn/native/d3d11/QueueD3D11.h"
 
+#include <algorithm>
+#include <deque>
 #include <limits>
 #include <utility>
+#include <vector>
 
+#include "dawn/native/WaitAnySystemEvent.h"
 #include "dawn/native/d3d/D3DError.h"
 #include "dawn/native/d3d11/BufferD3D11.h"
 #include "dawn/native/d3d11/CommandBufferD3D11.h"
@@ -41,18 +45,61 @@
 
 namespace dawn::native::d3d11 {
 
+class MonitoredQueue final : public Queue {
+  public:
+    using Queue::Queue;
+    MaybeError Initialize();
+    MaybeError NextSerial() override;
+    ResultOrError<ExecutionSerial> CheckAndUpdateCompletedSerials() override;
+    void SetEventOnCompletion(ExecutionSerial serial, HANDLE event) override;
+
+  private:
+    ~MonitoredQueue() override = default;
+};
+
+class UnmonitoredQueue final : public Queue {
+  public:
+    using Queue::Queue;
+    MaybeError Initialize();
+    MaybeError NextSerial() override;
+    ResultOrError<ExecutionSerial> CheckAndUpdateCompletedSerials() override;
+    ResultOrError<bool> WaitForQueueSerial(ExecutionSerial serial, Nanoseconds timeout) override;
+    void SetEventOnCompletion(ExecutionSerial serial, HANDLE event) override;
+
+  private:
+    ~UnmonitoredQueue() override = default;
+
+    struct SerialEventReceiverPair {
+        ExecutionSerial serial;
+        SystemEventReceiver receiver;
+    };
+    // Events associated with submitted commands. They are in old to recent order.
+    MutexProtected<std::deque<SerialEventReceiverPair>> mPendingEvents;
+};
+
 ResultOrError<Ref<Queue>> Queue::Create(Device* device, const QueueDescriptor* descriptor) {
-    Ref<Queue> queue = AcquireRef(new Queue(device, descriptor));
-    DAWN_TRY(queue->Initialize());
-    return queue;
+    // TODO(crbug.com/335553337): Choose monitored or unmonitored queue by device capabilities
+    if (device->IsToggleEnabled(Toggle::D3D11UseUnmonitoredFence)) {
+        Ref<UnmonitoredQueue> unmonitoredQueue =
+            AcquireRef(new UnmonitoredQueue(device, descriptor));
+        DAWN_TRY(unmonitoredQueue->Initialize());
+        return unmonitoredQueue;
+    } else {
+        Ref<MonitoredQueue> monitoredQueue = AcquireRef(new MonitoredQueue(device, descriptor));
+        DAWN_TRY(monitoredQueue->Initialize());
+        return monitoredQueue;
+    }
 }
 
-MaybeError Queue::Initialize() {
+MaybeError Queue::Initialize(bool isMonitored) {
     // Create the fence.
-    DAWN_TRY(CheckHRESULT(ToBackend(GetDevice())
-                              ->GetD3D11Device5()
-                              ->CreateFence(0, D3D11_FENCE_FLAG_SHARED, IID_PPV_ARGS(&mFence)),
-                          "D3D11: creating fence"));
+    D3D11_FENCE_FLAG flags = D3D11_FENCE_FLAG_SHARED;
+    if (!isMonitored) {
+        flags |= D3D11_FENCE_FLAG_NON_MONITORED;
+    }
+    DAWN_TRY(CheckHRESULT(
+        ToBackend(GetDevice())->GetD3D11Device5()->CreateFence(0, flags, IID_PPV_ARGS(&mFence)),
+        isMonitored ? "D3D11: creating monitored fence" : "D3D11: creating non-monitored fence"));
 
     DAWN_TRY_ASSIGN(mSharedFence, SharedFence::Create(ToBackend(GetDevice()),
                                                       "Internal shared DXGI fence", mFence));
@@ -204,7 +251,35 @@
     return mPendingCommandsNeedSubmit.load(std::memory_order_acquire);
 }
 
-ResultOrError<ExecutionSerial> Queue::CheckAndUpdateCompletedSerials() {
+void Queue::ForceEventualFlushOfCommands() {}
+
+MaybeError Queue::WaitForIdleForDestruction() {
+    DAWN_TRY(NextSerial());
+    // Wait for all in-flight commands to finish executing
+    DAWN_TRY_ASSIGN(std::ignore, WaitForQueueSerial(GetLastSubmittedCommandSerial(),
+                                                    std::numeric_limits<Nanoseconds>::max()));
+    return CheckPassedSerials();
+}
+
+// MonitoredQueuer:
+MaybeError MonitoredQueue::Initialize() {
+    return Queue::Initialize(/*isMonitored=*/true);
+}
+
+MaybeError MonitoredQueue::NextSerial() {
+    auto commandContext = GetScopedPendingCommandContext(SubmitMode::Passive);
+
+    IncrementLastSubmittedCommandSerial();
+    TRACE_EVENT1(GetDevice()->GetPlatform(), General, "D3D11Device::SignalFence", "serial",
+                 uint64_t(GetLastSubmittedCommandSerial()));
+    DAWN_TRY(
+        CheckHRESULT(commandContext.Signal(mFence.Get(), uint64_t(GetLastSubmittedCommandSerial())),
+                     "D3D11 command queue signal fence"));
+
+    return {};
+}
+
+ResultOrError<ExecutionSerial> MonitoredQueue::CheckAndUpdateCompletedSerials() {
     ExecutionSerial completedSerial = ExecutionSerial(mFence->GetCompletedValue());
     if (DAWN_UNLIKELY(completedSerial == ExecutionSerial(UINT64_MAX))) {
         // GetCompletedValue returns UINT64_MAX if the device was removed.
@@ -227,32 +302,144 @@
     return completedSerial;
 }
 
-void Queue::ForceEventualFlushOfCommands() {}
-
-MaybeError Queue::WaitForIdleForDestruction() {
-    DAWN_TRY(NextSerial());
-    // Wait for all in-flight commands to finish executing
-    DAWN_TRY_ASSIGN(std::ignore, WaitForQueueSerial(GetLastSubmittedCommandSerial(),
-                                                    std::numeric_limits<Nanoseconds>::max()));
-    return CheckPassedSerials();
+void MonitoredQueue::SetEventOnCompletion(ExecutionSerial serial, HANDLE event) {
+    mFence->SetEventOnCompletion(static_cast<uint64_t>(serial), event);
 }
 
-MaybeError Queue::NextSerial() {
-    IncrementLastSubmittedCommandSerial();
+// UnmonitoredQueuer:
+MaybeError UnmonitoredQueue::Initialize() {
+    // TODO(crbug.com/335553337): Choose monitored or unmonitored queue by device capabilities
+    return Queue::Initialize(/*isMonitored=*/true);
+}
 
-    TRACE_EVENT1(GetDevice()->GetPlatform(), General, "D3D11Device::SignalFence", "serial",
-                 uint64_t(GetLastSubmittedCommandSerial()));
-
+MaybeError UnmonitoredQueue::NextSerial() {
     auto commandContext = GetScopedPendingCommandContext(SubmitMode::Passive);
-    DAWN_TRY(
-        CheckHRESULT(commandContext.Signal(mFence.Get(), uint64_t(GetLastSubmittedCommandSerial())),
-                     "D3D11 command queue signal fence"));
+
+    IncrementLastSubmittedCommandSerial();
+    ExecutionSerial lastSubmittedSerial = GetLastSubmittedCommandSerial();
+    // TODO(crbug.com/335553337): only signal fence when it is needed.
+    TRACE_EVENT1(GetDevice()->GetPlatform(), General, "D3D11Device::SignalFence", "serial",
+                 uint64_t(lastSubmittedSerial));
+    DAWN_TRY(CheckHRESULT(commandContext.Signal(mFence.Get(), uint64_t(lastSubmittedSerial)),
+                          "D3D11 command queue signal fence"));
+
+    SystemEventReceiver receiver;
+    DAWN_TRY_ASSIGN(receiver, GetSystemEventReceiver());
+    commandContext.Flush1(D3D11_CONTEXT_TYPE_ALL, receiver.GetPrimitive().Get());
+    mPendingEvents->push_back({lastSubmittedSerial, std::move(receiver)});
 
     return {};
 }
 
-void Queue::SetEventOnCompletion(ExecutionSerial serial, HANDLE event) {
-    mFence->SetEventOnCompletion(static_cast<uint64_t>(serial), event);
+ResultOrError<ExecutionSerial> UnmonitoredQueue::CheckAndUpdateCompletedSerials() {
+    ExecutionSerial completedSerial;
+    std::vector<SystemEventReceiver> returnedReceivers;
+    DAWN_TRY_ASSIGN(
+        completedSerial,
+        mPendingEvents.Use([&](auto pendingEvents) -> ResultOrError<ExecutionSerial> {
+            if (pendingEvents->empty()) {
+                return GetLastSubmittedCommandSerial();
+            }
+
+            StackVector<HANDLE, 8> handles;
+            const size_t numberOfHandles =
+                std::min(pendingEvents->size(), static_cast<size_t>(MAXIMUM_WAIT_OBJECTS));
+            handles->reserve(numberOfHandles);
+            // Gather events in reversed order (from the most recent to the oldest events).
+            std::for_each_n(pendingEvents->rbegin(), numberOfHandles, [&handles](const auto& e) {
+                handles->push_back(e.receiver.GetPrimitive().Get());
+            });
+            DWORD result =
+                WaitForMultipleObjects(handles->size(), handles->data(), /*bWaitAll=*/false,
+                                       /*dwMilliseconds=*/0);
+            DAWN_INTERNAL_ERROR_IF(result == WAIT_FAILED, "WaitForMultipleObjects() failed");
+
+            DAWN_INTERNAL_ERROR_IF(
+                result >= WAIT_ABANDONED_0 && result < WAIT_ABANDONED_0 + handles->size(),
+                "WaitForMultipleObjects() get abandoned event");
+
+            if (result == WAIT_TIMEOUT) {
+                return GetCompletedCommandSerial();
+            }
+
+            DAWN_CHECK(result >= WAIT_OBJECT_0 && result < WAIT_OBJECT_0 + pendingEvents->size());
+            const size_t completedEventIndex = result - WAIT_OBJECT_0;
+            // |WaitForMultipleObjects()| returns the smallest index, if more than one
+            // events are signalled. So the number of completed events are
+            // |mPendingEvents.size() - index|.
+            const size_t completedEvents = pendingEvents->size() - completedEventIndex;
+            auto completedSerial = pendingEvents->at(completedEvents - 1).serial;
+            returnedReceivers.reserve(completedEvents);
+            std::for_each_n(pendingEvents->begin(), completedEvents, [&returnedReceivers](auto& e) {
+                returnedReceivers.emplace_back(std::move(e.receiver));
+            });
+            pendingEvents->erase(pendingEvents->begin(), pendingEvents->begin() + completedEvents);
+
+            return completedSerial;
+        }));
+
+    DAWN_TRY(CheckAndMapReadyBuffers(completedSerial));
+
+    if (!returnedReceivers.empty()) {
+        DAWN_TRY(ReturnSystemEventReceivers(std::move(returnedReceivers)));
+    }
+
+    return completedSerial;
+}
+
+ResultOrError<bool> UnmonitoredQueue::WaitForQueueSerial(ExecutionSerial serial,
+                                                         Nanoseconds timeout) {
+    ExecutionSerial completedSerial = GetCompletedCommandSerial();
+    if (serial <= completedSerial) {
+        return true;
+    }
+
+    if (serial > GetLastSubmittedCommandSerial()) {
+        return DAWN_FORMAT_INTERNAL_ERROR(
+            "Wait a serial (%llu) which is greater than last submitted command serial (%llu).",
+            uint64_t(serial), uint64_t(GetLastSubmittedCommandSerial()));
+    }
+
+    bool didComplete = false;
+    std::vector<SystemEventReceiver> returnedReceivers;
+    DAWN_TRY_ASSIGN(didComplete, mPendingEvents.Use([&](auto pendingEvents) -> ResultOrError<bool> {
+        DAWN_ASSERT(!pendingEvents->empty());
+        DAWN_ASSERT(serial >= pendingEvents->front().serial);
+        DAWN_ASSERT(serial <= pendingEvents->back().serial);
+        auto it = std::lower_bound(
+            pendingEvents->begin(), pendingEvents->end(), serial,
+            [](const SerialEventReceiverPair& a, ExecutionSerial b) { return a.serial < b; });
+        DAWN_ASSERT(it != pendingEvents->end());
+        DAWN_ASSERT(it->serial == serial);
+
+        // TODO(crbug.com/335553337): call WaitForSingleObject() without holding the mutex.
+        DWORD result =
+            WaitForSingleObject(it->receiver.GetPrimitive().Get(), ToMilliseconds(timeout));
+        DAWN_INTERNAL_ERROR_IF(result == WAIT_FAILED, "WaitForSingleObject() failed");
+
+        if (result != WAIT_OBJECT_0) {
+            return false;
+        }
+
+        // Events before |it| should be signalled as well.
+        const size_t completedEvents = std::distance(pendingEvents->begin(), it) + 1;
+        returnedReceivers.reserve(completedEvents);
+        std::for_each_n(pendingEvents->begin(), completedEvents, [&returnedReceivers](auto& e) {
+            returnedReceivers.emplace_back(std::move(e.receiver));
+        });
+        pendingEvents->erase(pendingEvents->begin(), pendingEvents->begin() + completedEvents);
+        return true;
+    }));
+
+    if (!returnedReceivers.empty()) {
+        DAWN_TRY(ReturnSystemEventReceivers(std::move(returnedReceivers)));
+    }
+
+    return didComplete;
+}
+
+void UnmonitoredQueue::SetEventOnCompletion(ExecutionSerial serial, HANDLE event) {
+    DAWN_UNREACHABLE();
 }
 
 }  // namespace dawn::native::d3d11
diff --git a/src/dawn/native/d3d11/QueueD3D11.h b/src/dawn/native/d3d11/QueueD3D11.h
index ef7a8c6..657e5ad 100644
--- a/src/dawn/native/d3d11/QueueD3D11.h
+++ b/src/dawn/native/d3d11/QueueD3D11.h
@@ -30,9 +30,7 @@
 
 #include "dawn/common/MutexProtected.h"
 #include "dawn/common/SerialMap.h"
-#include "dawn/native/SystemEvent.h"
 #include "dawn/native/d3d/QueueD3D.h"
-
 #include "dawn/native/d3d11/CommandRecordingContextD3D11.h"
 #include "dawn/native/d3d11/Forward.h"
 
@@ -41,7 +39,7 @@
 class Device;
 class SharedFence;
 
-class Queue final : public d3d::Queue {
+class Queue : public d3d::Queue {
   public:
     static ResultOrError<Ref<Queue>> Create(Device* device, const QueueDescriptor* descriptor);
 
@@ -49,7 +47,7 @@
     ScopedSwapStateCommandRecordingContext GetScopedSwapStatePendingCommandContext(
         SubmitMode submitMode);
     MaybeError SubmitPendingCommands() override;
-    MaybeError NextSerial();
+    virtual MaybeError NextSerial() = 0;
 
     // Separated from creation because it creates resources, which is not valid before the
     // DeviceBase is fully created.
@@ -58,12 +56,12 @@
     // Register the pending map buffer to be checked.
     void TrackPendingMapBuffer(Ref<Buffer>&& buffer, ExecutionSerial readySerial);
 
-  private:
+  protected:
     using d3d::Queue::Queue;
 
     ~Queue() override = default;
 
-    MaybeError Initialize();
+    MaybeError Initialize(bool isMonitored);
 
     MaybeError SubmitImpl(uint32_t commandCount, CommandBufferBase* const* commands) override;
     MaybeError WriteBufferImpl(BufferBase* buffer,
@@ -78,12 +76,10 @@
 
     void DestroyImpl() override;
     bool HasPendingCommands() const override;
-    ResultOrError<ExecutionSerial> CheckAndUpdateCompletedSerials() override;
     void ForceEventualFlushOfCommands() override;
     MaybeError WaitForIdleForDestruction() override;
 
     ResultOrError<Ref<d3d::SharedFence>> GetOrCreateSharedFence() override;
-    void SetEventOnCompletion(ExecutionSerial serial, HANDLE event) override;
 
     // Check all pending map buffers, and actually map the ready ones.
     MaybeError CheckAndMapReadyBuffers(ExecutionSerial completedSerial);
diff --git a/src/dawn/tests/end2end/EventTests.cpp b/src/dawn/tests/end2end/EventTests.cpp
index f4b0342..f0b5abf 100644
--- a/src/dawn/tests/end2end/EventTests.cpp
+++ b/src/dawn/tests/end2end/EventTests.cpp
@@ -473,8 +473,9 @@
 // - Other tests?
 
 DAWN_INSTANTIATE_TEST_P(EventCompletionTests,
-                        {D3D11Backend(), D3D12Backend(), MetalBackend(), VulkanBackend(),
-                         OpenGLBackend(), OpenGLESBackend()},
+                        {D3D11Backend(), D3D11Backend({"d3d11_use_unmonitored_fence"}),
+                         D3D12Backend(), MetalBackend(), VulkanBackend(), OpenGLBackend(),
+                         OpenGLESBackend()},
                         {
                             WaitTypeAndCallbackMode::TimedWaitAny_WaitAnyOnly,
                             WaitTypeAndCallbackMode::TimedWaitAny_AllowSpontaneous,
@@ -628,6 +629,7 @@
 
 DAWN_INSTANTIATE_TEST(WaitAnyTests,
                       D3D11Backend(),
+                      D3D11Backend({"d3d11_use_unmonitored_fence"}),
                       D3D12Backend(),
                       MetalBackend(),
                       VulkanBackend(),
@@ -654,6 +656,7 @@
 
 DAWN_INSTANTIATE_TEST(FutureTests,
                       D3D11Backend(),
+                      D3D11Backend({"d3d11_use_unmonitored_fence"}),
                       D3D12Backend(),
                       MetalBackend(),
                       VulkanBackend(),
diff --git a/src/dawn/tests/end2end/QueueTests.cpp b/src/dawn/tests/end2end/QueueTests.cpp
index 5864a1c..458a71a 100644
--- a/src/dawn/tests/end2end/QueueTests.cpp
+++ b/src/dawn/tests/end2end/QueueTests.cpp
@@ -934,6 +934,7 @@
 
 DAWN_INSTANTIATE_TEST(QueueWriteTextureSimpleTests,
                       D3D11Backend(),
+                      D3D11Backend({"d3d11_use_unmonitored_fence"}),
                       D3D12Backend(),
                       MetalBackend(),
                       OpenGLBackend(),