Delete unused VideoCapturer statistics.

webrtc/media/base/videocapturer.cc

 /*
  *  Copyright (c) 2010 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 14 matching lines @@
 namespace cricket {
 
 namespace {
 
 static const int64_t kMaxDistance = ~(static_cast<int64_t>(1) << 63);
 #ifdef WEBRTC_LINUX
 static const int kYU12Penalty = 16;  // Needs to be higher than MJPG index.
 #endif
 static const int kDefaultScreencastFps = 5;
 
-// Limit stats data collections to ~20 seconds of 30fps data before dropping
-// old data in case stats aren't reset for long periods of time.
-static const size_t kMaxAccumulatorSize = 600;
-
 }  // namespace
 
 /////////////////////////////////////////////////////////////////////
 // Implementation of struct CapturedFrame
 /////////////////////////////////////////////////////////////////////
 CapturedFrame::CapturedFrame()
     : width(0),
       height(0),
       fourcc(0),
       pixel_width(0),
       pixel_height(0),
       time_stamp(0),
       data_size(0),
       rotation(webrtc::kVideoRotation_0),
       data(NULL) {}
 
 // TODO(fbarchard): Remove this function once lmimediaengine stops using it.
 bool CapturedFrame::GetDataSize(uint32_t* size) const {
   if (!size || data_size == CapturedFrame::kUnknownDataSize) {
     return false;
   }
   *size = data_size;
   return true;
 }
 
 /////////////////////////////////////////////////////////////////////
 // Implementation of class VideoCapturer
 /////////////////////////////////////////////////////////////////////
-VideoCapturer::VideoCapturer()
-    : adapt_frame_drops_data_(kMaxAccumulatorSize),
-      frame_time_data_(kMaxAccumulatorSize),
-      apply_rotation_(true) {
+VideoCapturer::VideoCapturer() : apply_rotation_(true) {
   thread_checker_.DetachFromThread();
   Construct();
 }
 
 void VideoCapturer::Construct() {
   ratio_w_ = 0;
   ratio_h_ = 0;
   enable_camera_list_ = false;
   square_pixel_aspect_ratio_ = false;
   capture_state_ = CS_STOPPED;
   SignalFrameCaptured.connect(this, &VideoCapturer::OnFrameCaptured);
   // TODO(perkj) SignalVideoFrame is used directly by Chrome remoting.
   // Before that is refactored, SignalVideoFrame must forward frames to the
   // |VideoBroadcaster|;
   SignalVideoFrame.connect(this, &VideoCapturer::OnFrame);
   scaled_width_ = 0;
   scaled_height_ = 0;
   enable_video_adapter_ = true;
-  adapt_frame_drops_ = 0;
-  previous_frame_time_ = 0.0;
   // There are lots of video capturers out there that don't call
   // set_frame_factory.  We can either go change all of them, or we
   // can set this default.
   // TODO(pthatcher): Remove this hack and require the frame factory
   // to be passed in the constructor.
   set_frame_factory(new WebRtcVideoFrameFactory());
 }
 
 const std::vector<VideoFormat>* VideoCapturer::GetSupportedFormats() const {
   return &filtered_supported_formats_;
 }
 
 bool VideoCapturer::StartCapturing(const VideoFormat& capture_format) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  previous_frame_time_ = frame_length_time_reporter_.TimerNow();
   CaptureState result = Start(capture_format);
   const bool success = (result == CS_RUNNING) || (result == CS_STARTING);
   if (!success) {
     return false;
   }
   if (result == CS_RUNNING) {
     SetCaptureState(result);
   }
   return true;
 }
@@ skipping 70 matching lines @@
   return ss.str();
 }
 
 void VideoCapturer::set_frame_factory(VideoFrameFactory* frame_factory) {
   frame_factory_.reset(frame_factory);
   if (frame_factory) {
     frame_factory->SetApplyRotation(apply_rotation_);
   }
 }
 
-void VideoCapturer::GetStats(VariableInfo<int>* adapt_drops_stats,
-                             VariableInfo<int>* effect_drops_stats,
-                             VariableInfo<double>* frame_time_stats,
-                             VideoFormat* last_captured_frame_format) {
+void VideoCapturer::GetStats(VideoFormat* last_captured_frame_format) {
   rtc::CritScope cs(&frame_stats_crit_);
-  GetVariableSnapshot(adapt_frame_drops_data_, adapt_drops_stats);
-  GetVariableSnapshot(frame_time_data_, frame_time_stats);
   *last_captured_frame_format = last_captured_frame_format_;
-
-  adapt_frame_drops_data_.Reset();
-  frame_time_data_.Reset();
 }
 
 void VideoCapturer::RemoveSink(
     rtc::VideoSinkInterface<cricket::VideoFrame>* sink) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   broadcaster_.RemoveSink(sink);
   OnSinkWantsChanged(broadcaster_.wants());
 }
 
 void VideoCapturer::AddOrUpdateSink(
@@ skipping 164 matching lines @@
                 &cropped_width, &cropped_height);
   }
 
   int adapted_width = cropped_width;
   int adapted_height = cropped_height;
   if (enable_video_adapter_ && !IsScreencast()) {
     const VideoFormat adapted_format =
         video_adapter_.AdaptFrameResolution(cropped_width, cropped_height);
     if (adapted_format.IsSize0x0()) {
       // VideoAdapter dropped the frame.
-      ++adapt_frame_drops_;
       return;
     }
     adapted_width = adapted_format.width;
     adapted_height = adapted_format.height;
   }
 
   if (!frame_factory_) {
     LOG(LS_ERROR) << "No video frame factory.";
     return;
   }
@@ skipping 159 matching lines @@
 
 void VideoCapturer::UpdateStats(const CapturedFrame* captured_frame) {
   // Update stats protected from fetches from different thread.
   rtc::CritScope cs(&frame_stats_crit_);
 
   last_captured_frame_format_.width = captured_frame->width;
   last_captured_frame_format_.height = captured_frame->height;
   // TODO(ronghuawu): Useful to report interval as well?
   last_captured_frame_format_.interval = 0;
   last_captured_frame_format_.fourcc = captured_frame->fourcc;
-
-  double time_now = frame_length_time_reporter_.TimerNow();
-  if (previous_frame_time_ != 0.0) {
-    adapt_frame_drops_data_.AddSample(adapt_frame_drops_);
-    frame_time_data_.AddSample(time_now - previous_frame_time_);
-  }
-  previous_frame_time_ = time_now;
-  adapt_frame_drops_ = 0;
-}
-
-template<class T>
-void VideoCapturer::GetVariableSnapshot(
-    const rtc::RollingAccumulator<T>& data,
-    VariableInfo<T>* stats) {
-  stats->max_val = data.ComputeMax();
-  stats->mean = data.ComputeMean();
-  stats->min_val = data.ComputeMin();
-  stats->variance = data.ComputeVariance();
 }
 
 }  // namespace cricket