diff --git a/quic/quartc/test/quartc_bidi_test.cc b/quic/quartc/test/quartc_bidi_test.cc
index b1c88b7..87e4cd2 100644
--- a/quic/quartc/test/quartc_bidi_test.cc
+++ b/quic/quartc/test/quartc_bidi_test.cc
@@ -10,6 +10,7 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/quartc/simulated_packet_transport.h"
 #include "net/third_party/quiche/src/quic/quartc/test/bidi_test_runner.h"
+#include "net/third_party/quiche/src/quic/quartc/test/quartc_competing_endpoint.h"
 #include "net/third_party/quiche/src/quic/quartc/test/quic_trace_interceptor.h"
 #include "net/third_party/quiche/src/quic/quartc/test/random_packet_filter.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
@@ -22,19 +23,6 @@
 namespace test {
 namespace {
 
-class CompetingTransferAlarmDelegate : public quic::QuicAlarm::Delegate {
- public:
-  CompetingTransferAlarmDelegate(quic::simulator::QuicEndpoint* endpoint,
-                                 QuicByteCount bytes)
-      : endpoint_(endpoint), bytes_(bytes) {}
-
-  void OnAlarm() override { endpoint_->AddBytesToTransfer(bytes_); }
-
- private:
-  quic::simulator::QuicEndpoint* const endpoint_;
-  const QuicByteCount bytes_;
-};
-
 class QuartcBidiTest : public QuicTest {
  protected:
   QuartcBidiTest() {
@@ -89,19 +77,23 @@
         propagation_delay);
   }
 
-  void SetupCompetingEndpoints(QuicBandwidth bandwidth) {
-    competing_client_ = QuicMakeUnique<quic::simulator::QuicEndpoint>(
-        &simulator_, "competing_client", "competing_server",
-        quic::Perspective::IS_CLIENT, quic::test::TestConnectionId(3));
-    competing_server_ = QuicMakeUnique<quic::simulator::QuicEndpoint>(
-        &simulator_, "competing_server", "competing_client",
-        quic::Perspective::IS_SERVER, quic::test::TestConnectionId(3));
+  void SetupCompetingEndpoints(QuicBandwidth bandwidth,
+                               QuicTime::Delta send_interval,
+                               QuicByteCount bytes_per_interval) {
+    competing_client_ = QuicMakeUnique<QuartcCompetingEndpoint>(
+        &simulator_, send_interval, bytes_per_interval, "competing_client",
+        "competing_server", quic::Perspective::IS_CLIENT,
+        quic::test::TestConnectionId(3));
+    competing_server_ = QuicMakeUnique<QuartcCompetingEndpoint>(
+        &simulator_, send_interval, bytes_per_interval, "competing_server",
+        "competing_client", quic::Perspective::IS_SERVER,
+        quic::test::TestConnectionId(3));
 
     competing_client_link_ = QuicMakeUnique<quic::simulator::SymmetricLink>(
-        competing_client_.get(), client_switch_->port(3), 10 * bandwidth,
+        competing_client_->endpoint(), client_switch_->port(3), 10 * bandwidth,
         QuicTime::Delta::FromMicroseconds(1));
     competing_server_link_ = QuicMakeUnique<quic::simulator::SymmetricLink>(
-        competing_server_.get(), server_switch_->port(3), 10 * bandwidth,
+        competing_server_->endpoint(), server_switch_->port(3), 10 * bandwidth,
         QuicTime::Delta::FromMicroseconds(1));
   }
 
@@ -118,8 +110,8 @@
   std::unique_ptr<simulator::SymmetricLink> server_link_;
   std::unique_ptr<simulator::SymmetricLink> bottleneck_link_;
 
-  std::unique_ptr<simulator::QuicEndpoint> competing_client_;
-  std::unique_ptr<simulator::QuicEndpoint> competing_server_;
+  std::unique_ptr<QuartcCompetingEndpoint> competing_client_;
+  std::unique_ptr<QuartcCompetingEndpoint> competing_server_;
   std::unique_ptr<simulator::SymmetricLink> competing_client_link_;
   std::unique_ptr<simulator::SymmetricLink> competing_server_link_;
 
@@ -153,20 +145,8 @@
   QuicBandwidth bandwidth = QuicBandwidth::FromKBitsPerSecond(300);
   CreateTransports(bandwidth, QuicTime::Delta::FromMilliseconds(200),
                    10 * quic::kDefaultMaxPacketSize, /*loss_percent=*/2);
-  SetupCompetingEndpoints(bandwidth);
-
-  QuicTime competing_burst_time =
-      simulator_.GetClock()->Now() + QuicTime::Delta::FromSeconds(15);
-  std::unique_ptr<quic::QuicAlarm> competing_client_burst_alarm_ =
-      QuicWrapUnique(simulator_.GetAlarmFactory()->CreateAlarm(
-          new CompetingTransferAlarmDelegate(competing_client_.get(),
-                                             /*bytes=*/50 * 1024)));
-  std::unique_ptr<quic::QuicAlarm> competing_server_burst_alarm_ =
-      QuicWrapUnique(simulator_.GetAlarmFactory()->CreateAlarm(
-          new CompetingTransferAlarmDelegate(competing_server_.get(),
-                                             /*bytes=*/50 * 1024)));
-  competing_client_burst_alarm_->Set(competing_burst_time);
-  competing_server_burst_alarm_->Set(competing_burst_time);
+  SetupCompetingEndpoints(bandwidth, QuicTime::Delta::FromSeconds(15),
+                          /*bytes_per_interval=*/50 * 1024);
 
   quic::test::BidiTestRunner runner(&simulator_, client_transport_.get(),
                                     server_transport_.get());
diff --git a/quic/quartc/test/quartc_competing_endpoint.cc b/quic/quartc/test/quartc_competing_endpoint.cc
new file mode 100644
index 0000000..fe35045
--- /dev/null
+++ b/quic/quartc/test/quartc_competing_endpoint.cc
@@ -0,0 +1,42 @@
+// Copyright (c) 2019 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 "net/third_party/quiche/src/quic/quartc/test/quartc_competing_endpoint.h"
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"
+
+namespace quic {
+namespace test {
+
+QuartcCompetingEndpoint::QuartcCompetingEndpoint(
+    simulator::Simulator* simulator,
+    QuicTime::Delta send_interval,
+    QuicByteCount bytes_per_interval,
+    const std::string& name,
+    const std::string& peer_name,
+    Perspective perspective,
+    QuicConnectionId connection_id)
+    : Actor(simulator, QuicStrCat(name, " actor")),
+      send_interval_(send_interval),
+      bytes_per_interval_(bytes_per_interval),
+      endpoint_(QuicMakeUnique<simulator::QuicEndpoint>(simulator,
+                                                        name,
+                                                        peer_name,
+                                                        perspective,
+                                                        connection_id)) {
+  // Schedule the first send for one send interval into the test.
+  Schedule(simulator_->GetClock()->Now() + send_interval_);
+  last_send_time_ = simulator_->GetClock()->Now();
+}
+
+void QuartcCompetingEndpoint::Act() {
+  endpoint_->AddBytesToTransfer(bytes_per_interval_);
+  if (send_interval_ > QuicTime::Delta::Zero()) {
+    Schedule(last_send_time_ + send_interval_);
+  }
+  last_send_time_ = simulator_->GetClock()->Now();
+}
+
+}  // namespace test
+}  // namespace quic
diff --git a/quic/quartc/test/quartc_competing_endpoint.h b/quic/quartc/test/quartc_competing_endpoint.h
new file mode 100644
index 0000000..3b66131
--- /dev/null
+++ b/quic/quartc/test/quartc_competing_endpoint.h
@@ -0,0 +1,53 @@
+// Copyright (c) 2019 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.
+
+#ifndef QUICHE_QUIC_QUARTC_TEST_QUARTC_COMPETING_ENDPOINT_H_
+#define QUICHE_QUIC_QUARTC_TEST_QUARTC_COMPETING_ENDPOINT_H_
+
+#include <string>
+
+#include "net/third_party/quiche/src/quic/core/quic_alarm.h"
+#include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
+#include "net/third_party/quiche/src/quic/core/quic_time.h"
+#include "net/third_party/quiche/src/quic/core/quic_types.h"
+#include "net/third_party/quiche/src/quic/test_tools/simulator/actor.h"
+#include "net/third_party/quiche/src/quic/test_tools/simulator/quic_endpoint.h"
+#include "net/third_party/quiche/src/quic/test_tools/simulator/simulator.h"
+
+namespace quic {
+namespace test {
+
+// Wrapper for a QUIC endpoint that competes with a Quartc flow in simulator
+// tests.  A competing endpoint sends a fixed number of bytes at a fixed
+// frequency.
+class QuartcCompetingEndpoint : public simulator::Actor {
+ public:
+  // Creates a competing endpoint that sends |bytes_per_interval| every
+  // |send_interval|, starting one |send_interval| after it is created
+  // (according to |simulator|'s clock).
+  QuartcCompetingEndpoint(simulator::Simulator* simulator,
+                          QuicTime::Delta send_interval,
+                          QuicByteCount bytes_per_interval,
+                          const std::string& name,
+                          const std::string& peer_name,
+                          Perspective perspective,
+                          QuicConnectionId connection_id);
+
+  simulator::QuicEndpoint* endpoint() { return endpoint_.get(); }
+
+  void Act() override;
+
+ private:
+  const QuicTime::Delta send_interval_;
+  const QuicByteCount bytes_per_interval_;
+  std::unique_ptr<simulator::QuicEndpoint> endpoint_;
+  std::unique_ptr<QuicAlarm> send_alarm_;
+
+  QuicTime last_send_time_ = QuicTime::Zero();
+};
+
+}  // namespace test
+}  // namespace quic
+
+#endif  // QUICHE_QUIC_QUARTC_TEST_QUARTC_COMPETING_ENDPOINT_H_