Change MediaStreamVideoSource to output different resolutions to different tracks depending on the …

content/renderer/media/media_stream_video_source_unittest.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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 76 matching lines @@
   int NumberOfSuccessConstraintsCallbacks() const {
     return number_of_successful_constraints_applied_;
   }
 
   int NumberOfFailedConstraintsCallbacks() const {
     return number_of_failed_constraints_applied_;
   }
 
   MockMediaStreamVideoSource* mock_source() { return mock_source_; }
 
-  // Test that the source crops to the requested max width and
+  // Test that the source crops/scales to the requested width and
   // height even though the camera delivers a larger frame.
   void TestSourceCropFrame(int capture_width,
                            int capture_height,
                            const blink::WebMediaConstraints& constraints,
                            int expected_width,
                            int expected_height) {
     // Expect the source to start capture with the supported resolution.
     blink::WebMediaStreamTrack track =
         CreateTrackAndStartSource(constraints, capture_width, capture_height,
                                   30);
@@ skipping 15 matching lines @@
     base::RunLoop run_loop;
     base::Closure quit_closure = run_loop.QuitClosure();
     EXPECT_CALL(*sink, OnVideoFrame()).WillOnce(
         RunClosure(quit_closure));
     scoped_refptr<media::VideoFrame> frame =
               media::VideoFrame::CreateBlackFrame(gfx::Size(width, height));
     mock_source()->DeliverVideoFrame(frame);
     run_loop.Run();
   }
 
+  void DeliverVideoFrameAndWaitForTwoRenderers(
+      int width,
+      int height,
+      MockMediaStreamVideoSink* sink1,
+      MockMediaStreamVideoSink* sink2) {
+    base::RunLoop run_loop;
+    base::Closure quit_closure = run_loop.QuitClosure();
+    EXPECT_CALL(*sink1, OnVideoFrame());
+    EXPECT_CALL(*sink2, OnVideoFrame()).WillOnce(
+        RunClosure(quit_closure));
+    scoped_refptr<media::VideoFrame> frame =
+        media::VideoFrame::CreateBlackFrame(gfx::Size(width, height));
+    mock_source()->DeliverVideoFrame(frame);
+    run_loop.Run();
+  }
+
+  void TestTwoTracksWithDifferentConstraints(
+      const blink::WebMediaConstraints& constraints1,
+      const blink::WebMediaConstraints& constraints2,
+      int capture_width,
+      int capture_height,
+      int expected_width1,
+      int expected_height1,
+      int expected_width2,
+      int expected_height2) {
+    blink::WebMediaStreamTrack track1 =
+        CreateTrackAndStartSource(constraints1, capture_width, capture_height,
+                                  MediaStreamVideoSource::kDefaultFrameRate);
+
+    blink::WebMediaStreamTrack track2 =
+        CreateTrack("dummy", constraints2);
+
+    MockMediaStreamVideoSink sink1;
+    MediaStreamVideoSink::AddToVideoTrack(&sink1, sink1.GetDeliverFrameCB(),
+                                          track1);
+    EXPECT_EQ(0, sink1.number_of_frames());
+
+    MockMediaStreamVideoSink sink2;
+    MediaStreamVideoSink::AddToVideoTrack(&sink2, sink2.GetDeliverFrameCB(),
+                                          track2);
+    EXPECT_EQ(0, sink2.number_of_frames());
+
+    DeliverVideoFrameAndWaitForTwoRenderers(capture_width,
+                                            capture_height,
+                                            &sink1,
+                                            &sink2);
+
+    EXPECT_EQ(1, sink1.number_of_frames());
+    EXPECT_EQ(expected_width1, sink1.frame_size().width());
+    EXPECT_EQ(expected_height1, sink1.frame_size().height());
+
+    EXPECT_EQ(1, sink2.number_of_frames());
+    EXPECT_EQ(expected_width2, sink2.frame_size().width());
+    EXPECT_EQ(expected_height2, sink2.frame_size().height());
+
+    MediaStreamVideoSink::RemoveFromVideoTrack(&sink1, track1);
+    MediaStreamVideoSink::RemoveFromVideoTrack(&sink2, track2);
+  }
 
   void ReleaseTrackAndSourceOnAddTrackCallback(
       const blink::WebMediaStreamTrack& track_to_release) {
     track_to_release_ = track_to_release;
   }
 
  private:
   void OnConstraintsApplied(MediaStreamSource* source, bool success) {
     ASSERT_EQ(source, webkit_source_.extraData());
 
     if (success)
       ++number_of_successful_constraints_applied_;
     else
       ++number_of_failed_constraints_applied_;
 
     if (!track_to_release_.isNull()) {
       mock_source_ = NULL;
       webkit_source_.reset();
       track_to_release_.reset();
     }
   }
