Move FunctionView from AudioCodingModule to the rtc namespace

webrtc/modules/audio_coding/acm2/audio_coding_module.cc

 /*
  *  Copyright (c) 2012 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 27 matching lines @@
   /////////////////////////////////////////
   //   Sender
   //
 
   // Can be called multiple times for Codec, CNG, RED.
   int RegisterSendCodec(const CodecInst& send_codec) override;
 
   void RegisterExternalSendCodec(
       AudioEncoder* external_speech_encoder) override;
 
-  void ModifyEncoder(
-      FunctionView<void(std::unique_ptr<AudioEncoder>*)> modifier) override;
+  void ModifyEncoder(rtc::FunctionView<void(std::unique_ptr<AudioEncoder>*)>
+                         modifier) override;
 
-  void QueryEncoder(FunctionView<void(const AudioEncoder*)> query) override;
+  void QueryEncoder(
+      rtc::FunctionView<void(const AudioEncoder*)> query) override;
 
   // Get current send codec.
   rtc::Optional<CodecInst> SendCodec() const override;
 
   // Get current send frequency.
   int SendFrequency() const override;
 
   // Sets the bitrate to the specified value in bits/sec. In case the codec does
   // not support the requested value it will choose an appropriate value
   // instead.
@@ skipping 54 matching lines @@
 
   // Get current receive frequency.
   int ReceiveFrequency() const override;
 
   // Get current playout frequency.
   int PlayoutFrequency() const override;
 
   int RegisterReceiveCodec(const CodecInst& receive_codec) override;
   int RegisterReceiveCodec(
       const CodecInst& receive_codec,
-      FunctionView<std::unique_ptr<AudioDecoder>()> isac_factory) override;
+      rtc::FunctionView<std::unique_ptr<AudioDecoder>()> isac_factory) override;
 
   int RegisterExternalReceiveCodec(int rtp_payload_type,
                                    AudioDecoder* external_decoder,
                                    int sample_rate_hz,
                                    int num_channels,
                                    const std::string& name) override;
 
   // Get current received codec.
   int ReceiveCodec(CodecInst* current_codec) const override;
 
@@ skipping 79 matching lines @@
     void MaybeLog(int value);
 
    private:
     int last_value_ = 0;
     int first_time_ = true;
     const std::string histogram_name_;
   };
 
   int RegisterReceiveCodecUnlocked(
       const CodecInst& codec,
-      FunctionView<std::unique_ptr<AudioDecoder>()> isac_factory)
+      rtc::FunctionView<std::unique_ptr<AudioDecoder>()> isac_factory)
       EXCLUSIVE_LOCKS_REQUIRED(acm_crit_sect_);
 
   int Add10MsDataInternal(const AudioFrame& audio_frame, InputData* input_data)
       EXCLUSIVE_LOCKS_REQUIRED(acm_crit_sect_);
   int Encode(const InputData& input_data)
       EXCLUSIVE_LOCKS_REQUIRED(acm_crit_sect_);
 
   int InitializeReceiverSafe() EXCLUSIVE_LOCKS_REQUIRED(acm_crit_sect_);
 
   bool HaveValidEncoder(const char* caller_name) const
@@ skipping 343 matching lines @@
   rtc::CritScope lock(&acm_crit_sect_);
   encoder_factory_->codec_manager.UnsetCodecInst();
   encoder_factory_->external_speech_encoder = external_speech_encoder;
   RTC_CHECK(CreateSpeechEncoderIfNecessary(encoder_factory_.get()));
   auto* sp = encoder_factory_->codec_manager.GetStackParams();
   RTC_CHECK(sp->speech_encoder);
   encoder_stack_ = encoder_factory_->rent_a_codec.RentEncoderStack(sp);
 }
 
 void AudioCodingModuleImpl::ModifyEncoder(
-    FunctionView<void(std::unique_ptr<AudioEncoder>*)> modifier) {
+    rtc::FunctionView<void(std::unique_ptr<AudioEncoder>*)> modifier) {
   rtc::CritScope lock(&acm_crit_sect_);
 
   // Wipe the encoder factory, so that everything that relies on it will fail.
   // We don't want the complexity of supporting swapping back and forth.
   if (encoder_factory_) {
     encoder_factory_.reset();
     RTC_CHECK(!encoder_stack_);  // Ensure we hadn't started using the factory.
   }
 
   modifier(&encoder_stack_);
 }
 
 void AudioCodingModuleImpl::QueryEncoder(
-    FunctionView<void(const AudioEncoder*)> query) {
+    rtc::FunctionView<void(const AudioEncoder*)> query) {
   rtc::CritScope lock(&acm_crit_sect_);
   query(encoder_stack_.get());
 }
 
 // Get current send codec.
 rtc::Optional<CodecInst> AudioCodingModuleImpl::SendCodec() const {
   rtc::CritScope lock(&acm_crit_sect_);
   if (encoder_factory_) {
     auto* ci = encoder_factory_->codec_manager.GetCodecInst();
     if (ci) {
@@ skipping 373 matching lines @@
 
 int AudioCodingModuleImpl::RegisterReceiveCodec(const CodecInst& codec) {
   rtc::CritScope lock(&acm_crit_sect_);
   auto* ef = encoder_factory_.get();
   return RegisterReceiveCodecUnlocked(
       codec, [&] { return ef->rent_a_codec.RentIsacDecoder(codec.plfreq); });
 }
 
 int AudioCodingModuleImpl::RegisterReceiveCodec(
     const CodecInst& codec,
-    FunctionView<std::unique_ptr<AudioDecoder>()> isac_factory) {
+    rtc::FunctionView<std::unique_ptr<AudioDecoder>()> isac_factory) {
   rtc::CritScope lock(&acm_crit_sect_);
   return RegisterReceiveCodecUnlocked(codec, isac_factory);
 }
 
 int AudioCodingModuleImpl::RegisterReceiveCodecUnlocked(
     const CodecInst& codec,
-    FunctionView<std::unique_ptr<AudioDecoder>()> isac_factory) {
+    rtc::FunctionView<std::unique_ptr<AudioDecoder>()> isac_factory) {
   RTC_DCHECK(receiver_initialized_);
   if (codec.channels > 2) {
     LOG_F(LS_ERROR) << "Unsupported number of channels: " << codec.channels;
     return -1;
   }
 
   auto codec_id = acm2::RentACodec::CodecIdByParams(codec.plname, codec.plfreq,
                                                     codec.channels);
   if (!codec_id) {
     LOG_F(LS_ERROR) << "Wrong codec params to be registered as receive codec";
@@ skipping 339 matching lines @@
 // Checks the validity of the parameters of the given codec
 bool AudioCodingModule::IsCodecValid(const CodecInst& codec) {
   bool valid = acm2::RentACodec::IsCodecValid(codec);
   if (!valid)
     WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, -1,
                  "Invalid codec setting");
   return valid;
 }
 
 }  // namespace webrtc