VideoCaptureImpl & relatives small cleanup.

content/renderer/media/video_track_adapter.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/video_track_adapter.h"
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 
@@ skipping 73 matching lines @@
                         double min_aspect_ratio,
                         double max_aspect_ratio,
                         double max_frame_rate) const;
 
   bool IsEmpty() const;
 
  private:
   virtual ~VideoFrameResolutionAdapter();
   friend class base::RefCountedThreadSafe<VideoFrameResolutionAdapter>;
 
-  virtual void DoDeliverFrame(
-      const scoped_refptr<media::VideoFrame>& frame,
-      const media::VideoCaptureFormat& format,
-      const base::TimeTicks& estimated_capture_time);
+  void DoDeliverFrame(const scoped_refptr<media::VideoFrame>& frame,

[wolenetz, 2015/03/02 23:51:09]

nit: ditto update CL description to include this, which is outside of the
otherwise mechanical C++11 range-based-for-loop/auto/etc currently in the
description.

[mcasas, 2015/03/03 15:40:52]

Acknowledged.

+                      const media::VideoCaptureFormat& format,
+                      const base::TimeTicks& estimated_capture_time);
 
   // Returns |true| if the input frame rate is higher that the requested max
   // frame rate and |frame| should be dropped.
   bool MaybeDropFrame(const scoped_refptr<media::VideoFrame>& frame,
                       float source_frame_rate);
 
   // Bound to the IO-thread.
   base::ThreadChecker io_thread_checker_;
 
   // The task runner where we will release VideoCaptureDeliverFrameCB
@@ skipping 142 matching lines @@
 }
 
 bool VideoTrackAdapter::VideoFrameResolutionAdapter::MaybeDropFrame(
     const scoped_refptr<media::VideoFrame>& frame,
     float source_frame_rate) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
 
   // Do not drop frames if max frame rate hasn't been specified or the source
   // frame rate is known and is lower than max.
   if (max_frame_rate_ == 0.0f ||
-      (source_frame_rate > 0 &&
-          source_frame_rate <= max_frame_rate_)) {
+      (source_frame_rate > 0 && source_frame_rate <= max_frame_rate_)) {
     return false;
   }
 
   const double delta_ms =
       (frame->timestamp() - last_time_stamp_).InMillisecondsF();
 
   // Check if the time since the last frame is completely off.
   if (delta_ms < 0 || delta_ms > kMaxTimeInMsBetweenFrames) {
     // Reset |last_time_stamp_| and fps calculation.
     last_time_stamp_ = frame->timestamp();
@@ skipping 29 matching lines @@
   keep_frame_counter_ += max_frame_rate_ / frame_rate_;
   if (keep_frame_counter_ >= 1) {
     keep_frame_counter_ -= 1;
     // Keep the frame.
     return false;
   }
   DVLOG(3) << "Drop frame. Input frame_rate_ " << frame_rate_ << ".";
   return true;
 }
 
-void VideoTrackAdapter::
-VideoFrameResolutionAdapter::DoDeliverFrame(
+void VideoTrackAdapter::VideoFrameResolutionAdapter::DoDeliverFrame(
     const scoped_refptr<media::VideoFrame>& frame,
     const media::VideoCaptureFormat& format,
     const base::TimeTicks& estimated_capture_time) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
-  for (std::vector<VideoIdCallbackPair>::const_iterator it = callbacks_.begin();
-       it != callbacks_.end(); ++it) {
-    it->second.Run(frame, format, estimated_capture_time);
-  }
+  for (const auto& it : callbacks_)
+    it.second.Run(frame, format, estimated_capture_time);
 }
 
 void VideoTrackAdapter::VideoFrameResolutionAdapter::AddCallback(
     const MediaStreamVideoTrack* track,
     const VideoCaptureDeliverFrameCB& callback) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   callbacks_.push_back(std::make_pair(track, callback));
 }
 
 void VideoTrackAdapter::VideoFrameResolutionAdapter::RemoveCallback(
@@ skipping 42 matching lines @@
       muted_state_(false),
       frame_counter_(0),
       source_frame_rate_(0.0f) {
   DCHECK(io_message_loop_.get());
 }
 
 VideoTrackAdapter::~VideoTrackAdapter() {
   DCHECK(adapters_.empty());
 }
 
-void VideoTrackAdapter::AddTrack(
-    const MediaStreamVideoTrack* track,
-    VideoCaptureDeliverFrameCB frame_callback,
-    int max_width,
-    int max_height,
-    double min_aspect_ratio,
-    double max_aspect_ratio,
-    double max_frame_rate) {
+void VideoTrackAdapter::AddTrack(const MediaStreamVideoTrack* track,
+                                 VideoCaptureDeliverFrameCB frame_callback,
+                                 int max_width,
+                                 int max_height,
+                                 double min_aspect_ratio,
+                                 double max_aspect_ratio,
+                                 double max_frame_rate) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   io_message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&VideoTrackAdapter::AddTrackOnIO,
                  this, track, frame_callback, gfx::Size(max_width, max_height),
                  min_aspect_ratio, max_aspect_ratio, max_frame_rate));
 }
 
