Convert usage of ARRAY_SIZE to arraysize.

talk/media/webrtc/webrtcvideocapturer.cc

 /*
  * libjingle
  * Copyright 2011 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 16 matching lines @@
 
 #include "talk/media/webrtc/webrtcvideocapturer.h"
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 
 #ifdef HAVE_WEBRTC_VIDEO
 #include "talk/media/webrtc/webrtcvideoframe.h"
 #include "talk/media/webrtc/webrtcvideoframefactory.h"
+#include "webrtc/base/arraysize.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/safe_conversions.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/timeutils.h"
 
 #include "webrtc/base/win32.h"  // Need this to #include the impl files.
 #include "webrtc/modules/video_capture/include/video_capture_factory.h"
@@ skipping 29 matching lines @@
     return webrtc::VideoCaptureFactory::CreateDeviceInfo(id);
   }
   virtual void DestroyDeviceInfo(webrtc::VideoCaptureModule::DeviceInfo* info) {
     delete info;
   }
 };
 
 static bool CapabilityToFormat(const webrtc::VideoCaptureCapability& cap,
                                VideoFormat* format) {
   uint32_t fourcc = 0;
-  for (size_t i = 0; i < ARRAY_SIZE(kSupportedFourCCs); ++i) {
+  for (size_t i = 0; i < arraysize(kSupportedFourCCs); ++i) {
     if (kSupportedFourCCs[i].webrtc_type == cap.rawType) {
       fourcc = kSupportedFourCCs[i].fourcc;
       break;
     }
   }
   if (fourcc == 0) {
     return false;
   }
 
   format->fourcc = fourcc;
   format->width = cap.width;
   format->height = cap.height;
   format->interval = VideoFormat::FpsToInterval(cap.maxFPS);
   return true;
 }
 
 static bool FormatToCapability(const VideoFormat& format,
                                webrtc::VideoCaptureCapability* cap) {
   webrtc::RawVideoType webrtc_type = webrtc::kVideoUnknown;
-  for (size_t i = 0; i < ARRAY_SIZE(kSupportedFourCCs); ++i) {
+  for (size_t i = 0; i < arraysize(kSupportedFourCCs); ++i) {
     if (kSupportedFourCCs[i].fourcc == format.fourcc) {
       webrtc_type = kSupportedFourCCs[i].webrtc_type;
       break;
     }
   }
   if (webrtc_type == webrtc::kVideoUnknown) {
     return false;
   }
 
   cap->width = format.width;
@@ skipping 47 matching lines @@
   }
 
   // Find the desired camera, by name.
   // In the future, comparing IDs will be more robust.
   // TODO(juberti): Figure what's needed to allow this.
   int num_cams = info->NumberOfDevices();
   char vcm_id[256] = "";
   bool found = false;
   for (int index = 0; index < num_cams; ++index) {
     char vcm_name[256];
-    if (info->GetDeviceName(index, vcm_name, ARRAY_SIZE(vcm_name),
-                            vcm_id, ARRAY_SIZE(vcm_id)) != -1) {
+    if (info->GetDeviceName(index, vcm_name, arraysize(vcm_name), vcm_id,
+                            arraysize(vcm_id)) != -1) {
       if (device.name == reinterpret_cast<char*>(vcm_name)) {
         found = true;
         break;
       }
     }
   }
   if (!found) {
     LOG(LS_WARNING) << "Failed to find capturer for id: " << device.id;
     factory_->DestroyDeviceInfo(info);
     return false;
@@ skipping 168 matching lines @@
 bool WebRtcVideoCapturer::IsRunning() {
   return (module_ != NULL && module_->CaptureStarted());
 }
 
 bool WebRtcVideoCapturer::GetPreferredFourccs(std::vector<uint32_t>* fourccs) {
   if (!fourccs) {
     return false;
   }
 
   fourccs->clear();
-  for (size_t i = 0; i < ARRAY_SIZE(kSupportedFourCCs); ++i) {
+  for (size_t i = 0; i < arraysize(kSupportedFourCCs); ++i) {
     fourccs->push_back(kSupportedFourCCs[i].fourcc);
   }
   return true;
 }
 
 void WebRtcVideoCapturer::OnIncomingCapturedFrame(
     const int32_t id,
     const webrtc::VideoFrame& sample) {
   // This can only happen between Start() and Stop().
   RTC_DCHECK(start_thread_);
@@ skipping 62 matching lines @@
   // Convert units from VideoFrame RenderTimeMs to CapturedFrame (nanoseconds).
   time_stamp = sample.render_time_ms() * rtc::kNumNanosecsPerMillisec;
   data_size = rtc::checked_cast<uint32_t>(length);
   data = buffer;
   rotation = sample.rotation();
 }
 
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VIDEO