MediaStream: Adding VideoTrackRecorder class and unittests

content/renderer/media/media_stream_video_source.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/media_stream_video_source.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 86 matching lines @@
       constraints,
       MediaStreamVideoSource::kMinAspectRatio,
       min_aspect_ratio);
   mandatory |= GetMandatoryConstraintValueAsDouble(
       constraints,
       MediaStreamVideoSource::kMaxAspectRatio,
       max_aspect_ratio);
   if (mandatory)
     return;
 
-  GetOptionalConstraintValueAsDouble(
-      constraints,
-      MediaStreamVideoSource::kMinAspectRatio,
-      min_aspect_ratio);
-  GetOptionalConstraintValueAsDouble(
-      constraints,
-      MediaStreamVideoSource::kMaxAspectRatio,
-      max_aspect_ratio);
+  GetOptionalConstraintValueAsDouble(constraints,
+                                     MediaStreamVideoSource::kMinAspectRatio,
+                                     min_aspect_ratio);
+  GetOptionalConstraintValueAsDouble(constraints,
+                                     MediaStreamVideoSource::kMaxAspectRatio,
+                                     max_aspect_ratio);
 }
 
 // Returns true if |constraint| is fulfilled. |format| can be changed by a
 // constraint, e.g. the frame rate can be changed by setting maxFrameRate.
