Add RTC_ prefix to contructormagic macros.

webrtc/modules/video_coding/main/test/rtp_player.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 48 matching lines @@
   uint32_t ssrc() const { return ssrc_; }
   uint16_t seq_num() const { return seq_num_; }
 
  private:
   rtc::scoped_ptr<uint8_t[]> data_;
   size_t length_;
   int64_t resend_time_ms_;
   uint32_t ssrc_;
   uint16_t seq_num_;
 
-  DISALLOW_IMPLICIT_CONSTRUCTORS(RawRtpPacket);
+  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RawRtpPacket);
 };
 
 class LostPackets {
  public:
   LostPackets(Clock* clock, int64_t rtt_ms)
       : crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
         debug_file_(fopen("PacketLossDebug.txt", "w")),
         loss_count_(0),
         packets_(),
         clock_(clock),
@@ skipping 95 matching lines @@
   typedef RtpPacketList::iterator RtpPacketIterator;
   typedef RtpPacketList::const_iterator ConstRtpPacketIterator;
 
   rtc::scoped_ptr<CriticalSectionWrapper> crit_sect_;
   FILE* debug_file_;
   int loss_count_;
   RtpPacketList packets_;
   Clock* clock_;
   int64_t rtt_ms_;
 
-  DISALLOW_IMPLICIT_CONSTRUCTORS(LostPackets);
+  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(LostPackets);
 };
 
 class SsrcHandlers {
  public:
   SsrcHandlers(PayloadSinkFactoryInterface* payload_sink_factory,
                const PayloadTypes& payload_types)
       : payload_sink_factory_(payload_sink_factory),
         payload_types_(payload_types),
         handlers_() {
     assert(payload_sink_factory);
@@ skipping 102 matching lines @@
     rtc::scoped_ptr<RtpHeaderParser> rtp_header_parser_;
     rtc::scoped_ptr<RTPPayloadRegistry> rtp_payload_registry_;
     rtc::scoped_ptr<RtpReceiver> rtp_module_;
     rtc::scoped_ptr<PayloadSinkInterface> payload_sink_;
 
    private:
     uint32_t ssrc_;
     const PayloadTypes& payload_types_;
     LostPackets* lost_packets_;
 
-    DISALLOW_COPY_AND_ASSIGN(Handler);
+    RTC_DISALLOW_COPY_AND_ASSIGN(Handler);
   };
 
   typedef std::map<uint32_t, Handler*> HandlerMap;
   typedef std::map<uint32_t, Handler*>::iterator HandlerMapIt;
 
   PayloadSinkFactoryInterface* payload_sink_factory_;
   PayloadTypes payload_types_;
   HandlerMap handlers_;
 
-  DISALLOW_IMPLICIT_CONSTRUCTORS(SsrcHandlers);
+  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(SsrcHandlers);
 };
 
 class RtpPlayerImpl : public RtpPlayerInterface {
  public:
   RtpPlayerImpl(PayloadSinkFactoryInterface* payload_sink_factory,
                 const PayloadTypes& payload_types,
                 Clock* clock,
                 rtc::scoped_ptr<test::RtpFileReader>* packet_source,
                 float loss_rate,
                 int64_t rtt_ms,
@@ skipping 131 matching lines @@
   int64_t first_packet_rtp_time_;
   int64_t first_packet_time_ms_;
   float loss_rate_;
   LostPackets lost_packets_;
   uint32_t resend_packet_count_;
   uint32_t no_loss_startup_;
   bool end_of_file_;
   bool reordering_;
   rtc::scoped_ptr<RawRtpPacket> reorder_buffer_;
 
-  DISALLOW_IMPLICIT_CONSTRUCTORS(RtpPlayerImpl);
+  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RtpPlayerImpl);
 };
 
 RtpPlayerInterface* Create(const std::string& input_filename,
     PayloadSinkFactoryInterface* payload_sink_factory, Clock* clock,
     const PayloadTypes& payload_types, float loss_rate, int64_t rtt_ms,
     bool reordering) {
   rtc::scoped_ptr<test::RtpFileReader> packet_source(
       test::RtpFileReader::Create(test::RtpFileReader::kRtpDump,
                                   input_filename));
   if (packet_source.get() == NULL) {
     packet_source.reset(test::RtpFileReader::Create(test::RtpFileReader::kPcap,
                                                     input_filename));
     if (packet_source.get() == NULL) {
       return NULL;
     }
   }
 
   rtc::scoped_ptr<RtpPlayerImpl> impl(
       new RtpPlayerImpl(payload_sink_factory, payload_types, clock,
                         &packet_source, loss_rate, rtt_ms, reordering));
   return impl.release();
 }
 }  // namespace rtpplayer
 }  // namespace webrtc