Add RTC_ prefix to contructormagic macros.

webrtc/base/stream.h

 /*
  *  Copyright 2004 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 210 matching lines @@
   // readline object or adapter
   StreamResult ReadLine(std::string* line);
 
  protected:
   StreamInterface();
 
   // MessageHandler Interface
   void OnMessage(Message* msg) override;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(StreamInterface);
+  RTC_DISALLOW_COPY_AND_ASSIGN(StreamInterface);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // StreamAdapterInterface is a convenient base-class for adapting a stream.
 // By default, all operations are pass-through.  Override the methods that you
 // require adaptation.  Streams should really be upgraded to reference-counted.
 // In the meantime, use the owned flag to indicate whether the adapter should
 // own the adapted stream.
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 56 matching lines @@
   ~StreamAdapterInterface() override;
 
   // Note that the adapter presents itself as the origin of the stream events,
   // since users of the adapter may not recognize the adapted object.
   virtual void OnEvent(StreamInterface* stream, int events, int err);
   StreamInterface* stream() { return stream_; }
 
  private:
   StreamInterface* stream_;
   bool owned_;
-  DISALLOW_COPY_AND_ASSIGN(StreamAdapterInterface);
+  RTC_DISALLOW_COPY_AND_ASSIGN(StreamAdapterInterface);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // StreamTap is a non-modifying, pass-through adapter, which copies all data
 // in either direction to the tap.  Note that errors or blocking on writing to
 // the tap will prevent further tap writes from occurring.
 ///////////////////////////////////////////////////////////////////////////////
 
 class StreamTap : public StreamAdapterInterface {
  public:
@@ skipping 11 matching lines @@
                     int* error) override;
   StreamResult Write(const void* data,
                      size_t data_len,
                      size_t* written,
                      int* error) override;
 
  private:
   scoped_ptr<StreamInterface> tap_;
   StreamResult tap_result_;
   int tap_error_;
-  DISALLOW_COPY_AND_ASSIGN(StreamTap);
+  RTC_DISALLOW_COPY_AND_ASSIGN(StreamTap);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // NullStream gives errors on read, and silently discards all written data.
 ///////////////////////////////////////////////////////////////////////////////
 
 class NullStream : public StreamInterface {
  public:
   NullStream();
   ~NullStream() override;
@@ skipping 57 matching lines @@
 
   // Note: Deprecated in favor of Filesystem::GetFileSize().
   static bool GetSize(const std::string& filename, size_t* size);
 
  protected:
   virtual void DoClose();
 
   FILE* file_;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(FileStream);
+  RTC_DISALLOW_COPY_AND_ASSIGN(FileStream);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // MemoryStream is a simple implementation of a StreamInterface over in-memory
 // data.  Data is read and written at the current seek position.  Reads return
 // end-of-stream when they reach the end of data.  Writes actually extend the
 // end of data mark.
 ///////////////////////////////////////////////////////////////////////////////
 
 class MemoryStreamBase : public StreamInterface {
@@ skipping 22 matching lines @@
 
   virtual StreamResult DoReserve(size_t size, int* error);
 
   // Invariant: 0 <= seek_position <= data_length_ <= buffer_length_
   char* buffer_;
   size_t buffer_length_;
   size_t data_length_;
   size_t seek_position_;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(MemoryStreamBase);
+  RTC_DISALLOW_COPY_AND_ASSIGN(MemoryStreamBase);
 };
 
 // MemoryStream dynamically resizes to accomodate written data.
 
 class MemoryStream : public MemoryStreamBase {
  public:
   MemoryStream();
   explicit MemoryStream(const char* data);  // Calls SetData(data, strlen(data))
   MemoryStream(const void* data, size_t length);  // Calls SetData(data, length)
   ~MemoryStream() override;
@@ skipping 77 matching lines @@
   StreamResult WriteOffsetLocked(const void* buffer, size_t bytes,
                                  size_t offset, size_t* bytes_written);
 
   StreamState state_;  // keeps the opened/closed state of the stream
   scoped_ptr<char[]> buffer_;  // the allocated buffer
   size_t buffer_length_;  // size of the allocated buffer
   size_t data_length_;  // amount of readable data in the buffer
   size_t read_position_;  // offset to the readable data
   Thread* owner_;  // stream callbacks are dispatched on this thread
   mutable CriticalSection crit_;  // object lock
-  DISALLOW_COPY_AND_ASSIGN(FifoBuffer);
+  RTC_DISALLOW_COPY_AND_ASSIGN(FifoBuffer);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class LoggingAdapter : public StreamAdapterInterface {
  public:
   LoggingAdapter(StreamInterface* stream, LoggingSeverity level,
                  const std::string& label, bool hex_mode = false);
 
   void set_label(const std::string& label);
@@ skipping 10 matching lines @@
 
  protected:
   void OnEvent(StreamInterface* stream, int events, int err) override;
 
  private:
   LoggingSeverity level_;
   std::string label_;
   bool hex_mode_;
   LogMultilineState lms_;
 
-  DISALLOW_COPY_AND_ASSIGN(LoggingAdapter);
+  RTC_DISALLOW_COPY_AND_ASSIGN(LoggingAdapter);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // StringStream - Reads/Writes to an external std::string
 ///////////////////////////////////////////////////////////////////////////////
 
 class StringStream : public StreamInterface {
  public:
   explicit StringStream(std::string* str);
   explicit StringStream(const std::string& str);
@@ skipping 62 matching lines @@
       }
       if (ref_count == 0) {
         delete stream_;
         delete this;
       }
     }
    private:
     StreamInterface* stream_;
     int ref_count_;
     CriticalSection cs_;
-    DISALLOW_COPY_AND_ASSIGN(StreamRefCount);
+    RTC_DISALLOW_COPY_AND_ASSIGN(StreamRefCount);
   };
 
   // Constructor for adding references
   explicit StreamReference(StreamRefCount* stream_ref_count,
                            StreamInterface* stream);
 
   StreamRefCount* stream_ref_count_;
-  DISALLOW_COPY_AND_ASSIGN(StreamReference);
+  RTC_DISALLOW_COPY_AND_ASSIGN(StreamReference);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // Flow attempts to move bytes from source to sink via buffer of size
 // buffer_len.  The function returns SR_SUCCESS when source reaches
 // end-of-stream (returns SR_EOS), and all the data has been written successful
 // to sink.  Alternately, if source returns SR_BLOCK or SR_ERROR, or if sink
 // returns SR_BLOCK, SR_ERROR, or SR_EOS, then the function immediately returns
 // with the unexpected StreamResult value.
 // data_len is the length of the valid data in buffer. in case of error
 // this is the data that read from source but can't move to destination.
 // as a pass in parameter, it indicates data in buffer that should move to sink
 StreamResult Flow(StreamInterface* source,
                   char* buffer, size_t buffer_len,
                   StreamInterface* sink, size_t* data_len = NULL);
 
 ///////////////////////////////////////////////////////////////////////////////
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_STREAM_H_