Update thread annotiation macros in modules to use RTC_ prefix

webrtc/modules/video_coding/codecs/test/videoprocessor.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 235 matching lines @@
     rtc::TaskQueue* const task_queue_;
   };
 
   // Invoked by the callback adapter when a frame has completed encoding.
   void FrameEncoded(webrtc::VideoCodecType codec,
                     const webrtc::EncodedImage& encodedImage);
 
   // Invoked by the callback adapter when a frame has completed decoding.
   void FrameDecoded(const webrtc::VideoFrame& image);
 
-  bool initialized_ GUARDED_BY(sequence_checker_);
-  TestConfig config_ GUARDED_BY(sequence_checker_);
+  bool initialized_ RTC_GUARDED_BY(sequence_checker_);
+  TestConfig config_ RTC_GUARDED_BY(sequence_checker_);
 
   webrtc::VideoEncoder* const encoder_;
   webrtc::VideoDecoder* const decoder_;
   const std::unique_ptr<VideoBitrateAllocator> bitrate_allocator_;
 
   // Adapters for the codec callbacks.
   VideoProcessorEncodeCompleteCallback encode_callback_;
   VideoProcessorDecodeCompleteCallback decode_callback_;
 
   // Fake network.
   PacketManipulator* const packet_manipulator_;
 
   // These (mandatory) file manipulators are used for, e.g., objective PSNR and
   // SSIM calculations at the end of a test run.
   FrameReader* const analysis_frame_reader_;
   FrameWriter* const analysis_frame_writer_;
 
   // These (optional) file writers are used to persistently store the encoded
   // and decoded bitstreams. The purpose is to give the experimenter an option
   // to subjectively evaluate the quality of the processing. Each frame writer
   // is enabled by being non-null.
   IvfFileWriter* const encoded_frame_writer_;
   FrameWriter* const decoded_frame_writer_;
 
   // Keep track of inputed/encoded/decoded frames, so we can detect frame drops.
-  int last_inputed_frame_num_ GUARDED_BY(sequence_checker_);
-  int last_encoded_frame_num_ GUARDED_BY(sequence_checker_);
-  int last_decoded_frame_num_ GUARDED_BY(sequence_checker_);
+  int last_inputed_frame_num_ RTC_GUARDED_BY(sequence_checker_);
+  int last_encoded_frame_num_ RTC_GUARDED_BY(sequence_checker_);
+  int last_decoded_frame_num_ RTC_GUARDED_BY(sequence_checker_);
 
   // Store an RTP timestamp -> frame number map, since the timestamps are
   // based off of the frame rate, which can change mid-test.
   std::map<uint32_t, int> rtp_timestamp_to_frame_num_
-      GUARDED_BY(sequence_checker_);
+      RTC_GUARDED_BY(sequence_checker_);
 
   // Keep track of if we have excluded the first key frame from packet loss.
-  bool first_key_frame_has_been_excluded_ GUARDED_BY(sequence_checker_);
+  bool first_key_frame_has_been_excluded_ RTC_GUARDED_BY(sequence_checker_);
 
   // Keep track of the last successfully decoded frame, since we write that
   // frame to disk when decoding fails.
-  rtc::Buffer last_decoded_frame_buffer_ GUARDED_BY(sequence_checker_);
+  rtc::Buffer last_decoded_frame_buffer_ RTC_GUARDED_BY(sequence_checker_);
 
   // Statistics.
   Stats* stats_;
-  std::vector<int> num_dropped_frames_ GUARDED_BY(sequence_checker_);
-  std::vector<int> num_spatial_resizes_ GUARDED_BY(sequence_checker_);
-  int rate_update_index_ GUARDED_BY(sequence_checker_);
+  std::vector<int> num_dropped_frames_ RTC_GUARDED_BY(sequence_checker_);
+  std::vector<int> num_spatial_resizes_ RTC_GUARDED_BY(sequence_checker_);
+  int rate_update_index_ RTC_GUARDED_BY(sequence_checker_);
 
   rtc::SequencedTaskChecker sequence_checker_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(VideoProcessor);
 };
 
 }  // namespace test
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_VIDEOPROCESSOR_H_