Replace Atomic32 with webrtc/base/atomicops.h.

webrtc/test/channel_transport/udp_socket2_win.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.
  */
 
 #include "webrtc/test/channel_transport/udp_socket2_win.h"
 
 #include <assert.h>
 #include <stdlib.h>
 #include <winsock2.h>
 
+#include "webrtc/base/atomicops.h"
 #include "webrtc/base/format_macros.h"
 #include "webrtc/system_wrappers/interface/sleep.h"
 #include "webrtc/test/channel_transport/traffic_control_win.h"
 #include "webrtc/test/channel_transport/udp_socket2_manager_win.h"
 
 #pragma warning(disable : 4311)
 
 namespace webrtc {
 namespace test {
 
@@ skipping 249 matching lines @@
 
 bool UdpSocket2Windows::StartReceiving(uint32_t receiveBuffers)
 {
     WEBRTC_TRACE(kTraceDebug, kTraceTransport, _id,
                  "UdpSocket2Windows(%d)::StartReceiving(%d)", (int32_t)this,
                  receiveBuffers);
 
     _wantsIncoming = true;
 
     int32_t numberOfReceiveBuffersToCreate =
-        receiveBuffers - _receiveBuffers.Value();
+        receiveBuffers - rtc::AtomicOps::AcquireLoad(&_receiveBuffers);
     numberOfReceiveBuffersToCreate = (numberOfReceiveBuffersToCreate < 0) ?
         0 : numberOfReceiveBuffersToCreate;
 
     int32_t error = 0;
     for(int32_t i = 0;
         i < numberOfReceiveBuffersToCreate;
         i++)
     {
         if(PostRecv())
         {
             WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
                          "UdpSocket2Windows::StartReceiving() i=%d", i);
             error = -1;
             break;
         }
-        ++_receiveBuffers;
+        rtc::AtomicOps::Increment(&_receiveBuffers);
     }
     if(error == -1)
     {
         return false;
     }
 
     WEBRTC_TRACE(kTraceDebug, kTraceTransport, _id,
                  "Socket receiving using:%d number of buffers",
-                 _receiveBuffers.Value());
+                 rtc::AtomicOps::AcquireLoad(&_receiveBuffers));
     return true;
 }
 
 bool UdpSocket2Windows::StopReceiving()
 {
     WEBRTC_TRACE(kTraceDebug, kTraceTransport, _id,
                  "UdpSocket2Windows::StopReceiving()");
     _wantsIncoming = false;
     return true;
 }
@@ skipping 144 matching lines @@
                     pIOContext ? (int32_t)pIOContext->ioOperation : -1);
             } else {
                 WEBRTC_TRACE(
                     kTraceDebug,
                     kTraceTransport,
                     _id,
                     "UdpSocket2Windows::IOCompleted() Operation aborted");
             }
             if(pIOContext)
             {
-                int32_t remainingReceiveBuffers = --_receiveBuffers;
+              int32_t remainingReceiveBuffers =
+                  rtc::AtomicOps::Decrement(&_receiveBuffers);
                 if(remainingReceiveBuffers < 0)
                 {
                     assert(false);
                 }
                 int32_t err = _mgr->PushIoContext(pIOContext);
                 if(err)
                 {
                     WEBRTC_TRACE(
                         kTraceError,
                         kTraceTransport,
@@ skipping 134 matching lines @@
             postingSucessfull = true;
             break;
         }
     }
     ReleaseSocket();
 
     if(postingSucessfull)
     {
         return 0;
     }
-    int32_t remainingReceiveBuffers = --_receiveBuffers;
+    int32_t remainingReceiveBuffers =
+        rtc::AtomicOps::Decrement(&_receiveBuffers);
     if(remainingReceiveBuffers < 0)
     {
         assert(false);
     }
     int32_t error = _mgr->PushIoContext(pIoContext);
     if(error)
     {
         WEBRTC_TRACE(
             kTraceError,
             kTraceTransport,
@@ skipping 609 matching lines @@
     f->Latency            = QOS_NOT_SPECIFIED;
     f->MaxSduSize         = QOS_NOT_SPECIFIED;
     f->MinimumPolicedSize = QOS_NOT_SPECIFIED;
     return 0;
 }
 
 bool UdpSocket2Windows::NewOutstandingCall()
 {
     assert(!_outstandingCallsDisabled);
 
-    ++_outstandingCalls;
+    rtc::AtomicOps::Increment(&_outstandingCalls);
     return true;
 }
 
 void UdpSocket2Windows::OutstandingCallCompleted()
 {
     _ptrDestRWLock->AcquireLockShared();
-    ++_outstandingCallComplete;
-    if((--_outstandingCalls == 0) && _outstandingCallsDisabled)
-    {
+    rtc::AtomicOps::Increment(&_outstandingCallComplete);
+    if ((rtc::AtomicOps::Decrement(&_outstandingCalls) == 0) &&
+        _outstandingCallsDisabled) {
         // When there are no outstanding calls and new outstanding calls are
         // disabled it is time to terminate.
         _terminate = true;
     }
     _ptrDestRWLock->ReleaseLockShared();
 
-    if((--_outstandingCallComplete == 0) &&
-        (_terminate))
-    {
+    if ((rtc::AtomicOps::Decrement(&_outstandingCallComplete) == 0) &&
+        (_terminate)) {
         // Only one thread will enter here. The thread with the last outstanding
         // call.
         CriticalSectionScoped cs(_ptrDeleteCrit);
         _safeTodelete = true;
         _ptrDeleteCond->Wake();
     }
 }
 
 void UdpSocket2Windows::DisableNewOutstandingCalls()
 {
     _ptrDestRWLock->AcquireLockExclusive();
     if(_outstandingCallsDisabled)
     {
         // Outstandning calls are already disabled.
         _ptrDestRWLock->ReleaseLockExclusive();
         return;
     }
     _outstandingCallsDisabled = true;
-    const bool noOutstandingCalls = (_outstandingCalls.Value() == 0);
+    const bool noOutstandingCalls =
+        (rtc::AtomicOps::AcquireLoad(&_outstandingCalls) == 0);
     _ptrDestRWLock->ReleaseLockExclusive();
 
     RemoveSocketFromManager();
 
     if(noOutstandingCalls)
     {
         CriticalSectionScoped cs(_ptrDeleteCrit);
         _safeTodelete = true;
         _ptrDeleteCond->Wake();
     }
@@ skipping 56 matching lines @@
                      "UdpSocket2Windows(%d)::InvalidateSocket() WSAerror: %d",
                      (int32_t)this, WSAGetLastError());
     }
     _socket = INVALID_SOCKET;
     _ptrSocketRWLock->ReleaseLockExclusive();
     return true;
 }
 
 }  // namespace test
 }  // namespace webrtc