Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/api/videocapturertracksource.cc

 /*
  *  Copyright 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/api/videocapturertracksource.h"
 
 #include <cstdlib>
 #include <string>
 #include <vector>
 
 #include "webrtc/api/mediaconstraintsinterface.h"
 #include "webrtc/base/arraysize.h"
+#include "webrtc/base/checks.h"
 
 using cricket::CaptureState;
 using webrtc::MediaConstraintsInterface;
 using webrtc::MediaSourceInterface;
 
 namespace {
 
 const double kRoundingTruncation = 0.0005;
 
 // Default resolution. If no constraint is specified, this is the resolution we
@@ skipping 14 matching lines @@
 MediaSourceInterface::SourceState GetReadyState(cricket::CaptureState state) {
   switch (state) {
     case cricket::CS_STARTING:
       return MediaSourceInterface::kInitializing;
     case cricket::CS_RUNNING:
       return MediaSourceInterface::kLive;
     case cricket::CS_FAILED:
     case cricket::CS_STOPPED:
       return MediaSourceInterface::kEnded;
     default:
-      ASSERT(false && "GetReadyState unknown state");
+      RTC_DCHECK(false && "GetReadyState unknown state");

[kwiberg-webrtc, 2017/01/12 02:10:41]

RTC_NOTREACHED?

   }
   return MediaSourceInterface::kEnded;
 }
 
 void SetUpperLimit(int new_limit, int* original_limit) {
   if (*original_limit < 0 || new_limit < *original_limit)
     *original_limit = new_limit;
 }
 
 // Updates |format_upper_limit| from |constraint|.
@@ skipping 30 matching lines @@
 }
 
 // Returns true if |constraint| is fulfilled. |format_out| can differ from
 // |format_in| if the format is changed by the constraint. Ie - the frame rate
 // can be changed by setting maxFrameRate.
 bool NewFormatWithConstraints(
     const MediaConstraintsInterface::Constraint& constraint,
     const cricket::VideoFormat& format_in,
     bool mandatory,
     cricket::VideoFormat* format_out) {
-  ASSERT(format_out != NULL);
+  RTC_DCHECK(format_out != NULL);
   *format_out = format_in;
 
   if (constraint.key == MediaConstraintsInterface::kMinWidth) {
     int value = rtc::FromString<int>(constraint.value);
     return (value <= format_in.width);
   } else if (constraint.key == MediaConstraintsInterface::kMaxWidth) {
     int value = rtc::FromString<int>(constraint.value);
     return (value >= format_in.width);
   } else if (constraint.key == MediaConstraintsInterface::kMinHeight) {
     int value = rtc::FromString<int>(constraint.value);
@@ skipping 93 matching lines @@
   return candidates;
 }
 
 // Find the format that best matches the default video size.
 // Constraints are optional and since the performance of a video call
 // might be bad due to bitrate limitations, CPU, and camera performance,
 // it is better to select a resolution that is as close as possible to our
 // default and still meets the contraints.
 const cricket::VideoFormat& GetBestCaptureFormat(
     const std::vector<cricket::VideoFormat>& formats) {
-  ASSERT(formats.size() > 0);
+  RTC_DCHECK(formats.size() > 0);
 
   int default_area = kDefaultFormat.width * kDefaultFormat.height;
 
   std::vector<cricket::VideoFormat>::const_iterator it = formats.begin();
   std::vector<cricket::VideoFormat>::const_iterator best_it = formats.begin();
   int best_diff_area = std::abs(default_area - it->width * it->height);
   int64_t best_diff_interval = kDefaultFormat.interval;
   for (; it != formats.end(); ++it) {
     int diff_area = std::abs(default_area - it->width * it->height);
     int64_t diff_interval = std::abs(kDefaultFormat.interval - it->interval);
@@ skipping 158 matching lines @@
                   capture_state));
     return;
   }
 
   if (capturer == video_capturer_.get()) {
     SetState(GetReadyState(capture_state));
   }
 }
 
 }  // namespace webrtc