Add RTC_ prefix to contructormagic macros.

webrtc/modules/audio_coding/neteq/audio_decoder_impl.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.
  */
 
@@ skipping 28 matching lines @@
   size_t Channels() const override;
 
  protected:
   int DecodeInternal(const uint8_t* encoded,
                      size_t encoded_len,
                      int sample_rate_hz,
                      int16_t* decoded,
                      SpeechType* speech_type) override;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(AudioDecoderPcmU);
+  RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoderPcmU);
 };
 
 class AudioDecoderPcmA : public AudioDecoder {
  public:
   AudioDecoderPcmA() {}
   void Reset() override;
   int PacketDuration(const uint8_t* encoded, size_t encoded_len) const override;
   size_t Channels() const override;
 
  protected:
   int DecodeInternal(const uint8_t* encoded,
                      size_t encoded_len,
                      int sample_rate_hz,
                      int16_t* decoded,
                      SpeechType* speech_type) override;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(AudioDecoderPcmA);
+  RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoderPcmA);
 };
 
 class AudioDecoderPcmUMultiCh : public AudioDecoderPcmU {
  public:
   explicit AudioDecoderPcmUMultiCh(size_t channels)
       : AudioDecoderPcmU(), channels_(channels) {
     assert(channels > 0);
   }
   size_t Channels() const override;
 
  private:
   const size_t channels_;
-  DISALLOW_COPY_AND_ASSIGN(AudioDecoderPcmUMultiCh);
+  RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoderPcmUMultiCh);
 };
 
 class AudioDecoderPcmAMultiCh : public AudioDecoderPcmA {
  public:
   explicit AudioDecoderPcmAMultiCh(size_t channels)
       : AudioDecoderPcmA(), channels_(channels) {
     assert(channels > 0);
   }
   size_t Channels() const override;
 
  private:
   const size_t channels_;
-  DISALLOW_COPY_AND_ASSIGN(AudioDecoderPcmAMultiCh);
+  RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoderPcmAMultiCh);
 };
 
 #ifdef WEBRTC_CODEC_PCM16
 // This class handles all four types (i.e., sample rates) of PCM16B codecs.
 // The type is specified in the constructor parameter |type|.
 class AudioDecoderPcm16B : public AudioDecoder {
  public:
   AudioDecoderPcm16B();
   void Reset() override;
   int PacketDuration(const uint8_t* encoded, size_t encoded_len) const override;
   size_t Channels() const override;
 
  protected:
   int DecodeInternal(const uint8_t* encoded,
                      size_t encoded_len,
                      int sample_rate_hz,
                      int16_t* decoded,
                      SpeechType* speech_type) override;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(AudioDecoderPcm16B);
+  RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoderPcm16B);
 };
 
 // This class handles all four types (i.e., sample rates) of PCM16B codecs.
 // The type is specified in the constructor parameter |type|, and the number
 // of channels is derived from the type.
 class AudioDecoderPcm16BMultiCh : public AudioDecoderPcm16B {
  public:
   explicit AudioDecoderPcm16BMultiCh(size_t num_channels);
   size_t Channels() const override;
 
  private:
   const size_t channels_;
-  DISALLOW_COPY_AND_ASSIGN(AudioDecoderPcm16BMultiCh);
+  RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoderPcm16BMultiCh);
 };
 #endif
 
 #ifdef WEBRTC_CODEC_ILBC
 class AudioDecoderIlbc : public AudioDecoder {
  public:
   AudioDecoderIlbc();
   ~AudioDecoderIlbc() override;
   bool HasDecodePlc() const override;
   size_t DecodePlc(size_t num_frames, int16_t* decoded) override;
   void Reset() override;
   size_t Channels() const override;
 
  protected:
   int DecodeInternal(const uint8_t* encoded,
                      size_t encoded_len,
                      int sample_rate_hz,
                      int16_t* decoded,
                      SpeechType* speech_type) override;
 
  private:
   IlbcDecoderInstance* dec_state_;
-  DISALLOW_COPY_AND_ASSIGN(AudioDecoderIlbc);
+  RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoderIlbc);
 };
 #endif
 
 #ifdef WEBRTC_CODEC_G722
 class AudioDecoderG722 : public AudioDecoder {
  public:
   AudioDecoderG722();
   ~AudioDecoderG722() override;
   bool HasDecodePlc() const override;
   void Reset() override;
   int PacketDuration(const uint8_t* encoded, size_t encoded_len) const override;
   size_t Channels() const override;
 
  protected:
   int DecodeInternal(const uint8_t* encoded,
                      size_t encoded_len,
                      int sample_rate_hz,
                      int16_t* decoded,
                      SpeechType* speech_type) override;
 
  private:
   G722DecInst* dec_state_;
-  DISALLOW_COPY_AND_ASSIGN(AudioDecoderG722);
+  RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoderG722);
 };
 
 class AudioDecoderG722Stereo : public AudioDecoder {
  public:
   AudioDecoderG722Stereo();
   ~AudioDecoderG722Stereo() override;
   void Reset() override;
 
  protected:
   int DecodeInternal(const uint8_t* encoded,
                      size_t encoded_len,
                      int sample_rate_hz,
                      int16_t* decoded,
                      SpeechType* speech_type) override;
   size_t Channels() const override;
 
  private:
   // Splits the stereo-interleaved payload in |encoded| into separate payloads
   // for left and right channels. The separated payloads are written to
   // |encoded_deinterleaved|, which must hold at least |encoded_len| samples.
   // The left channel starts at offset 0, while the right channel starts at
   // offset encoded_len / 2 into |encoded_deinterleaved|.
   void SplitStereoPacket(const uint8_t* encoded, size_t encoded_len,
                          uint8_t* encoded_deinterleaved);
 
   G722DecInst* dec_state_left_;
   G722DecInst* dec_state_right_;
 
-  DISALLOW_COPY_AND_ASSIGN(AudioDecoderG722Stereo);
+  RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoderG722Stereo);
 };
 #endif
 
 // AudioDecoderCng is a special type of AudioDecoder. It inherits from
 // AudioDecoder just to fit in the DecoderDatabase. None of the class methods
 // should be used, except constructor, destructor, and accessors.
 // TODO(hlundin): Consider the possibility to create a super-class to
 // AudioDecoder that is stored in DecoderDatabase. Then AudioDecoder and a
 // specific CngDecoder class could both inherit from that class.
 class AudioDecoderCng : public AudioDecoder {
@@ skipping 12 matching lines @@
 
  protected:
   int DecodeInternal(const uint8_t* encoded,
                      size_t encoded_len,
                      int sample_rate_hz,
                      int16_t* decoded,
                      SpeechType* speech_type) override;
 
  private:
   CNG_dec_inst* dec_state_;
-  DISALLOW_COPY_AND_ASSIGN(AudioDecoderCng);
+  RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoderCng);
 };
 
 enum NetEqDecoder {
   kDecoderPCMu,
   kDecoderPCMa,
   kDecoderPCMu_2ch,
   kDecoderPCMa_2ch,
   kDecoderILBC,
   kDecoderISAC,
   kDecoderISACswb,
@@ skipping 26 matching lines @@
 // Returns the sample rate for |codec_type|.
 int CodecSampleRateHz(NetEqDecoder codec_type);
 
 // Creates an AudioDecoder object of type |codec_type|. Returns NULL for for
 // unsupported codecs, and when creating an AudioDecoder is not applicable
 // (e.g., for RED and DTMF/AVT types).
 AudioDecoder* CreateAudioDecoder(NetEqDecoder codec_type);
 
 }  // namespace webrtc
 #endif  // WEBRTC_MODULES_AUDIO_CODING_NETEQ_AUDIO_DECODER_IMPL_H_