Convert usage of ARRAY_SIZE to arraysize.

webrtc/base/physicalsocketserver.cc

 /*
  *  Copyright 2004 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 21 matching lines @@
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #include <winsock2.h>
 #include <ws2tcpip.h>
 #undef SetPort
 #endif
 
 #include <algorithm>
 #include <map>
 
+#include "webrtc/base/arraysize.h"
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/byteorder.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/nethelpers.h"
 #include "webrtc/base/physicalsocketserver.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/base/winping.h"
 #include "webrtc/base/win32socketinit.h"
 
@@ skipping 569 matching lines @@
   // There is just a single global instance. (Signal handlers do not get any
   // sort of user-defined void * parameter, so they can't access anything that
   // isn't global.)
   static PosixSignalHandler* Instance() {
     RTC_DEFINE_STATIC_LOCAL(PosixSignalHandler, instance, ());
     return &instance;
   }
 
   // Returns true if the given signal number is set.
   bool IsSignalSet(int signum) const {
-    ASSERT(signum < ARRAY_SIZE(received_signal_));
-    if (signum < ARRAY_SIZE(received_signal_)) {
+    ASSERT(signum < static_cast<int>(arraysize(received_signal_)));
+    if (signum < static_cast<int>(arraysize(received_signal_))) {
       return received_signal_[signum];
     } else {
       return false;
     }
   }
 
   // Clears the given signal number.
   void ClearSignal(int signum) {
-    ASSERT(signum < ARRAY_SIZE(received_signal_));
-    if (signum < ARRAY_SIZE(received_signal_)) {
+    ASSERT(signum < static_cast<int>(arraysize(received_signal_)));
+    if (signum < static_cast<int>(arraysize(received_signal_))) {
       received_signal_[signum] = false;
     }
   }
 
   // Returns the file descriptor to monitor for signal events.
   int GetDescriptor() const {
     return afd_[0];
   }
 
   // This is called directly from our real signal handler, so it must be
   // signal-handler-safe. That means it cannot assume anything about the
   // user-level state of the process, since the handler could be executed at any
   // time on any thread.
   void OnPosixSignalReceived(int signum) {
-    if (signum >= ARRAY_SIZE(received_signal_)) {
+    if (signum >= static_cast<int>(arraysize(received_signal_))) {
       // We don't have space in our array for this.
       return;
     }
     // Set a flag saying we've seen this signal.
     received_signal_[signum] = true;
     // Notify application code that we got a signal.
     const uint8_t b[1] = {0};
     if (-1 == write(afd_[1], b, sizeof(b))) {
       // Nothing we can do here. If there's an error somehow then there's
       // nothing we can safely do from a signal handler.
@@ skipping 959 matching lines @@
        break;
     }
   }
 
   // Done
   return true;
 }
 #endif  // WEBRTC_WIN 
 
 }  // namespace rtc