Replace Atomic32 with webrtc/base/atomicops.h.

webrtc/video/video_send_stream_tests.cc

 /*
  *  Copyright (c) 2013 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.
  */
 #include <algorithm>  // max
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
+#include "webrtc/base/atomicops.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/call.h"
 #include "webrtc/call/transport_adapter.h"
 #include "webrtc/frame_callback.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_sender.h"
@@ skipping 551 matching lines @@
         } else {
           // Increase next expected frame size. If testing with FEC, make sure
           // a FEC packet has been received for this frame size before
           // proceeding, to make sure that redundancy packets don't exceed
           // size limit.
           if (!use_fec_) {
             ++current_size_rtp_;
           } else if (fec_packet_received_) {
             fec_packet_received_ = false;
             ++current_size_rtp_;
-            ++current_size_frame_;
+            rtc::AtomicOps::Increment(&current_size_frame_);
           }
         }
       }
 
       return SEND_PACKET;
     }
 
     void TriggerLossReport(const RTPHeader& header) {
       // Send lossy receive reports to trigger FEC enabling.
       if (packet_count_++ % 2 != 0) {
@@ skipping 10 matching lines @@
         RTCPSender::FeedbackState feedback_state;
 
         EXPECT_EQ(0, rtcp_sender.SendRTCP(feedback_state, kRtcpRr));
       }
     }
 
     virtual void EncodedFrameCallback(const EncodedFrame& encoded_frame) {
       // Increase frame size for next encoded frame, in the context of the
       // encoder thread.
       if (!use_fec_ &&
-          current_size_frame_.Value() < static_cast<int32_t>(stop_size_)) {
-        ++current_size_frame_;
+          rtc::AtomicOps::AcquireLoad(&current_size_frame_) <
+              static_cast<int32_t>(stop_size_)) {
+        rtc::AtomicOps::Increment(&current_size_frame_);
       }
-      encoder_.SetFrameSize(static_cast<size_t>(current_size_frame_.Value()));
+      encoder_.SetFrameSize(static_cast<size_t>(
+          rtc::AtomicOps::AcquireLoad(&current_size_frame_)));
     }
 
     Call::Config GetSenderCallConfig() override {
       Call::Config config;
       const int kMinBitrateBps = 30000;
       config.bitrate_config.min_bitrate_bps = kMinBitrateBps;
       return config;
     }
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
@@ skipping 28 matching lines @@
     const size_t stop_size_;
     const bool test_generic_packetization_;
     const bool use_fec_;
 
     uint32_t packet_count_;
     size_t accumulated_size_;
     size_t accumulated_payload_;
     bool fec_packet_received_;
 
     size_t current_size_rtp_;
-    Atomic32 current_size_frame_;
+    volatile int current_size_frame_;
   };
 
   // Don't auto increment if FEC is used; continue sending frame size until
   // a FEC packet has been received.
   FrameFragmentationTest test(
       kMaxPacketSize, start, stop, format == kGeneric, with_fec);
 
   RunBaseTest(&test);
 }
 
@@ skipping 1218 matching lines @@
       EXPECT_TRUE(vp9videoHeader->flexible_mode);
       observation_complete_->Set();
     }
 
   } test;
 
   RunBaseTest(&test);
 }
 
 }  // namespace webrtc