+  base::MessageLoopForUI message_loop_;
   scoped_ptr<ChildProcess> child_process_;
-  base::MessageLoopForUI message_loop_;
   blink::WebMediaStreamTrack track_to_release_;
   int number_of_successful_constraints_applied_;
   int number_of_failed_constraints_applied_;
   blink::WebMediaStreamSource webkit_source_;
   // |mock_source_| is owned by |webkit_source_|.
   MockMediaStreamVideoSource* mock_source_;
 };
 
 TEST_F(MediaStreamVideoSourceTest, AddTrackAndStartSource) {
   blink::WebMediaConstraints constraints;
@@ skipping 73 matching lines @@
 // require it even if an optional constraint request a higher resolution
 // that don't have this aspect ratio.
 TEST_F(MediaStreamVideoSourceTest, MandatoryAspectRatio4To3) {
   MockMediaConstraintFactory factory;
   factory.AddMandatory(MediaStreamVideoSource::kMinWidth, 640);
   factory.AddMandatory(MediaStreamVideoSource::kMinHeight, 480);
   factory.AddMandatory(MediaStreamVideoSource::kMaxAspectRatio,
                        640.0 / 480);
   factory.AddOptional(MediaStreamVideoSource::kMinWidth, 1280);
 
-  CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 640, 480, 30);
+  TestSourceCropFrame(1280, 720,
+                      factory.CreateWebMediaConstraints(), 960, 720);
 }
 
-// Test that AddTrack fail if the mandatory aspect ratio
-// is set higher than supported.
-TEST_F(MediaStreamVideoSourceTest, MandatoryAspectRatioTooHigh) {
+// Test that AddTrack succeeds if the mandatory min aspect ratio it set to 2.
+TEST_F(MediaStreamVideoSourceTest, MandatoryAspectRatio2) {
   MockMediaConstraintFactory factory;
   factory.AddMandatory(MediaStreamVideoSource::kMinAspectRatio, 2);
+
+  TestSourceCropFrame(MediaStreamVideoSource::kDefaultWidth,
+                      MediaStreamVideoSource::kDefaultHeight,
+                      factory.CreateWebMediaConstraints(), 640, 320);
+}
+
+TEST_F(MediaStreamVideoSourceTest, MinAspectRatioLargerThanMaxAspectRatio) {
+  MockMediaConstraintFactory factory;
+  factory.AddMandatory(MediaStreamVideoSource::kMinAspectRatio, 2);
+  factory.AddMandatory(MediaStreamVideoSource::kMaxAspectRatio, 1);
   blink::WebMediaStreamTrack track = CreateTrack(
       "123", factory.CreateWebMediaConstraints());
   mock_source()->CompleteGetSupportedFormats();
+  EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks());
+}
+
+TEST_F(MediaStreamVideoSourceTest, MaxAspectRatioZero) {
+  MockMediaConstraintFactory factory;
+  factory.AddOptional(MediaStreamVideoSource::kMaxAspectRatio, 0);
+  blink::WebMediaStreamTrack track = CreateTrack(
+      "123", factory.CreateWebMediaConstraints());
+  mock_source()->CompleteGetSupportedFormats();
+  EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks());
+}
+
+TEST_F(MediaStreamVideoSourceTest, MinWidthLargerThanMaxWidth) {
+  MockMediaConstraintFactory factory;
+  factory.AddMandatory(MediaStreamVideoSource::kMinWidth, 640);
+  factory.AddMandatory(MediaStreamVideoSource::kMaxWidth, 320);
+  blink::WebMediaStreamTrack track = CreateTrack(
+      "123", factory.CreateWebMediaConstraints());
+  mock_source()->CompleteGetSupportedFormats();
+  EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks());
+}
+
+TEST_F(MediaStreamVideoSourceTest, MinHeightLargerThanMaxHeight) {
+  MockMediaConstraintFactory factory;
+  factory.AddMandatory(MediaStreamVideoSource::kMinHeight, 480);
+  factory.AddMandatory(MediaStreamVideoSource::kMaxHeight, 360);
+  blink::WebMediaStreamTrack track = CreateTrack(
+      "123", factory.CreateWebMediaConstraints());
+  mock_source()->CompleteGetSupportedFormats();
   EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks());
 }
 
 // Test that its safe to release the last reference of a blink track and the
 // source during the callback if adding a track succeeds.
 TEST_F(MediaStreamVideoSourceTest, ReleaseTrackAndSourceOnSuccessCallBack) {
   MockMediaConstraintFactory factory;
   {
     blink::WebMediaStreamTrack track =
         CreateTrack("123", factory.CreateWebMediaConstraints());
     ReleaseTrackAndSourceOnAddTrackCallback(track);
   }
   mock_source()->CompleteGetSupportedFormats();
   mock_source()->StartMockedSource();
   EXPECT_EQ(1, NumberOfSuccessConstraintsCallbacks());
 }
 
 // Test that its safe to release the last reference of a blink track and the
 // source during the callback if adding a track fails.
 TEST_F(MediaStreamVideoSourceTest, ReleaseTrackAndSourceOnFailureCallBack) {
   MockMediaConstraintFactory factory;
-  factory.AddMandatory(MediaStreamVideoSource::kMinAspectRatio, 2);
+  factory.AddMandatory(MediaStreamVideoSource::kMinWidth, 99999);
   {
     blink::WebMediaStreamTrack track =
         CreateTrack("123", factory.CreateWebMediaConstraints());
     ReleaseTrackAndSourceOnAddTrackCallback(track);
   }
   mock_source()->CompleteGetSupportedFormats();
   EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks());
 }
 
 // Test that the source ignores an optional aspect ratio that is higher than
