Update thread annotiation macros to use RTC_ prefix

webrtc/video/video_stream_encoder_unittest.cc

 /*
  *  Copyright (c) 2016 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 71 matching lines @@
     OveruseFrameDetector::OnTargetFramerateUpdated(framerate_fps);
   }
 
   int GetLastTargetFramerate() {
     rtc::CritScope cs(&lock_);
     return last_target_framerate_fps_;
   }
 
  private:
   rtc::CriticalSection lock_;
-  int last_target_framerate_fps_ GUARDED_BY(lock_);
+  int last_target_framerate_fps_ RTC_GUARDED_BY(lock_);
 };
 
 class VideoStreamEncoderUnderTest : public VideoStreamEncoder {
  public:
   VideoStreamEncoderUnderTest(SendStatisticsProxy* stats_proxy,
                       const VideoSendStream::Config::EncoderSettings& settings)
       : VideoStreamEncoder(
             1 /* number_of_cores */,
             stats_proxy,
             settings,
@@ skipping 108 matching lines @@
   void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
                        const rtc::VideoSinkWants& wants) override {
     rtc::CritScope cs(&crit_);
     last_wants_ = sink_wants();
     adapter_.OnResolutionFramerateRequest(wants.target_pixel_count,
                                           wants.max_pixel_count,
                                           wants.max_framerate_fps);
     test::FrameForwarder::AddOrUpdateSink(sink, wants);
   }
   cricket::VideoAdapter adapter_;
-  bool adaptation_enabled_ GUARDED_BY(crit_);
-  rtc::VideoSinkWants last_wants_ GUARDED_BY(crit_);
+  bool adaptation_enabled_ RTC_GUARDED_BY(crit_);
+  rtc::VideoSinkWants last_wants_ RTC_GUARDED_BY(crit_);
 };
 
 class MockableSendStatisticsProxy : public SendStatisticsProxy {
  public:
   MockableSendStatisticsProxy(Clock* clock,
                               const VideoSendStream::Config& config,
                               VideoEncoderConfig::ContentType content_type)
       : SendStatisticsProxy(clock, config, content_type) {}
 
   VideoSendStream::Stats GetStats() override {
     rtc::CritScope cs(&lock_);
     if (mock_stats_)
       return *mock_stats_;
     return SendStatisticsProxy::GetStats();
   }
 
   void SetMockStats(const VideoSendStream::Stats& stats) {
     rtc::CritScope cs(&lock_);
     mock_stats_.emplace(stats);
   }
 
   void ResetMockStats() {
     rtc::CritScope cs(&lock_);
     mock_stats_.reset();
   }
 
  private:
   rtc::CriticalSection lock_;
-  rtc::Optional<VideoSendStream::Stats> mock_stats_ GUARDED_BY(lock_);
+  rtc::Optional<VideoSendStream::Stats> mock_stats_ RTC_GUARDED_BY(lock_);
 };
 
 class MockBitrateObserver : public VideoBitrateAllocationObserver {
  public:
   MOCK_METHOD1(OnBitrateAllocationUpdated, void(const BitrateAllocation&));
 };
 
 }  // namespace
 
 class VideoStreamEncoderTest : public ::testing::Test {
@@ skipping 282 matching lines @@
           allocated_temporal_layers_.emplace_back(
               config->VP8().tl_factory->Create(i, num_temporal_layers, 42));
         }
       }
       if (force_init_encode_failed_)
         return -1;
       return res;
     }
 
     rtc::CriticalSection local_crit_sect_;
-    bool block_next_encode_ GUARDED_BY(local_crit_sect_) = false;
+    bool block_next_encode_ RTC_GUARDED_BY(local_crit_sect_) = false;
     rtc::Event continue_encode_event_;
-    uint32_t timestamp_ GUARDED_BY(local_crit_sect_) = 0;
-    int64_t ntp_time_ms_ GUARDED_BY(local_crit_sect_) = 0;
-    int last_input_width_ GUARDED_BY(local_crit_sect_) = 0;
-    int last_input_height_ GUARDED_BY(local_crit_sect_) = 0;
-    bool quality_scaling_ GUARDED_BY(local_crit_sect_) = true;
+    uint32_t timestamp_ RTC_GUARDED_BY(local_crit_sect_) = 0;
+    int64_t ntp_time_ms_ RTC_GUARDED_BY(local_crit_sect_) = 0;
+    int last_input_width_ RTC_GUARDED_BY(local_crit_sect_) = 0;
+    int last_input_height_ RTC_GUARDED_BY(local_crit_sect_) = 0;
+    bool quality_scaling_ RTC_GUARDED_BY(local_crit_sect_) = true;
     std::vector<std::unique_ptr<TemporalLayers>> allocated_temporal_layers_
-        GUARDED_BY(local_crit_sect_);
-    bool force_init_encode_failed_ GUARDED_BY(local_crit_sect_) = false;
+        RTC_GUARDED_BY(local_crit_sect_);
+    bool force_init_encode_failed_ RTC_GUARDED_BY(local_crit_sect_) = false;
   };
 
   class TestSink : public VideoStreamEncoder::EncoderSink {
    public:
     explicit TestSink(TestEncoder* test_encoder)
         : test_encoder_(test_encoder), encoded_frame_event_(false, false) {}
 
     void WaitForEncodedFrame(int64_t expected_ntp_time) {
       EXPECT_TRUE(
           TimedWaitForEncodedFrame(expected_ntp_time, kDefaultTimeoutMs));
@@ skipping 2697 matching lines @@
   // Bitrate observer should not be called.
   EXPECT_CALL(bitrate_observer, OnBitrateAllocationUpdated(_)).Times(0);
   video_source_.IncomingCapturedFrame(
       CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight));
   ExpectDroppedFrame();
 
   video_stream_encoder_->Stop();
 }
 
 }  // namespace webrtc