Replace Atomic32 with webrtc/base/atomicops.h.

webrtc/test/channel_transport/udp_socket2_manager_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_manager_win.h"
 
 #include <assert.h>
 #include <stdio.h>
 
+#include "webrtc/base/atomicops.h"
 #include "webrtc/system_wrappers/interface/aligned_malloc.h"
 #include "webrtc/test/channel_transport/udp_socket2_win.h"
 
 namespace webrtc {
 namespace test {
 
 uint32_t UdpSocket2ManagerWindows::_numOfActiveManagers = 0;
 bool UdpSocket2ManagerWindows::_wsaInit = false;
 
 UdpSocket2ManagerWindows::UdpSocket2ManagerWindows()
@@ skipping 385 matching lines @@
     : _pListHead(NULL),
       _init(false),
       _size(0),
       _inUse(0)
 {
 }
 
 IoContextPool::~IoContextPool()
 {
     Free();
-    assert(_size.Value() == 0);
+    assert(rtc::AtomicOps::AcquireLoad(&_size) == 0);
     AlignedFree(_pListHead);
 }
 
 int32_t IoContextPool::Init(uint32_t /*increaseSize*/)
 {
     if(_init)
     {
         return 0;
     }
 
@@ skipping 22 matching lines @@
             AlignedMalloc(
                 sizeof(IoContextPoolItem),
                 MEMORY_ALLOCATION_ALIGNMENT);
         if(item == NULL)
         {
             return NULL;
         }
         memset(&item->payload.ioContext,0,sizeof(PerIoContext));
         item->payload.base = item;
         pListEntry = &(item->itemEntry);
-        ++_size;
+        rtc::AtomicOps::Increment(&_size);
     }
-    ++_inUse;
+    rtc::AtomicOps::Increment(&_inUse);
     return &((IoContextPoolItem*)pListEntry)->payload.ioContext;
 }
 
 int32_t IoContextPool::PushIoContext(PerIoContext* pIoContext)
 {
     // TODO (hellner): Overlapped IO should be completed at this point. Perhaps
     //                 add an assert?
     const bool overlappedIOCompleted = HasOverlappedIoCompleted(
         (LPOVERLAPPED)pIoContext);
 
     IoContextPoolItem* item = ((IoContextPoolItemPayload*)pIoContext)->base;
 
-    const int32_t usedItems = --_inUse;
-    const int32_t totalItems = _size.Value();
+    const int32_t usedItems = rtc::AtomicOps::Decrement(&_inUse);
+    const int32_t totalItems = rtc::AtomicOps::AcquireLoad(&_size);
     const int32_t freeItems = totalItems - usedItems;
     if(freeItems < 0)
     {
         assert(false);
         AlignedFree(item);
         return -1;
     }
     if((freeItems >= totalItems>>1) &&
         overlappedIOCompleted)
     {
         AlignedFree(item);
-        --_size;
+        rtc::AtomicOps::Decrement(&_size);
         return 0;
     }
     InterlockedPushEntrySList(_pListHead, &(item->itemEntry));
     return 0;
 }
 
 int32_t IoContextPool::Free()
 {
     if(!_init)
     {
         return 0;
     }
 
     int32_t itemsFreed = 0;
     PSLIST_ENTRY pListEntry = InterlockedPopEntrySList(_pListHead);
     while(pListEntry != NULL)
     {
         IoContextPoolItem* item = ((IoContextPoolItem*)pListEntry);
         AlignedFree(item);
-        --_size;
+        rtc::AtomicOps::Decrement(&_size);
         itemsFreed++;
         pListEntry = InterlockedPopEntrySList(_pListHead);
     }
     return itemsFreed;
 }
 
 int32_t UdpSocket2WorkerWindows::_numOfWorkers = 0;
 
 UdpSocket2WorkerWindows::UdpSocket2WorkerWindows(HANDLE ioCompletionHandle)
     : _ioCompletionHandle(ioCompletionHandle),
@@ skipping 81 matching lines @@
             _workerNumber);
         return true;
     }
     pIOContext = (PerIoContext*)pOverlapped;
     pSocket->IOCompleted(pIOContext,ioSize,error);
     return true;
 }
 
 }  // namespace test
 }  // namespace webrtc