Avoiding check on reordering configs in ANA if there is no controller has scoring point.

webrtc/modules/audio_coding/audio_network_adaptor/controller_manager.cc

 /*
  *  Copyright (c) 2016 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.
  */
 
@@ skipping 235 matching lines @@
       auto& characteristic_point = controller_config.scoring_point();
       RTC_CHECK(characteristic_point.has_uplink_bandwidth_bps());
       RTC_CHECK(characteristic_point.has_uplink_packet_loss_fraction());
       chracteristic_points[controller.get()] = std::make_pair<int, float>(
           characteristic_point.uplink_bandwidth_bps(),
           characteristic_point.uplink_packet_loss_fraction());
     }
     controllers.push_back(std::move(controller));
   }
 
-  RTC_CHECK(controller_manager_config.has_min_reordering_time_ms());
-  RTC_CHECK(controller_manager_config.has_min_reordering_squared_distance());
-  return std::unique_ptr<ControllerManagerImpl>(new ControllerManagerImpl(
-      ControllerManagerImpl::Config(
-          controller_manager_config.min_reordering_time_ms(),
-          controller_manager_config.min_reordering_squared_distance()),
-      std::move(controllers), chracteristic_points));
+  if (chracteristic_points.size() == 0) {

[tschumi, 2017/05/30 14:03:24]

Do you think its worth the extra complexity ?

+    return std::unique_ptr<ControllerManagerImpl>(new ControllerManagerImpl(
+        ControllerManagerImpl::Config(0, 0), std::move(controllers),
+        chracteristic_points));
+  } else {
+    RTC_CHECK(controller_manager_config.has_min_reordering_time_ms());
+    RTC_CHECK(controller_manager_config.has_min_reordering_squared_distance());
+    return std::unique_ptr<ControllerManagerImpl>(new ControllerManagerImpl(
+        ControllerManagerImpl::Config(
+            controller_manager_config.min_reordering_time_ms(),
+            controller_manager_config.min_reordering_squared_distance()),
+        std::move(controllers), chracteristic_points));
+  }
 #else
   RTC_NOTREACHED();
   return nullptr;
 #endif  // WEBRTC_AUDIO_NETWORK_ADAPTOR_DEBUG_DUMP
 }
 
 ControllerManagerImpl::ControllerManagerImpl(const Config& config)
     : ControllerManagerImpl(
           config,
           std::vector<std::unique_ptr<Controller>>(),
@@ skipping 15 matching lines @@
     controller_scoring_points_.insert(std::make_pair(
         controller_point.first, ScoringPoint(controller_point.second.first,
                                              controller_point.second.second)));
   }
 }
 
 ControllerManagerImpl::~ControllerManagerImpl() = default;
 
 std::vector<Controller*> ControllerManagerImpl::GetSortedControllers(
     const Controller::NetworkMetrics& metrics) {
-  int64_t now_ms = rtc::TimeMillis();
+  if (controller_scoring_points_.size() == 0)
+    return default_sorted_controllers_;
 
   if (!metrics.uplink_bandwidth_bps || !metrics.uplink_packet_loss_fraction)
     return sorted_controllers_;
 
+  const int64_t now_ms = rtc::TimeMillis();
   if (last_reordering_time_ms_ &&
       now_ms - *last_reordering_time_ms_ < config_.min_reordering_time_ms)
     return sorted_controllers_;
 
   ScoringPoint scoring_point(*metrics.uplink_bandwidth_bps,
                              *metrics.uplink_packet_loss_fraction);
 
   if (last_reordering_time_ms_ &&
       last_scoring_point_.SquaredDistanceTo(scoring_point) <
           config_.min_reordering_squared_distance)
@@ skipping 69 matching lines @@
       NormalizeUplinkBandwidth(scoring_point.uplink_bandwidth_bps) -
       NormalizeUplinkBandwidth(uplink_bandwidth_bps);
   float diff_normalized_packet_loss =
       NormalizePacketLossFraction(scoring_point.uplink_packet_loss_fraction) -
       NormalizePacketLossFraction(uplink_packet_loss_fraction);
   return std::pow(diff_normalized_bitrate_bps, 2) +
          std::pow(diff_normalized_packet_loss, 2);
 }
 
 }  // namespace webrtc