Create an experiment to study whether too many bindings cause NAT failure

content/renderer/media/webrtc/stun_field_trial.h

 // Copyright 2015 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.
 
 #ifndef CONTENT_RENDERER_MEDIA_WEBRTC_STUN_FIELD_TRIAL_H_
 #define CONTENT_RENDERER_MEDIA_WEBRTC_STUN_FIELD_TRIAL_H_
 
 #include <string>
+#include <vector>
 
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
 #include "content/common/content_export.h"
 #include "third_party/webrtc/base/network.h"
+#include "third_party/webrtc/p2p/stunprober/stunprober.h"
 
 namespace rtc {
 class PacketSocketFactory;
 class SocketAddress;
 }  // namespace rtc
 
-namespace stunprober {
-class StunProber;
-}  // namespace stunprober
+namespace content {
 
-namespace content {
+// Helper class to link the StunProbers together such that they could be started
+// in the right timing.
+class StunProberWithWeakPtr {
+ public:
+  StunProberWithWeakPtr(stunprober::StunProber* prober);
+  virtual ~StunProberWithWeakPtr();
+  void set_next_prober(StunProberWithWeakPtr* prober);
+  void Start(stunprober::AsyncCallback callback);
+  base::WeakPtr<StunProberWithWeakPtr> GetWeakPtr() {
+    return weak_factory_.GetWeakPtr();
+  }
+  bool GetStats(stunprober::StunProber::Stats* stats) {
+    return prober_->GetStats(stats);
+  }
+  StunProberWithWeakPtr* GetNextProber() { return next_prober_; }
+
+ private:
+  scoped_ptr<stunprober::StunProber> prober_;
+  StunProberWithWeakPtr* next_prober_ = nullptr;

[pthatcher2, 2015/10/22 05:27:52]

So a StunProberWithWeakPtr is really a linked list of StunProbers?  If so, why
do we need a vector of these?  Isn't that a vector of a linked list?

+  base::WeakPtrFactory<StunProberWithWeakPtr> weak_factory_;
+};
+
+typedef std::vector<StunProberWithWeakPtr*> ListOfStunProbers;

[pthatcher2, 2015/10/22 05:27:52]

Doesn't the style guide discourage typedefs like this?  Since have c++11 for
loops, the pain of just using std::vector<StunProberWithWeakPtr*> is quite
small.

 
 // Wait for 30 seconds to avoid high CPU usage during browser start-up which
 // might affect the accuracy of the trial. The trial wakes up the browser every
 // 1 ms for no more than 3 seconds to see if time has passed for sending next
 // stun probe.
 static const int kExperimentStartDelayMs = 30000;
 
 // This will use |factory| to create sockets, send stun binding requests with
 // various intervals as determined by |params|, observed the success rate and
 // latency of the stun responses and report through UMA.
-scoped_ptr<stunprober::StunProber> StartStunProbeTrial(
-    const rtc::NetworkManager::NetworkList& networks,
-    const std::string& params,
-    rtc::PacketSocketFactory* factory);
+void StartStunProbeTrial(const rtc::NetworkManager::NetworkList& networks,
+                         const std::string& params,
+                         rtc::PacketSocketFactory* factory,
+                         ListOfStunProbers* probers);
 
 // Parsing function to decode the '/' separated parameter string |params|.
 CONTENT_EXPORT bool ParseStunProbeParameters(
     const std::string& params,
     int* requests_per_ip,
     int* interval_ms,
     int* shared_socket_mode,
+    int* rounds,
     std::vector<rtc::SocketAddress>* servers);
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_WEBRTC_STUN_FIELD_TRIAL_H_