@@ skipping 106 matching lines @@
 
 // Test that the source crops to the requested max width and
 // height even though the requested frame has odd size.
 TEST_F(MediaStreamVideoSourceTest, DeliverCroppedVideoFrame637359) {
   MockMediaConstraintFactory factory;
   factory.AddOptional(MediaStreamVideoSource::kMaxWidth, 637);
   factory.AddOptional(MediaStreamVideoSource::kMaxHeight, 359);
   TestSourceCropFrame(640, 480, factory.CreateWebMediaConstraints(), 637, 359);
 }
 
+TEST_F(MediaStreamVideoSourceTest, DeliverCroppedVideoFrame320320) {
+  MockMediaConstraintFactory factory;
+  factory.AddMandatory(MediaStreamVideoSource::kMaxWidth, 320);
+  factory.AddMandatory(MediaStreamVideoSource::kMaxHeight, 320);
+  factory.AddMandatory(MediaStreamVideoSource::kMinHeight, 320);
+  factory.AddMandatory(MediaStreamVideoSource::kMinWidth, 320);
+  TestSourceCropFrame(640, 480, factory.CreateWebMediaConstraints(), 320, 320);
+}
+
 TEST_F(MediaStreamVideoSourceTest, DeliverSmallerSizeWhenTooLargeMax) {
   MockMediaConstraintFactory factory;
   factory.AddOptional(MediaStreamVideoSource::kMaxWidth, 1920);
   factory.AddOptional(MediaStreamVideoSource::kMaxHeight, 1080);
   factory.AddOptional(MediaStreamVideoSource::kMinWidth, 1280);
   factory.AddOptional(MediaStreamVideoSource::kMinHeight, 720);
   TestSourceCropFrame(1280, 720, factory.CreateWebMediaConstraints(),
                       1280, 720);
 }
 
