Add first part of the network_tester functionality.

webrtc/tools/network_tester/packet_sender.cc

Index: webrtc/tools/network_tester/packet_sender.cc
diff --git a/webrtc/tools/network_tester/packet_sender.cc b/webrtc/tools/network_tester/packet_sender.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4cc1c69a9f3b32f5bd9d0f1a17b47e1aae9908ea
--- /dev/null
+++ b/webrtc/tools/network_tester/packet_sender.cc
@@ -0,0 +1,118 @@
+/*
+ *  Copyright 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/tools/network_tester/packet_sender.h"
+
+#include <string>
+#include <utility>
+
+#include "webrtc/base/timeutils.h"
+#include "webrtc/tools/network_tester/config_reader.h"
+#include "webrtc/tools/network_tester/test_controller.h"
+
+namespace webrtc {
+
+namespace {
+
+class SendPacketTask : public rtc::QueuedTask {
+ public:
+  explicit SendPacketTask(PacketSender* packet_sender)
+      : packet_sender_(packet_sender) {}
+
+ private:
+  bool Run() override {
+    if (packet_sender_->IsSending()) {
+      packet_sender_->SendPacket();
+      rtc::TaskQueue::Current()->PostDelayedTask(
+          std::unique_ptr<QueuedTask>(this),
+          packet_sender_->GetSendIntervalMs());
+      return false;
+    } else {
+      return true;
+    }
+  }
+  PacketSender* packet_sender_;
+};
+
+class UpdateTestSettingTask : public rtc::QueuedTask {
+ public:
+  UpdateTestSettingTask(PacketSender* packet_sender,
+                        std::unique_ptr<ConfigReader> config_reader)
+      : packet_sender_(packet_sender),
+        config_reader_(std::move(config_reader)) {}
+
+ private:
+  bool Run() override {
+    auto config = config_reader_->GetNextConfig();
+    if (config) {
+      packet_sender_->UpdateTestSetting((*config).packet_size,
+                                        (*config).packet_send_interval_ms);
+      rtc::TaskQueue::Current()->PostDelayedTask(
+          std::unique_ptr<QueuedTask>(this), (*config).execution_time_ms);
+      return false;
+    } else {
+      packet_sender_->StopSending();
+      return true;
+    }
+  }
+  PacketSender* packet_sender_;
+  const std::unique_ptr<ConfigReader> config_reader_;
+};
+}  // namespace
+
+PacketSender::PacketSender(TestController* test_controller,
+                           const std::string& config_file_path)
+    : worker_queue_("Packet Sender", rtc::TaskQueue::Priority::HIGH),
+      packet_size_(0),
+      send_interval_ms_(0),
+      sequence_number_(0),
+      sending_(false),
+      config_file_path_(config_file_path),
+      test_controller_(test_controller) {}
+
+PacketSender::~PacketSender() = default;
+
+void PacketSender::StartSending() {
+  sending_ = true;
+  worker_queue_.PostTask(
+      std::unique_ptr<rtc::QueuedTask>(new UpdateTestSettingTask(
+          this,
+          std::unique_ptr<ConfigReader>(new ConfigReader(config_file_path_)))));
+  worker_queue_.PostTask(
+      std::unique_ptr<rtc::QueuedTask>(new SendPacketTask(this)));
+}
+
+void PacketSender::StopSending() {
+  sending_ = false;
+  test_controller_->OnTestDone();
+}
+
+bool PacketSender::IsSending() {
+  return sending_;
+}
+
+void PacketSender::SendPacket() {
+  NetworkTesterPacket packet;
+  packet.set_type(NetworkTesterPacket::TEST_DATA);
+  packet.set_sequence_number(sequence_number_++);
+  packet.set_send_timestamp(rtc::TimeMicros());

[stefan-webrtc, 2017/03/30 07:56:53]

You could also grab this from the SignalSentPacket signal. That would be more
accurate since we avoid issues where we have to wait when hopping between
threads.

[michaelt, 2017/03/30 08:29:26]

Isn't the packet already sent on SignalSentPacket ? 

[stefan-webrtc, 2017/03/30 09:20:31]

It is signaled once the socket has sent the packet, and should better represent
when the packet "hits the wire".

[michaelt, 2017/03/30 09:31:03]

In the current impl. I have to set the send time in packet which is send.
So i can't set it after it is sent.

[stefan-webrtc, 2017/03/30 09:42:22]

I see, probably good enough anyway since the app is so simple.

+  test_controller_->SendData(packet, rtc::Optional<size_t>(packet_size_));
+}
+
+int64_t PacketSender::GetSendIntervalMs() {
+  return send_interval_ms_;
+}
+
+void PacketSender::UpdateTestSetting(size_t packet_size,
+                                     int64_t send_interval_ms) {
+  send_interval_ms_ = send_interval_ms;
+  packet_size_ = packet_size;
+}
+
+}  // namespace webrtc