-bool UpdateFormatForConstraint(
-    const blink::WebMediaConstraint& constraint,
-    bool mandatory,
-    media::VideoCaptureFormat* format) {
+bool UpdateFormatForConstraint(const blink::WebMediaConstraint& constraint,
+                               bool mandatory,
+                               media::VideoCaptureFormat* format) {
   DCHECK(format != NULL);
 
   if (!format->IsValid())
     return false;
 
-  std::string constraint_name = constraint.m_name.utf8();
-  std::string constraint_value = constraint.m_value.utf8();
+  const std::string constraint_name = constraint.m_name.utf8();
+  const std::string constraint_value = constraint.m_value.utf8();
 
   if (constraint_name.find(kGooglePrefix) == 0) {
     // These are actually options, not constraints, so they can be satisfied
     // regardless of the format.
     return true;
   }
 
   if (constraint_name == MediaStreamSource::kSourceId) {
     // This is a constraint that doesn't affect the format.
     return true;
@@ skipping 45 matching lines @@
     return true;
   } else {
     LOG(WARNING) << "Found unknown MediaStream constraint. Name:"
                  <<  constraint_name << " Value:" << constraint_value;
     return false;
   }
 }
 
 // Removes media::VideoCaptureFormats from |formats| that don't meet
 // |constraint|.
-void FilterFormatsByConstraint(
-    const blink::WebMediaConstraint& constraint,
-    bool mandatory,
-    media::VideoCaptureFormats* formats) {
+void FilterFormatsByConstraint(const blink::WebMediaConstraint& constraint,
+                               bool mandatory,
+                               media::VideoCaptureFormats* formats) {
   DVLOG(3) << "FilterFormatsByConstraint("
            << "{ constraint.m_name = " << constraint.m_name.utf8()
            << "  constraint.m_value = " << constraint.m_value.utf8()
            << "  mandatory =  " << mandatory << "})";
   media::VideoCaptureFormats::iterator format_it = formats->begin();
   while (format_it != formats->end()) {
     // Modify the format_it to fulfill the constraint if possible.
     // Delete it otherwise.
     if (!UpdateFormatForConstraint(constraint, mandatory, &(*format_it)))
       format_it = formats->erase(format_it);
@@ skipping 48 matching lines @@
       DLOG(WARNING) << "Wrong requested frame rate.";
       return media::VideoCaptureFormats();
     }
   }
 
   blink::WebVector<blink::WebMediaConstraint> mandatory;
   blink::WebVector<blink::WebMediaConstraint> optional;
   constraints.getMandatoryConstraints(mandatory);
   constraints.getOptionalConstraints(optional);
   media::VideoCaptureFormats candidates = supported_formats;
-  for (size_t i = 0; i < mandatory.size(); ++i) {
-    FilterFormatsByConstraint(mandatory[i], true, &candidates);
+  for (const auto& constraint : mandatory) {
+    FilterFormatsByConstraint(constraint, true, &candidates);
     if (candidates.empty()) {
-      *unsatisfied_constraint = mandatory[i].m_name;
+      *unsatisfied_constraint = constraint.m_name;
       return candidates;
     }
   }
 
   if (candidates.empty())
     return candidates;
 
   // Ok - all mandatory checked and we still have candidates.
   // Let's try filtering using the optional constraints. The optional
   // constraints must be filtered in the order they occur in |optional|.
   // But if a constraint produce zero candidates, the constraint is ignored and
   // the next constraint is tested.
   // http://dev.w3.org/2011/webrtc/editor/getusermedia.html#idl-def-Constraints
-  for (size_t i = 0; i < optional.size(); ++i) {
+  for (const auto& constraint : optional) {
     media::VideoCaptureFormats current_candidates = candidates;
-    FilterFormatsByConstraint(optional[i], false, &current_candidates);
+    FilterFormatsByConstraint(constraint, false, &current_candidates);
     if (!current_candidates.empty())
       candidates = current_candidates;
   }
 
   // We have done as good as we can to filter the supported resolutions.
   return candidates;
 }
 
 const media::VideoCaptureFormat& GetBestFormatBasedOnArea(
     const media::VideoCaptureFormats& formats,
@@ skipping 10 matching lines @@
   }
   return *best_it;
 }
 
 // Find the format that best matches the default video size.
 // This algorithm is chosen since a resolution must be picked even if no
 // constraints are provided. We don't just select the maximum supported
 // resolution since higher resolutions cost more in terms of complexity and
 // many cameras have lower frame rate and have more noise in the image at
 // their maximum supported resolution.
-void GetBestCaptureFormat(
-    const media::VideoCaptureFormats& formats,
-    const blink::WebMediaConstraints& constraints,
-    media::VideoCaptureFormat* capture_format) {
+void GetBestCaptureFormat(const media::VideoCaptureFormats& formats,
+                          const blink::WebMediaConstraints& constraints,
+                          media::VideoCaptureFormat* capture_format) {
   DCHECK(!formats.empty());
 
   int max_width;
   int max_height;
   GetDesiredMaxWidthAndHeight(constraints, &max_width, &max_height);
 
   *capture_format = GetBestFormatBasedOnArea(
       formats,
       std::min(max_width,
                static_cast<int>(MediaStreamVideoSource::kDefaultWidth)) *
@@ skipping 29 matching lines @@
   DCHECK(CalledOnValidThread());
 }
 
 void MediaStreamVideoSource::AddTrack(
     MediaStreamVideoTrack* track,
     const VideoCaptureDeliverFrameCB& frame_callback,
     const blink::WebMediaConstraints& constraints,
     const ConstraintsCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(!constraints.isNull());
-  DCHECK(std::find(tracks_.begin(), tracks_.end(),
-                   track) == tracks_.end());
+  DCHECK(std::find(tracks_.begin(), tracks_.end(), track) == tracks_.end());
   tracks_.push_back(track);
 
   requested_constraints_.push_back(
       RequestedConstraints(track, frame_callback, constraints, callback));
 
   switch (state_) {
     case NEW: {
       // Tab capture and Screen capture needs the maximum requested height
       // and width to decide on the resolution.
       int max_requested_width = 0;
@@ skipping 232 matching lines @@
     : track(track),
       frame_callback(frame_callback),
       constraints(constraints),
       callback(callback) {
 }
 
 MediaStreamVideoSource::RequestedConstraints::~RequestedConstraints() {
 }
 
 }  // namespace content