Move FunctionView from AudioCodingModule to the rtc namespace

webrtc/modules/audio_coding/include/audio_coding_module.h

 /*
  *  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.
  */
 
 #ifndef WEBRTC_MODULES_AUDIO_CODING_INCLUDE_AUDIO_CODING_MODULE_H_
 #define WEBRTC_MODULES_AUDIO_CODING_INCLUDE_AUDIO_CODING_MODULE_H_
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "webrtc/base/deprecation.h"
+#include "webrtc/base/function_view.h"
 #include "webrtc/base/optional.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/audio_coding/codecs/audio_decoder_factory.h"
 #include "webrtc/modules/audio_coding/include/audio_coding_module_typedefs.h"
 #include "webrtc/modules/audio_coding/neteq/include/neteq.h"
 #include "webrtc/modules/include/module.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
@@ skipping 173 matching lines @@
   //   -1 if failed to initialize,
   //    0 if succeeded.
   //
   virtual int32_t RegisterSendCodec(const CodecInst& send_codec) = 0;
 
   // Registers |external_speech_encoder| as encoder. The new encoder will
   // replace any previously registered speech encoder (internal or external).
   virtual void RegisterExternalSendCodec(
       AudioEncoder* external_speech_encoder) = 0;
 
-  // Just like std::function, FunctionView will wrap any callable and hide its
-  // actual type, exposing only its signature. But unlike std::function,
-  // FunctionView doesn't own its callable---it just points to it. Thus, it's a
-  // good choice mainly as a function argument when the callable argument will
-  // not be called again once the function has returned.
-  template <typename T>
-  class FunctionView;  // Undefined.
-
-  template <typename RetT, typename... ArgT>
-  class FunctionView<RetT(ArgT...)> final {
-   public:
-    // This constructor is implicit, so that callers won't have to convert
-    // lambdas to FunctionView<Blah(Blah, Blah)> explicitly. This is safe
-    // because FunctionView is only a reference to the real callable.
-    template <typename F>
-    FunctionView(F&& f)
-        : f_(&f), call_(Call<typename std::remove_reference<F>::type>) {}
-
-    RetT operator()(ArgT... args) const {
-      return call_(f_, std::forward<ArgT>(args)...);
-    }
-
-   private:
-    template <typename F>
-    static RetT Call(void* f, ArgT... args) {
-      return (*static_cast<F*>(f))(std::forward<ArgT>(args)...);
-    }
-    void* f_;
-    RetT (*call_)(void* f, ArgT... args);
-  };
-
   // |modifier| is called exactly once with one argument: a pointer to the
   // unique_ptr that holds the current encoder (which is null if there is no
   // current encoder). For the duration of the call, |modifier| has exclusive
   // access to the unique_ptr; it may call the encoder, steal the encoder and
   // replace it with another encoder or with nullptr, etc.
   virtual void ModifyEncoder(
-      FunctionView<void(std::unique_ptr<AudioEncoder>*)> modifier) = 0;
+      rtc::FunctionView<void(std::unique_ptr<AudioEncoder>*)> modifier) = 0;
 
   // |modifier| is called exactly once with one argument: a const pointer to the
   // current encoder (which is null if there is no current encoder).
-  virtual void QueryEncoder(FunctionView<void(AudioEncoder const*)> query) = 0;
+  virtual void QueryEncoder(
+      rtc::FunctionView<void(AudioEncoder const*)> query) = 0;
 
   // Utility method for simply replacing the existing encoder with a new one.
   void SetEncoder(std::unique_ptr<AudioEncoder> new_encoder) {
     ModifyEncoder([&](std::unique_ptr<AudioEncoder>* encoder) {
       *encoder = std::move(new_encoder);
     });
   }
 
   ///////////////////////////////////////////////////////////////////////////
   // int32_t SendCodec()
@@ skipping 258 matching lines @@
   //   -1 if failed to register the codec
   //    0 if the codec registered successfully.
   //
   virtual int RegisterReceiveCodec(const CodecInst& receive_codec) = 0;
 
   // Register a decoder; call repeatedly to register multiple decoders. |df| is
   // a decoder factory that returns an iSAC decoder; it will be called once if
   // the decoder being registered is iSAC.
   virtual int RegisterReceiveCodec(
       const CodecInst& receive_codec,
-      FunctionView<std::unique_ptr<AudioDecoder>()> isac_factory) = 0;
+      rtc::FunctionView<std::unique_ptr<AudioDecoder>()> isac_factory) = 0;
 
   // Registers an external decoder. The name is only used to provide information
   // back to the caller about the decoder. Hence, the name is arbitrary, and may
   // be empty.
   virtual int RegisterExternalReceiveCodec(int rtp_payload_type,
                                            AudioDecoder* external_decoder,
                                            int sample_rate_hz,
                                            int num_channels,
                                            const std::string& name) = 0;
 
@@ skipping 280 matching lines @@
   virtual std::vector<uint16_t> GetNackList(
       int64_t round_trip_time_ms) const = 0;
 
   virtual void GetDecodingCallStatistics(
       AudioDecodingCallStats* call_stats) const = 0;
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_AUDIO_CODING_INCLUDE_AUDIO_CODING_MODULE_H_