Simplifying audio network adaptor by moving receiver frame length range to ctor.

webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h

 /*
  *  Copyright (c) 2014 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 31 matching lines @@
 
     int frame_size_ms = 20;
     size_t num_channels = 1;
     int payload_type = 120;
     ApplicationMode application = kVoip;
     rtc::Optional<int> bitrate_bps;  // Unset means to use default value.
     bool fec_enabled = false;
     int max_playback_rate_hz = 48000;
     int complexity = kDefaultComplexity;
     bool dtx_enabled = false;
+    std::vector<int> supported_frame_lengths_ms;
     const Clock* clock = nullptr;
 
    private:
 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS) || defined(WEBRTC_ARCH_ARM)
     // If we are on Android, iOS and/or ARM, use a lower complexity setting as
     // default, to save encoder complexity.
     static const int kDefaultComplexity = 5;
 #else
     static const int kDefaultComplexity = 9;
 #endif
@@ skipping 33 matching lines @@
   bool EnableAudioNetworkAdaptor(const std::string& config_string,
                                  const Clock* clock) override;
   void DisableAudioNetworkAdaptor() override;
   void OnReceivedUplinkBandwidth(int uplink_bandwidth_bps) override;
   void OnReceivedUplinkPacketLossFraction(
       float uplink_packet_loss_fraction) override;
   void OnReceivedTargetAudioBitrate(int target_audio_bitrate_bps) override;
   void OnReceivedRtt(int rtt_ms) override;
   void SetReceiverFrameLengthRange(int min_frame_length_ms,
                                    int max_frame_length_ms) override;
+  const std::vector<int>& supported_frame_lengths_ms() const {

[kwiberg-webrtc, 2016/10/19 09:12:01]

Again, I wonder if the return type here shouldn't be rtc::ArrayView<const int>.

[minyue-webrtc, 2016/10/19 09:25:54]

if config_.supported_frame_lengths_ms is a vector, it is any benefit of
returning rtc::ArrayView<const int>

[kwiberg-webrtc, 2016/10/19 10:43:33]

No, but there are also no disadvantages. And the API then makes it possible for
you to change how you store the supported frame lengths.

Basically, everywhere where you pass an array of contiguous elements as a
function argument or return value, and the recipient is only allowed to access
the elements and not do anything to the length or ownership of the array,
rtc::ArrayView is just as good as std::vector&, rtc::Buffer&, etc., but places
fewer restrictions on how that memory is managed.

[minyue-webrtc, 2016/10/21 08:26:29]

ok, yes, changed to rtc::ArrayView. Thanks for the explanation, This will also
help in my future CLs.

+    return config_.supported_frame_lengths_ms;
+  }
 
   // Getters for testing.
   double packet_loss_rate() const { return packet_loss_rate_; }
   ApplicationMode application() const { return config_.application; }
   bool fec_enabled() const { return config_.fec_enabled; }
   size_t num_channels_to_encode() const { return num_channels_to_encode_; }
   int next_frame_length_ms() const { return next_frame_length_ms_; }
 
  protected:
   EncodedInfo EncodeImpl(uint32_t rtp_timestamp,
@@ skipping 24 matching lines @@
   std::unique_ptr<PacketLossFractionSmoother> packet_loss_fraction_smoother_;
   AudioNetworkAdaptorCreator audio_network_adaptor_creator_;
   std::unique_ptr<AudioNetworkAdaptor> audio_network_adaptor_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(AudioEncoderOpus);
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_AUDIO_CODING_CODECS_OPUS_AUDIO_ENCODER_OPUS_H_