Reland "Adding ANA config event to debug dump."

Originally review in https://chromium-review.googlesource.com/c/535554/

Reverted in https://chromium-review.googlesource.com/c/539737/ due to upstreaming failure.

BUG=webrtc:7854

Change-Id: Ie4ad6ecfaf0f6b556dc662512d0be8ce94f8a4a8
Reviewed-on: https://chromium-review.googlesource.com/541436
Commit-Queue: Minyue Li <minyue@webrtc.org>
Reviewed-by: Oskar Sundbom <ossu@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#18865}

webrtc/modules/audio_coding/audio_network_adaptor/controller_manager.cc

@@ -17,6 +17,7 @@
 #include "webrtc/base/timeutils.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/bitrate_controller.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/channel_controller.h"
+#include "webrtc/modules/audio_coding/audio_network_adaptor/debug_dump_writer.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/dtx_controller.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based.h"
@@ -201,9 +202,29 @@ std::unique_ptr<ControllerManager> ControllerManagerImpl::Create(
     int initial_bitrate_bps,
     bool initial_fec_enabled,
     bool initial_dtx_enabled) {
+  return Create(config_string, num_encoder_channels, encoder_frame_lengths_ms,
+                min_encoder_bitrate_bps, intial_channels_to_encode,
+                initial_frame_length_ms, initial_bitrate_bps,
+                initial_fec_enabled, initial_dtx_enabled, nullptr);
+}
+
+std::unique_ptr<ControllerManager> ControllerManagerImpl::Create(
+    const ProtoString& config_string,
+    size_t num_encoder_channels,
+    rtc::ArrayView<const int> encoder_frame_lengths_ms,
+    int min_encoder_bitrate_bps,
+    size_t intial_channels_to_encode,
+    int initial_frame_length_ms,
+    int initial_bitrate_bps,
+    bool initial_fec_enabled,
+    bool initial_dtx_enabled,
+    DebugDumpWriter* debug_dump_writer) {
 #if WEBRTC_ENABLE_PROTOBUF
   audio_network_adaptor::config::ControllerManager controller_manager_config;
-  controller_manager_config.ParseFromString(config_string);
+  RTC_CHECK(controller_manager_config.ParseFromString(config_string));
+  if (debug_dump_writer)
+    debug_dump_writer->DumpControllerManagerConfig(controller_manager_config,
+                                                   rtc::TimeMillis());
 
   std::vector<std::unique_ptr<Controller>> controllers;
   std::map<const Controller*, std::pair<int, float>> scoring_points;

webrtc/modules/audio_coding/audio_network_adaptor/controller_manager.h

@@ -21,6 +21,8 @@
 
 namespace webrtc {
 
+class DebugDumpWriter;
+
 class ControllerManager {
  public:
   virtual ~ControllerManager() = default;
@@ -55,6 +57,18 @@ class ControllerManagerImpl final : public ControllerManager {
       bool initial_fec_enabled,
       bool initial_dtx_enabled);
 
+  static std::unique_ptr<ControllerManager> Create(
+      const ProtoString& config_string,
+      size_t num_encoder_channels,
+      rtc::ArrayView<const int> encoder_frame_lengths_ms,
+      int min_encoder_bitrate_bps,
+      size_t intial_channels_to_encode,
+      int initial_frame_length_ms,
+      int initial_bitrate_bps,
+      bool initial_fec_enabled,
+      bool initial_dtx_enabled,
+      DebugDumpWriter* debug_dump_writer);
+
   explicit ControllerManagerImpl(const Config& config);
 
   // Dependency injection for testing.

webrtc/modules/audio_coding/audio_network_adaptor/controller_manager_unittest.cc

@@ -15,6 +15,7 @@
 #include "webrtc/base/protobuf_utils.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/controller_manager.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_controller.h"
+#include "webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_debug_dump_writer.h"
 #include "webrtc/test/gtest.h"
 
 #if WEBRTC_ENABLE_PROTOBUF
@@ -29,6 +30,7 @@ RTC_POP_IGNORING_WUNDEF()
 
 namespace webrtc {
 
+using ::testing::_;
 using ::testing::NiceMock;
 
 namespace {
@@ -332,8 +334,50 @@ void CheckControllersOrder(const std::vector<Controller*>& controllers,
   }
 }
 
+MATCHER_P(ControllerManagerEqual, value, "") {
+  ProtoString value_string;
+  ProtoString arg_string;
+  EXPECT_TRUE(arg.SerializeToString(&arg_string));
+  EXPECT_TRUE(value.SerializeToString(&value_string));
+  return arg_string == value_string;
+}
+
 }  // namespace
 
+TEST(ControllerManagerTest, DebugDumpLoggedWhenCreateFromConfigString) {
+  audio_network_adaptor::config::ControllerManager config;
+  config.set_min_reordering_time_ms(kMinReorderingTimeMs);
+  config.set_min_reordering_squared_distance(kMinReorderingSquareDistance);
+
+  AddFecControllerConfig(&config);
+  AddChannelControllerConfig(&config);
+  AddDtxControllerConfig(&config);
+  AddFrameLengthControllerConfig(&config);
+  AddBitrateControllerConfig(&config);
+
+  ProtoString config_string;
+  config.SerializeToString(&config_string);
+
+  constexpr size_t kNumEncoderChannels = 2;
+  const std::vector<int> encoder_frame_lengths_ms = {20, 60};
+
+  constexpr int64_t kClockInitialTimeMs = 12345678;
+  rtc::ScopedFakeClock fake_clock;
+  fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kClockInitialTimeMs));
+  auto debug_dump_writer =
+      std::unique_ptr<MockDebugDumpWriter>(new NiceMock<MockDebugDumpWriter>());
+  EXPECT_CALL(*debug_dump_writer, Die());
+  EXPECT_CALL(*debug_dump_writer,
+              DumpControllerManagerConfig(ControllerManagerEqual(config),
+                                          kClockInitialTimeMs));
+
+  ControllerManagerImpl::Create(config_string, kNumEncoderChannels,
+                                encoder_frame_lengths_ms, kMinBitrateBps,
+                                kIntialChannelsToEncode, kInitialFrameLengthMs,
+                                kInitialBitrateBps, kInitialFecEnabled,
+                                kInitialDtxEnabled, debug_dump_writer.get());
+}
+
 TEST(ControllerManagerTest, CreateFromConfigStringAndCheckDefaultOrder) {
   audio_network_adaptor::config::ControllerManager config;
   config.set_min_reordering_time_ms(kMinReorderingTimeMs);

webrtc/modules/audio_coding/audio_network_adaptor/debug_dump.proto

@@ -2,6 +2,8 @@ syntax = "proto2";
 option optimize_for = LITE_RUNTIME;
 package webrtc.audio_network_adaptor.debug_dump;
 
+import "config.proto";
+
 message NetworkMetrics {
   optional int32 uplink_bandwidth_bps = 1;
   optional float uplink_packet_loss_fraction = 2;
@@ -28,9 +30,13 @@ message Event {
   enum Type {
     NETWORK_METRICS = 0;
     ENCODER_RUNTIME_CONFIG = 1;
+    CONTROLLER_MANAGER_CONFIG = 2;
   }
   required Type type = 1;
   required uint32 timestamp = 2;
   optional NetworkMetrics network_metrics = 3;
   optional EncoderRuntimeConfig encoder_runtime_config = 4;
+  optional webrtc.audio_network_adaptor.config.ControllerManager
+      controller_manager_config = 5;
 }
+

webrtc/modules/audio_coding/audio_network_adaptor/debug_dump_writer.cc

@@ -56,6 +56,13 @@ class DebugDumpWriterImpl final : public DebugDumpWriter {
   void DumpNetworkMetrics(const Controller::NetworkMetrics& metrics,
                           int64_t timestamp) override;
 
+#if WEBRTC_ENABLE_PROTOBUF
+  void DumpControllerManagerConfig(
+      const audio_network_adaptor::config::ControllerManager&
+          controller_manager_config,
+      int64_t timestamp) override;
+#endif
+
  private:
   std::unique_ptr<FileWrapper> dump_file_;
 };
@@ -137,6 +144,20 @@ void DebugDumpWriterImpl::DumpEncoderRuntimeConfig(
 #endif  // WEBRTC_ENABLE_PROTOBUF
 }
 
+#if WEBRTC_ENABLE_PROTOBUF
+void DebugDumpWriterImpl::DumpControllerManagerConfig(
+    const audio_network_adaptor::config::ControllerManager&
+        controller_manager_config,
+    int64_t timestamp) {
+  Event event;
+  event.set_timestamp(timestamp);
+  event.set_type(Event::CONTROLLER_MANAGER_CONFIG);
+  event.mutable_controller_manager_config()->CopyFrom(
+      controller_manager_config);
+  DumpEventToFile(event, dump_file_.get());
+}
+#endif  // WEBRTC_ENABLE_PROTOBUF
+
 std::unique_ptr<DebugDumpWriter> DebugDumpWriter::Create(FILE* file_handle) {
   return std::unique_ptr<DebugDumpWriter>(new DebugDumpWriterImpl(file_handle));
 }

webrtc/modules/audio_coding/audio_network_adaptor/debug_dump_writer.h

@@ -14,9 +14,19 @@
 #include <memory>
 
 #include "webrtc/base/constructormagic.h"
+#include "webrtc/base/ignore_wundef.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/controller.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
 #include "webrtc/system_wrappers/include/file_wrapper.h"
+#if WEBRTC_ENABLE_PROTOBUF
+RTC_PUSH_IGNORING_WUNDEF()
+#ifdef WEBRTC_ANDROID_PLATFORM_BUILD
+#include "external/webrtc/webrtc/modules/audio_coding/audio_network_adaptor/config.pb.h"
+#else
+#include "webrtc/modules/audio_coding/audio_network_adaptor/config.pb.h"
+#endif
+RTC_POP_IGNORING_WUNDEF()
+#endif
 
 namespace webrtc {
 
@@ -31,6 +41,13 @@ class DebugDumpWriter {
 
   virtual void DumpNetworkMetrics(const Controller::NetworkMetrics& metrics,
                                   int64_t timestamp) = 0;
+
+#if WEBRTC_ENABLE_PROTOBUF
+  virtual void DumpControllerManagerConfig(
+      const audio_network_adaptor::config::ControllerManager&
+          controller_manager_config,
+      int64_t timestamp) = 0;
+#endif
 };
 
 }  // namespace webrtc

webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_debug_dump_writer.h

@@ -27,6 +27,12 @@ class MockDebugDumpWriter : public DebugDumpWriter {
   MOCK_METHOD2(DumpNetworkMetrics,
                void(const Controller::NetworkMetrics& metrics,
                     int64_t timestamp));
+#if WEBRTC_ENABLE_PROTOBUF
+  MOCK_METHOD2(DumpControllerManagerConfig,
+               void(const audio_network_adaptor::config::ControllerManager&
+                        controller_manager_config,
+                    int64_t timestamp));
+#endif
 };
 
 }  // namespace webrtc