-void VideoTrackAdapter::AddTrackOnIO(
-    const MediaStreamVideoTrack* track,
-    VideoCaptureDeliverFrameCB frame_callback,
-    const gfx::Size& max_frame_size,
-    double min_aspect_ratio,
-    double max_aspect_ratio,
-    double max_frame_rate) {
+void VideoTrackAdapter::AddTrackOnIO(const MediaStreamVideoTrack* track,
+                                     VideoCaptureDeliverFrameCB frame_callback,
+                                     const gfx::Size& max_frame_size,
+                                     double min_aspect_ratio,
+                                     double max_aspect_ratio,
+                                     double max_frame_rate) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   scoped_refptr<VideoFrameResolutionAdapter> adapter;
-  for (FrameAdapters::const_iterator it = adapters_.begin();
-       it != adapters_.end(); ++it) {
-    if ((*it)->ConstraintsMatch(max_frame_size, min_aspect_ratio,
-                                max_aspect_ratio, max_frame_rate)) {
-      adapter = it->get();
+  for (const auto& it : adapters_) {
+    if (it->ConstraintsMatch(max_frame_size, min_aspect_ratio,
+                             max_aspect_ratio, max_frame_rate)) {
+      adapter = it.get();
       break;
     }
   }
   if (!adapter.get()) {
     adapter = new VideoFrameResolutionAdapter(renderer_task_runner_,
                                               max_frame_size,
                                               min_aspect_ratio,
                                               max_aspect_ratio,
                                               max_frame_rate);
     adapters_.push_back(adapter);
@@ skipping 68 matching lines @@
   }
 }
 
 void VideoTrackAdapter::DeliverFrameOnIO(
     const scoped_refptr<media::VideoFrame>& frame,
     const media::VideoCaptureFormat& format,
     const base::TimeTicks& estimated_capture_time) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   TRACE_EVENT0("video", "VideoTrackAdapter::DeliverFrameOnIO");
   ++frame_counter_;
-  for (FrameAdapters::iterator it = adapters_.begin();
-       it != adapters_.end(); ++it) {
-    (*it)->DeliverFrame(frame, format, estimated_capture_time);
-  }
+  for (const auto& it : adapters_)
+    it->DeliverFrame(frame, format, estimated_capture_time);
 }
 
 void VideoTrackAdapter::CheckFramesReceivedOnIO(
     const OnMutedCallback& set_muted_state_callback,
     uint64 old_frame_counter_snapshot) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
 
   if (!monitoring_frame_rate_)
     return;
 
   DVLOG_IF(1, old_frame_counter_snapshot == frame_counter_)
       << "No frames have passed, setting source as Muted.";
 
   bool muted_state = old_frame_counter_snapshot == frame_counter_;
   if (muted_state_ != muted_state) {
     set_muted_state_callback.Run(muted_state);
     muted_state_ = muted_state;
   }
 
   io_message_loop_->PostDelayedTask(FROM_HERE,
       base::Bind(&VideoTrackAdapter::CheckFramesReceivedOnIO, this,
           set_muted_state_callback, frame_counter_),
       base::TimeDelta::FromSecondsD(kNormalFrameTimeoutInFrameIntervals /
                                     source_frame_rate_));
 }
 
 }  // namespace content