diff --git a/quiche/quic/bindings/quic_libevent.cc b/quiche/quic/bindings/quic_libevent.cc
index 083236d..668f441 100644
--- a/quiche/quic/bindings/quic_libevent.cc
+++ b/quiche/quic/bindings/quic_libevent.cc
@@ -65,8 +65,7 @@
 LibeventQuicEventLoop::LibeventQuicEventLoop(event_base* base, QuicClock* clock)
     : base_(base),
       edge_triggered_(event_base_get_features(base) & EV_FEATURE_ET),
-      clock_(clock),
-      alarm_factory_(this) {
+      clock_(clock) {
   QUICHE_CHECK_LE(sizeof(event), event_get_struct_event_size())
       << "libevent ABI mismatch: sizeof(event) is bigger than the one QUICHE "
          "has been compiled with";
diff --git a/quiche/quic/bindings/quic_libevent.h b/quiche/quic/bindings/quic_libevent.h
index 1f46e71..5eabb45 100644
--- a/quiche/quic/bindings/quic_libevent.h
+++ b/quiche/quic/bindings/quic_libevent.h
@@ -26,7 +26,9 @@
 
   // QuicEventLoop implementation.
   bool SupportsEdgeTriggered() const override { return edge_triggered_; }
-  QuicAlarmFactory* GetAlarmFactory() override { return &alarm_factory_; }
+  std::unique_ptr<QuicAlarmFactory> CreateAlarmFactory() override {
+    return std::make_unique<AlarmFactory>(this);
+  }
   bool RegisterSocket(QuicUdpSocketFd fd, QuicSocketEventMask events,
                       QuicSocketEventListener* listener) override;
   bool UnregisterSocket(QuicUdpSocketFd fd) override;
@@ -85,7 +87,6 @@
   QuicClock* clock_;
 
   RegistrationMap registration_map_;
-  AlarmFactory alarm_factory_;
 };
 
 // RAII-style wrapper around event_base.
diff --git a/quiche/quic/bindings/quic_libevent_test.cc b/quiche/quic/bindings/quic_libevent_test.cc
index 20dcbad..e6f2427 100644
--- a/quiche/quic/bindings/quic_libevent_test.cc
+++ b/quiche/quic/bindings/quic_libevent_test.cc
@@ -49,8 +49,10 @@
   auto event_loop_owned = QuicLibeventEventLoopFactory::Get()->Create(clock);
   LibeventQuicEventLoop* event_loop =
       static_cast<LibeventQuicEventLoop*>(event_loop_owned.get());
-  std::unique_ptr<QuicAlarm> timeout_alarm = absl::WrapUnique(
-      event_loop->GetAlarmFactory()->CreateAlarm(new FailureAlarmDelegate()));
+  std::unique_ptr<QuicAlarmFactory> alarm_factory =
+      event_loop->CreateAlarmFactory();
+  std::unique_ptr<QuicAlarm> timeout_alarm =
+      absl::WrapUnique(alarm_factory->CreateAlarm(new FailureAlarmDelegate()));
 
   const QuicTime kTimeoutAt = clock->Now() + QuicTime::Delta::FromSeconds(10);
   timeout_alarm->Set(kTimeoutAt);
diff --git a/quiche/quic/core/io/quic_all_event_loops_test.cc b/quiche/quic/core/io/quic_all_event_loops_test.cc
index c9e4dab..841717f 100644
--- a/quiche/quic/core/io/quic_all_event_loops_test.cc
+++ b/quiche/quic/core/io/quic_all_event_loops_test.cc
@@ -62,7 +62,8 @@
     : public QuicTestWithParam<QuicEventLoopFactory*> {
  public:
   QuicEventLoopFactoryTest()
-      : loop_(GetParam()->Create(&clock_)), factory_(loop_->GetAlarmFactory()) {
+      : loop_(GetParam()->Create(&clock_)),
+        factory_(loop_->CreateAlarmFactory()) {
     int fds[2];
     int result = ::pipe(fds);
     QUICHE_CHECK(result >= 0) << "Failed to create a pipe, errno: " << errno;
@@ -96,7 +97,7 @@
  protected:
   QuicDefaultClock clock_;
   std::unique_ptr<QuicEventLoop> loop_;
-  QuicAlarmFactory* factory_;
+  std::unique_ptr<QuicAlarmFactory> factory_;
   int read_fd_;
   int write_fd_;
 };
diff --git a/quiche/quic/core/io/quic_event_loop.h b/quiche/quic/core/io/quic_event_loop.h
index be82ac7..1b09562 100644
--- a/quiche/quic/core/io/quic_event_loop.h
+++ b/quiche/quic/core/io/quic_event_loop.h
@@ -73,8 +73,8 @@
   virtual void RunEventLoopOnce(QuicTime::Delta default_timeout) = 0;
 
   // Returns an alarm factory that allows alarms to be scheduled on this event
-  // loop.  The factory is owned by the event loop.
-  virtual QuicAlarmFactory* GetAlarmFactory() = 0;
+  // loop.
+  virtual std::unique_ptr<QuicAlarmFactory> CreateAlarmFactory() = 0;
 };
 
 // A factory object for the event loop. Every implementation is expected to have
diff --git a/quiche/quic/core/io/quic_poll_event_loop.cc b/quiche/quic/core/io/quic_poll_event_loop.cc
index f7a9794..286dd65 100644
--- a/quiche/quic/core/io/quic_poll_event_loop.cc
+++ b/quiche/quic/core/io/quic_poll_event_loop.cc
@@ -36,8 +36,7 @@
 
 }  // namespace
 
-QuicPollEventLoop::QuicPollEventLoop(QuicClock* clock)
-    : clock_(clock), alarm_factory_(this) {}
+QuicPollEventLoop::QuicPollEventLoop(QuicClock* clock) : clock_(clock) {}
 
 bool QuicPollEventLoop::RegisterSocket(QuicUdpSocketFd fd,
                                        QuicSocketEventMask events,
@@ -258,8 +257,8 @@
   current_schedule_handle_.reset();
 }
 
-QuicAlarmFactory* QuicPollEventLoop::GetAlarmFactory() {
-  return &alarm_factory_;
+std::unique_ptr<QuicAlarmFactory> QuicPollEventLoop::CreateAlarmFactory() {
+  return std::make_unique<AlarmFactory>(this);
 }
 
 }  // namespace quic
diff --git a/quiche/quic/core/io/quic_poll_event_loop.h b/quiche/quic/core/io/quic_poll_event_loop.h
index f99f220..4e19ff9 100644
--- a/quiche/quic/core/io/quic_poll_event_loop.h
+++ b/quiche/quic/core/io/quic_poll_event_loop.h
@@ -50,7 +50,7 @@
   ABSL_MUST_USE_RESULT bool ArtificiallyNotifyEvent(
       QuicUdpSocketFd fd, QuicSocketEventMask events) override;
   void RunEventLoopOnce(QuicTime::Delta default_timeout) override;
-  QuicAlarmFactory* GetAlarmFactory() override;
+  std::unique_ptr<QuicAlarmFactory> CreateAlarmFactory() override;
 
  protected:
   // Allows poll(2) calls to be mocked out in unit tests.
@@ -143,7 +143,6 @@
   const QuicClock* clock_;
   RegistrationMap registrations_;
   AlarmList alarms_;
-  AlarmFactory alarm_factory_;
   bool has_artificial_events_pending_ = false;
 };
 
diff --git a/quiche/quic/core/io/quic_poll_event_loop_test.cc b/quiche/quic/core/io/quic_poll_event_loop_test.cc
index d8ad01f..f0e9557 100644
--- a/quiche/quic/core/io/quic_poll_event_loop_test.cc
+++ b/quiche/quic/core/io/quic_poll_event_loop_test.cc
@@ -86,7 +86,8 @@
 
 class QuicPollEventLoopTest : public QuicTest {
  public:
-  QuicPollEventLoopTest() : loop_(&clock_), factory_(loop_.GetAlarmFactory()) {
+  QuicPollEventLoopTest()
+      : loop_(&clock_), factory_(loop_.CreateAlarmFactory()) {
     int fds[2];
     int result = ::pipe(fds);
     QUICHE_CHECK(result >= 0) << "Failed to create a pipe, errno: " << errno;
@@ -123,7 +124,7 @@
  protected:
   MockClock clock_;
   QuicPollEventLoopForTest loop_;
-  QuicAlarmFactory* factory_;
+  std::unique_ptr<QuicAlarmFactory> factory_;
   int read_fd_;
   int write_fd_;
 };