QuicAlarms are now allocated out of an arena in QuicConnection

net/quic/quic_chromium_connection_helper.cc

 // Copyright (c) 2012 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/quic/quic_chromium_connection_helper.h"
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/task_runner.h"
 #include "base/time/time.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/quic/quic_utils.h"
 
 namespace net {
 
 namespace {
 
 class QuicChromeAlarm : public QuicAlarm {
  public:
   QuicChromeAlarm(const QuicClock* clock,
                   base::TaskRunner* task_runner,
-                  QuicAlarm::Delegate* delegate)
-      : QuicAlarm(delegate),
+                  QuicArenaScopedPtr<QuicAlarm::Delegate> delegate)
+      : QuicAlarm(std::move(delegate)),
         clock_(clock),
         task_runner_(task_runner),
         task_deadline_(QuicTime::Zero()),
         weak_factory_(this) {}
 
  protected:
   void SetImpl() override {
     DCHECK(deadline().IsInitialized());
     if (task_deadline_.IsInitialized()) {
       if (task_deadline_ <= deadline()) {
@@ skipping 67 matching lines @@
 QuicChromiumConnectionHelper::~QuicChromiumConnectionHelper() {}
 
 const QuicClock* QuicChromiumConnectionHelper::GetClock() const {
   return clock_;
 }
 
 QuicRandom* QuicChromiumConnectionHelper::GetRandomGenerator() {
   return random_generator_;
 }
 
+QuicArenaScopedPtr<QuicAlarm> QuicChromiumConnectionHelper::CreateAlarm(
+    QuicArenaScopedPtr<QuicAlarm::Delegate> delegate,
+    QuicConnectionArena* arena) {
+  if (arena != nullptr) {
+    return arena->New<QuicChromeAlarm>(clock_, task_runner_,
+                                       std::move(delegate));
+  } else {
+    return QuicArenaScopedPtr<QuicAlarm>(
+        new QuicChromeAlarm(clock_, task_runner_, std::move(delegate)));
+  }
+}
+
 QuicAlarm* QuicChromiumConnectionHelper::CreateAlarm(
     QuicAlarm::Delegate* delegate) {
-  return new QuicChromeAlarm(clock_, task_runner_, delegate);
+  return new QuicChromeAlarm(clock_, task_runner_,
+                             QuicArenaScopedPtr<QuicAlarm::Delegate>(delegate));
 }
 
 QuicBufferAllocator* QuicChromiumConnectionHelper::GetBufferAllocator() {
   return &buffer_allocator_;
 }
 
 }  // namespace net