Define Stable API for WebRTC/Quartc

net/quic/quartc/quartc_alarm_factory.cc

Index: net/quic/quartc/quartc_alarm_factory.cc
diff --git a/net/quic/chromium/quic_chromium_alarm_factory.cc b/net/quic/quartc/quartc_alarm_factory.cc
similarity index 63%
copy from net/quic/chromium/quic_chromium_alarm_factory.cc
copy to net/quic/quartc/quartc_alarm_factory.cc
index 1b8315e5c9f59e0bbffbbb7667cffc9649522e9d..a793dd2f8a817d0d7b79bdc224356651df3eac2f 100644
--- a/net/quic/chromium/quic_chromium_alarm_factory.cc
+++ b/net/quic/quartc/quartc_alarm_factory.cc
@@ -1,25 +1,22 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright (c) 2016 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/chromium/quic_chromium_alarm_factory.h"
+#include "net/quic/quartc/quartc_alarm_factory.h"
 
 #include "base/bind.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"
 
 namespace net {
 
 namespace {
 
-class QuicChromeAlarm : public QuicAlarm {
+class QuartcAlarm : public QuicAlarm {
  public:
-  QuicChromeAlarm(const QuicClock* clock,
-                  base::TaskRunner* task_runner,
-                  QuicArenaScopedPtr<QuicAlarm::Delegate> delegate)
+  QuartcAlarm(base::TaskRunner* task_runner,
+              const QuicClock* clock,
+              QuicArenaScopedPtr<QuicAlarm::Delegate> delegate)
       : QuicAlarm(std::move(delegate)),
         clock_(clock),
         task_runner_(task_runner),
@@ -47,7 +44,7 @@ class QuicChromeAlarm : public QuicAlarm {
     }
     task_runner_->PostDelayedTask(
         FROM_HERE,
-        base::Bind(&QuicChromeAlarm::OnAlarm, weak_factory_.GetWeakPtr()),
+        base::Bind(&QuartcAlarm::OnAlarm, weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromMicroseconds(delay_us));
     task_deadline_ = deadline();
   }
@@ -84,34 +81,27 @@ class QuicChromeAlarm : public QuicAlarm {
   // post a new task when the new deadline now earlier than when
   // previously posted.
   QuicTime task_deadline_;
-  base::WeakPtrFactory<QuicChromeAlarm> weak_factory_;
+  base::WeakPtrFactory<QuartcAlarm> weak_factory_;
 };
 
 }  // namespace
 
-QuicChromiumAlarmFactory::QuicChromiumAlarmFactory(
-    base::TaskRunner* task_runner,
-    const QuicClock* clock)
-    : task_runner_(task_runner), clock_(clock), weak_factory_(this) {}
+QuartcAlarmFactory::QuartcAlarmFactory(base::TaskRunner* task_runner,
+                                       const QuicClock* clock)
+    : task_runner_(task_runner), clock_(clock) {}
 
-QuicChromiumAlarmFactory::~QuicChromiumAlarmFactory() {}
+QuartcAlarmFactory::~QuartcAlarmFactory() {}
 
-QuicArenaScopedPtr<QuicAlarm> QuicChromiumAlarmFactory::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* QuartcAlarmFactory::CreateAlarm(QuicAlarm::Delegate* delegate) {
+  return new QuartcAlarm(task_runner_, clock_,
+                         QuicArenaScopedPtr<QuicAlarm::Delegate>(delegate));
 }
 
-QuicAlarm* QuicChromiumAlarmFactory::CreateAlarm(
-    QuicAlarm::Delegate* delegate) {
-  return new QuicChromeAlarm(clock_, task_runner_,
-                             QuicArenaScopedPtr<QuicAlarm::Delegate>(delegate));
+QuicArenaScopedPtr<QuicAlarm> QuartcAlarmFactory::CreateAlarm(
+    QuicArenaScopedPtr<QuicAlarm::Delegate> delegate,
+    QuicConnectionArena* arena) {
+  return QuicArenaScopedPtr<QuicAlarm>(
+      new QuartcAlarm(task_runner_, clock_, std::move(delegate)));
 }
 
 }  // namespace net