Propagate packet pacing information to SenTimeHistory

webrtc/modules/pacing/bitrate_prober.h

 /*
  *  Copyright (c) 2014 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.
  */
 
 #ifndef WEBRTC_MODULES_PACING_BITRATE_PROBER_H_
 #define WEBRTC_MODULES_PACING_BITRATE_PROBER_H_
 
 #include <queue>
 
 #include "webrtc/base/basictypes.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
 
+class ProbeClusterCreatedObserver {
+ public:
+  virtual ~ProbeClusterCreatedObserver() {}
+  virtual void OnProbingClusterCreated(int cluster_id,

[nisse-webrtc, 2017/01/10 16:04:41]

Please document what the parameters mean.

Might also make sense to collect them into a struct and pass a const&.

It's unclear to me what use the CongestionController can make of the fact that a
probe was created. I would have expected the measurement *results*, once the
probe is complete and ACKs are seen, to be signalled to the
CongestionController.

[philipel, 2017/01/11 09:03:33]

Done
The CongestionController can't do anything with this data other than pass it on.
The reason the CongestionController is the class that implements this interface
is because it is the first class that connects the BitrateProber and the
ProbeBitrateEstimator.

[nisse-webrtc, 2017/01/11 09:10:32]

Even if it delegates the processing, I still don't see how it's useful. The
result of the probe is needed before it can be useful for estimating stuff.

Or is this rather a *request* to start sending a new probe? If so, I think it
needs a different name. 

I feel I don't grasp the big picture here.

+                                       int min_bytes,
+                                       int min_probes) = 0;
+};
+
 // Note that this class isn't thread-safe by itself and therefore relies
 // on being protected by the caller.
 class BitrateProber {
  public:
   BitrateProber();
 
+  explicit BitrateProber(ProbeClusterCreatedObserver* cluster_created_observer);
+
   void SetEnabled(bool enable);
 
   // Returns true if the prober is in a probing session, i.e., it currently
   // wants packets to be sent out according to the time returned by
   // TimeUntilNextProbe().
   bool IsProbing() const;
 
   // Initializes a new probing session if the prober is allowed to probe. Does
   // not initialize the prober unless the packet size is large enough to probe
   // with.
@@ skipping 56 matching lines @@
 
   // Probe bitrate per packet. These are used to compute the delta relative to
   // the previous probe packet based on the size and time when that packet was
   // sent.
   std::queue<ProbeCluster> clusters_;
 
   // Time the next probe should be sent when in kActive state.
   int64_t next_probe_time_ms_;
 
   int next_cluster_id_;
+
+  ProbeClusterCreatedObserver* cluster_created_observer_;
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_PACING_BITRATE_PROBER_H_