Define Stable API for WebRTC/Quartc

net/quic/quartc/quartc_alarm_factory.cc

-// 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(const QuicClock* clock,
+              base::TaskRunner* task_runner,
+              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()) {
         // Since tasks can not be un-posted, OnAlarm will be invoked which
         // will notice that deadline has not yet been reached, and will set
         // the alarm for the new deadline.
         return;
       }
       // The scheduled task is after new deadline.  Invalidate the weak ptrs
       // so that task does not execute when we're not expecting it.
       weak_factory_.InvalidateWeakPtrs();
     }
 
     int64_t delay_us = (deadline() - (clock_->Now())).ToMicroseconds();
     if (delay_us < 0) {
       delay_us = 0;
     }
     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();
   }
 
   void CancelImpl() override {
     DCHECK(!deadline().IsInitialized());
     // Since tasks can not be un-posted, OnAlarm will be invoked which
     // will notice that deadline is not Initialized and will do nothing.
   }
 
@@ skipping 16 matching lines @@
   }
 
   const QuicClock* clock_;
   base::TaskRunner* task_runner_;
   // If a task has been posted to the message loop, this is the time it
   // was scheduled to fire.  Tracking this allows us to avoid posting a
   // new tast if the new deadline is in the future, but permits us to
   // 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_;
 };

[pthatcher2, 2016/10/05 22:12:04]

So if the only thing different between the QuartcAlarm and the QuicChromeAlarm
is the name, why don't we just use the QuicChromeAlarm?

 
 }  // 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(
+QuicAlarm* QuartcAlarmFactory::CreateAlarm(QuicAlarm::Delegate* delegate) {
+  return new QuartcAlarm(clock_, task_runner_,
+                         QuicArenaScopedPtr<QuicAlarm::Delegate>(delegate));
+}
+
+QuicArenaScopedPtr<QuicAlarm> QuartcAlarmFactory::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* QuicChromiumAlarmFactory::CreateAlarm(
-    QuicAlarm::Delegate* delegate) {
-  return new QuicChromeAlarm(clock_, task_runner_,
-                             QuicArenaScopedPtr<QuicAlarm::Delegate>(delegate));
+  return QuicArenaScopedPtr<QuicAlarm>(
+      new QuartcAlarm(clock_, task_runner_, std::move(delegate)));
 }
 
 }  // namespace net