+TEST_F(MediaStreamVideoSourceTest, TwoTracksWithVGAAndWVGA) {
+  MockMediaConstraintFactory factory1;
+  factory1.AddOptional(MediaStreamVideoSource::kMaxWidth, 640);
+  factory1.AddOptional(MediaStreamVideoSource::kMaxHeight, 480);
+
+  MockMediaConstraintFactory factory2;
+  factory2.AddOptional(MediaStreamVideoSource::kMaxHeight, 360);
+
+  TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(),
+                                        factory2.CreateWebMediaConstraints(),
+                                        640, 480,
+                                        640, 480,
+                                        640, 360);
+}
+
+TEST_F(MediaStreamVideoSourceTest, TwoTracksWith720AndWVGA) {
+  MockMediaConstraintFactory factory1;
+  factory1.AddOptional(MediaStreamVideoSource::kMinWidth, 1280);
+  factory1.AddOptional(MediaStreamVideoSource::kMinHeight, 720);
+
+
+  MockMediaConstraintFactory factory2;
+  factory2.AddMandatory(MediaStreamVideoSource::kMaxWidth, 640);
+  factory2.AddMandatory(MediaStreamVideoSource::kMaxHeight, 360);
+
+  TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(),
+                                        factory2.CreateWebMediaConstraints(),
+                                        1280, 720,
+                                        1280, 720,
+                                        640, 360);
+}
+
+TEST_F(MediaStreamVideoSourceTest, TwoTracksWith720AndW700H700) {
+  MockMediaConstraintFactory factory1;
+  factory1.AddOptional(MediaStreamVideoSource::kMinWidth, 1280);
+  factory1.AddOptional(MediaStreamVideoSource::kMinHeight, 720);
+
+  MockMediaConstraintFactory factory2;
+  factory2.AddMandatory(MediaStreamVideoSource::kMaxWidth, 700);
+  factory2.AddMandatory(MediaStreamVideoSource::kMaxHeight, 700);
+
+  TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(),
+                                        factory2.CreateWebMediaConstraints(),
+                                        1280, 720,
+                                        1280, 720,
+                                        700, 700);
+}
+
+TEST_F(MediaStreamVideoSourceTest, TwoTracksWith720AndMaxAspectRatio4To3) {
+  MockMediaConstraintFactory factory1;
+  factory1.AddOptional(MediaStreamVideoSource::kMinWidth, 1280);
+  factory1.AddOptional(MediaStreamVideoSource::kMinHeight, 720);
+
+  MockMediaConstraintFactory factory2;
+  factory2.AddMandatory(MediaStreamVideoSource::kMaxAspectRatio, 640.0 / 480);
+
+  TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(),
+                                        factory2.CreateWebMediaConstraints(),
+                                        1280, 720,
+                                        1280, 720,
+                                        960, 720);
+}
+
+TEST_F(MediaStreamVideoSourceTest, TwoTracksWithVgaAndMinAspectRatio) {
+  MockMediaConstraintFactory factory1;
+  factory1.AddOptional(MediaStreamVideoSource::kMaxWidth, 640);
+  factory1.AddOptional(MediaStreamVideoSource::kMaxHeight, 480);
+
+  MockMediaConstraintFactory factory2;
+  factory2.AddMandatory(MediaStreamVideoSource::kMinAspectRatio, 640.0 / 360);
+
+  TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(),
+                                        factory2.CreateWebMediaConstraints(),
+                                        640, 480,
+                                        640, 480,
+                                        640, 360);
+}
+
 // Test that a source can change the frame resolution on the fly and that
 // tracks sinks get the new frame size unless constraints force the frame to be
 // cropped.
 TEST_F(MediaStreamVideoSourceTest, SourceChangeFrameSize) {
   MockMediaConstraintFactory factory;
   factory.AddOptional(MediaStreamVideoSource::kMaxWidth, 800);
   factory.AddOptional(MediaStreamVideoSource::kMaxHeight, 700);
 
   // Expect the source to start capture with the supported resolution.
   blink::WebMediaStreamTrack track =
@@ skipping 44 matching lines @@
   EXPECT_TRUE(MediaStreamVideoSource::IsConstraintSupported(
         MediaStreamVideoSource::kMaxAspectRatio));
   EXPECT_TRUE(MediaStreamVideoSource::IsConstraintSupported(
       MediaStreamVideoSource::kMinAspectRatio));
 
   EXPECT_FALSE(MediaStreamVideoSource::IsConstraintSupported(
       "something unsupported"));
 }
 
 }  // namespace content