Cosmetic change in ANA: renaming characteristic points for consistency.

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 188 matching lines @@
     size_t intial_channels_to_encode,
     int initial_frame_length_ms,
     int initial_bitrate_bps,
     bool initial_fec_enabled,
     bool initial_dtx_enabled) {
 #ifdef WEBRTC_AUDIO_NETWORK_ADAPTOR_DEBUG_DUMP
   audio_network_adaptor::config::ControllerManager controller_manager_config;
   controller_manager_config.ParseFromString(config_string);
 
   std::vector<std::unique_ptr<Controller>> controllers;
-  std::map<const Controller*, std::pair<int, float>> chracteristic_points;
+  std::map<const Controller*, std::pair<int, float>> scoring_points;
 
   for (int i = 0; i < controller_manager_config.controllers_size(); ++i) {
     auto& controller_config = controller_manager_config.controllers(i);
     std::unique_ptr<Controller> controller;
     switch (controller_config.controller_case()) {
       case audio_network_adaptor::config::Controller::kFecController:
         controller = CreateFecControllerPlrBased(
             controller_config.fec_controller(), initial_fec_enabled);
         break;
       case audio_network_adaptor::config::Controller::kFecControllerRplrBased:
@@ skipping 16 matching lines @@
                                          initial_dtx_enabled);
         break;
       case audio_network_adaptor::config::Controller::kBitrateController:
         controller = CreateBitrateController(initial_bitrate_bps,
                                              initial_frame_length_ms);
         break;
       default:
         RTC_NOTREACHED();
     }
     if (controller_config.has_scoring_point()) {
-      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());
+      auto& scoring_point = controller_config.scoring_point();
+      RTC_CHECK(scoring_point.has_uplink_bandwidth_bps());
+      RTC_CHECK(scoring_point.has_uplink_packet_loss_fraction());
+      scoring_points[controller.get()] = std::make_pair<int, float>(
+          scoring_point.uplink_bandwidth_bps(),
+          scoring_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));
+      std::move(controllers), scoring_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>>(),
           std::map<const Controller*, std::pair<int, float>>()) {}
 
 ControllerManagerImpl::ControllerManagerImpl(
     const Config& config,
     std::vector<std::unique_ptr<Controller>>&& controllers,
-    const std::map<const Controller*, std::pair<int, float>>&
-        chracteristic_points)
+    const std::map<const Controller*, std::pair<int, float>>& scoring_points)
     : config_(config),
       controllers_(std::move(controllers)),
       last_reordering_time_ms_(rtc::Optional<int64_t>()),
       last_scoring_point_(0, 0.0) {
   for (auto& controller : controllers_)
     default_sorted_controllers_.push_back(controller.get());
   sorted_controllers_ = default_sorted_controllers_;
-  for (auto& controller_point : chracteristic_points) {
+  for (auto& controller_point : scoring_points) {
     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 (!metrics.uplink_bandwidth_bps || !metrics.uplink_packet_loss_fraction)
     return sorted_controllers_;
 
   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)
     return sorted_controllers_;
 
   // Sort controllers according to the distances of |scoring_point| to the
-  // characteristic scoring points of controllers.
+  // scoring points of controllers.
   //
   // A controller that does not associate with any scoring point
   // are treated as if
   // 1) they are less important than any controller that has a scoring point,
   // 2) they are equally important to any controller that has no scoring point,
   //    and their relative order will follow |default_sorted_controllers_|.
   std::vector<Controller*> sorted_controllers(default_sorted_controllers_);
   std::stable_sort(
       sorted_controllers.begin(), sorted_controllers.end(),
       [this, &scoring_point](const Controller* lhs, const Controller* rhs) {
@@ skipping 55 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