Let getSettings() return the constrained track resolution, not source.

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 205 matching lines @@
   if (MaybeDropFrame(frame, frame_rate))
     return;
 
   // TODO(perkj): Allow cropping / scaling of textures once
   // http://crbug/362521 is fixed.
   if (frame->HasTextures()) {
     DoDeliverFrame(frame, estimated_capture_time);
     return;
   }
   scoped_refptr<media::VideoFrame> video_frame(frame);
-  const double input_ratio =
-      static_cast<double>(frame->natural_size().width()) /
-      frame->natural_size().height();
 
-  // If |frame| has larger width or height than requested, or the aspect ratio
-  // does not match the requested, we want to create a wrapped version of this
-  // frame with a size that fulfills the constraints.
-  if (frame->natural_size().width() > max_frame_size_.width() ||
-      frame->natural_size().height() > max_frame_size_.height() ||
-      input_ratio > max_aspect_ratio_ ||
-      input_ratio < min_aspect_ratio_) {
-    int desired_width = std::min(max_frame_size_.width(),
-                                 frame->natural_size().width());
-    int desired_height = std::min(max_frame_size_.height(),
-                                  frame->natural_size().height());
-
-    const double resulting_ratio =
-        static_cast<double>(desired_width) / desired_height;
-    // Make sure |min_aspect_ratio_| < |requested_ratio| < |max_aspect_ratio_|.
-    const double requested_ratio = std::max(
-        std::min(resulting_ratio, max_aspect_ratio_), min_aspect_ratio_);
-
-    if (resulting_ratio < requested_ratio) {
-      desired_height = static_cast<int>((desired_height * resulting_ratio) /
-                                        requested_ratio);
-      // Make sure we scale to an even height to avoid rounding errors
-      desired_height = (desired_height + 1) & ~1;
-    } else if (resulting_ratio > requested_ratio) {
-      desired_width = static_cast<int>((desired_width * requested_ratio) /
-                                       resulting_ratio);
-      // Make sure we scale to an even width to avoid rounding errors.
-      desired_width = (desired_width + 1) & ~1;
-    }
-
-    const gfx::Size desired_size(desired_width, desired_height);
-
+  gfx::Size desired_size;
+  CalculateTargetSize(frame->natural_size(), max_frame_size_, min_aspect_ratio_,
+                      max_aspect_ratio_, &desired_size);
+  if (desired_size != frame->natural_size()) {
     // Get the largest centered rectangle with the same aspect ratio of
     // |desired_size| that fits entirely inside of |frame->visible_rect()|.
     // This will be the rect we need to crop the original frame to.
     // From this rect, the original frame can be scaled down to |desired_size|.
     const gfx::Rect region_in_frame =
         media::ComputeLetterboxRegion(frame->visible_rect(), desired_size);
 
     video_frame = media::VideoFrame::WrapVideoFrame(
         frame, frame->format(), region_in_frame, desired_size);
     if (!video_frame)
@@ skipping 169 matching lines @@
       FROM_HERE, base::Bind(&VideoTrackAdapter::StartFrameMonitoringOnIO, this,
                             bound_on_muted_callback, source_frame_rate));
 }
 
 void VideoTrackAdapter::StopFrameMonitoring() {
   DCHECK(thread_checker_.CalledOnValidThread());
   io_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoTrackAdapter::StopFrameMonitoringOnIO, this));
 }
 
+// static
+void VideoTrackAdapter::CalculateTargetSize(const gfx::Size& input_size,
+                                            const gfx::Size& max_frame_size,
+                                            double min_aspect_ratio,
+                                            double max_aspect_ratio,
+                                            gfx::Size* desired_size) {
+  // If |frame| has larger width or height than requested, or the aspect ratio
+  // does not match the requested, we want to create a wrapped version of this
+  // frame with a size that fulfills the constraints.
+  const double input_ratio =
+      static_cast<double>(input_size.width()) / input_size.height();
+
+  if (input_size.width() > max_frame_size.width() ||
+      input_size.height() > max_frame_size.height() ||
+      input_ratio > max_aspect_ratio || input_ratio < min_aspect_ratio) {
+    int desired_width = std::min(max_frame_size.width(), input_size.width());
+    int desired_height = std::min(max_frame_size.height(), input_size.height());
+
+    const double resulting_ratio =
+        static_cast<double>(desired_width) / desired_height;
+    // Make sure |min_aspect_ratio| < |requested_ratio| < |max_aspect_ratio|.
+    const double requested_ratio =
+        std::max(std::min(resulting_ratio, max_aspect_ratio), min_aspect_ratio);
+
+    if (resulting_ratio < requested_ratio) {
+      desired_height = static_cast<int>((desired_height * resulting_ratio) /
+                                        requested_ratio);
+      // Make sure we scale to an even height to avoid rounding errors
+      desired_height = (desired_height + 1) & ~1;
+    } else if (resulting_ratio > requested_ratio) {
+      desired_width =
+          static_cast<int>((desired_width * requested_ratio) / resulting_ratio);
+      // Make sure we scale to an even width to avoid rounding errors.
+      desired_width = (desired_width + 1) & ~1;
+    }
+
+    *desired_size = gfx::Size(desired_width, desired_height);
+  } else {
+    *desired_size = input_size;
+  }
+}
+
 void VideoTrackAdapter::StartFrameMonitoringOnIO(
     const OnMutedCallback& on_muted_callback,
     double source_frame_rate) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   DCHECK(!monitoring_frame_rate_);
 
   monitoring_frame_rate_ = true;
 
   // If the source does not know the frame rate, set one by default.
   if (source_frame_rate == 0.0f)
@@ skipping 53 matching lines @@
   }
 
   io_task_runner_->PostDelayedTask(
       FROM_HERE, base::Bind(&VideoTrackAdapter::CheckFramesReceivedOnIO, this,
                             set_muted_state_callback, frame_counter_),
       base::TimeDelta::FromSecondsD(kNormalFrameTimeoutInFrameIntervals /
                                     source_frame_rate_));
 }
 
 }  // namespace content