Add a histogram metric tracking for how long audio RTP packets are sent

webrtc/rtc_base/time_interval.cc

Index: webrtc/rtc_base/time_interval.cc
diff --git a/webrtc/rtc_base/time_interval.cc b/webrtc/rtc_base/time_interval.cc
new file mode 100644
index 0000000000000000000000000000000000000000..940c424642dac4c45593df7c23b327ae98e097fd
--- /dev/null
+++ b/webrtc/rtc_base/time_interval.cc
@@ -0,0 +1,44 @@
+/*
+ *  Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "webrtc/rtc_base/time_interval.h"
+#include "webrtc/rtc_base/timeutils.h"
+
+namespace rtc {
+
+TimeInterval::TimeInterval() {}

[ossu, 2017/07/14 11:13:15]

= default instead of {}

[saza WebRTC, 2017/07/17 14:27:29]

Done.

+TimeInterval::~TimeInterval() {}

[ossu, 2017/07/14 11:13:15]

Same here.

[saza WebRTC, 2017/07/17 14:27:29]

Done.

+
+void TimeInterval::Extend() {
+  Extend(TimeMillis());
+}
+
+void TimeInterval::Extend(int64_t time) {
+  if (!first_ || time < *first_) {

[ossu, 2017/07/14 11:13:15]

Just a minor detail, but first_ and last_ aren't both individually optional.
You'll either have an interval with both first and last points (possibly equal)
or no interval. I'd probably restructure it as:

In the header:
struct Interval {
  int64_t first, last;
};

rtc::Optional<Interval> interval_;

Here:
if (!interval_) {
  interval_.emplace{{time, time});
} else {
  ... comparisons go here ...
}

This probably save a whole eight bytes of memory per TimeInterval as well. :)

[ossu, 2017/07/14 15:37:32]

Rietveld top-tip: If you reply to the comments individually on the diff pages,
rather than in the main reply message, you'll get neat threads that are easier
to follow! I've tried to sort-of hack your message back into this comment
thread. It probably won't work well. :)

On 2017/07/14 15:04:00, Sam Zackrisson WebRTC wrote:
Hmm... You _could_ just have First() and Last() return int64_t and in them
DCHECK that the internal interval_ is set... though Optional will also check
that for you. In a way, accessing TimeInterval::First() when Empty() is as wrong
as accessing operator* on an Optional that's empty. I.e. there's no particular
reason to signal nonexistence of First() both through Empty() and the through
return value of First(). 

[saza WebRTC, 2017/07/17 14:27:29]

Oh, thanks for the tip!

+    first_.emplace(time);
+  }
+  if (!last_ || *last_ < time) {
+    last_.emplace(time);
+  }
+}
+
+bool TimeInterval::Empty() const {
+  return !first_;
+}
+
+Optional<int64_t> TimeInterval::First() const {
+  return first_;
+}
+
+Optional<int64_t> TimeInterval::Last() const {
+  return last_;
+}
+
+}  // namespace rtc