Detect frames from rotated devices in VideoTrackAdapter on Android.

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/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/test/scoped_task_environment.h"
+#include "build/build_config.h"
 #include "content/child/child_process.h"
 #include "content/public/common/content_features.h"
 #include "content/renderer/media/media_stream_video_source.h"
 #include "content/renderer/media/media_stream_video_track.h"
 #include "content/renderer/media/mock_constraint_factory.h"
 #include "content/renderer/media/mock_media_stream_video_sink.h"
 #include "content/renderer/media/mock_media_stream_video_source.h"
 #include "content/renderer/media/video_track_adapter.h"
 #include "media/base/limits.h"
 #include "media/base/video_frame.h"
@@ skipping 68 matching lines @@
       double min_frame_rate) {
     bool enabled = true;
     return MediaStreamVideoTrack::CreateVideoTrack(
         mock_source_, adapter_settings, noise_reduction, is_screencast,
         min_frame_rate,
         base::Bind(&MediaStreamVideoSourceTest::OnConstraintsApplied,
                    base::Unretained(this)),
         enabled);
   }
 
-  blink::WebMediaStreamTrack CreateTrackAndStartSource(int width,
-                                                       int height,
-                                                       double frame_rate) {
+  blink::WebMediaStreamTrack CreateTrackAndStartSource(
+      int width,
+      int height,
+      double frame_rate,
+      bool detect_rotation = false) {
     DCHECK(!IsOldVideoConstraints());
-    blink::WebMediaStreamTrack track = CreateTrack(
-        "123",
-        VideoTrackAdapterSettings(width, height, 0.0, HUGE_VAL, frame_rate),
-        base::Optional<bool>(), false, 0.0);
+    blink::WebMediaStreamTrack track =
+        CreateTrack("123",
+                    VideoTrackAdapterSettings(
+                        width, height, 0.0, HUGE_VAL, frame_rate,
+                        detect_rotation ? gfx::Size(width, height)
+                                        : base::Optional<gfx::Size>()),
+                    base::Optional<bool>(), false, 0.0);
 
     EXPECT_EQ(0, NumberOfSuccessConstraintsCallbacks());
     mock_source_->StartMockedSource();
     // Once the source has started successfully we expect that the
     // ConstraintsCallback in MediaStreamSource::AddTrack completes.
     EXPECT_EQ(1, NumberOfSuccessConstraintsCallbacks());
     return track;
   }
 
   int NumberOfSuccessConstraintsCallbacks() const {
@@ skipping 37 matching lines @@
                                            MockMediaStreamVideoSink* sink) {
     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 DeliverRotatedVideoFrameAndWaitForRenderer(
+      int width,
+      int height,
+      MockMediaStreamVideoSink* sink) {
+    DeliverVideoFrameAndWaitForRenderer(height, width, sink);
+  }
+
   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 TestTwoTracksWithDifferentSettings(int capture_width,
                                           int capture_height,
                                           int expected_width1,
                                           int expected_height1,
                                           int expected_width2,
                                           int expected_height2) {
     blink::WebMediaStreamTrack track1 =
         CreateTrackAndStartSource(expected_width1, expected_height1,
                                   MediaStreamVideoSource::kDefaultFrameRate);
 
     blink::WebMediaStreamTrack track2 =
         CreateTrack("dummy",
                     VideoTrackAdapterSettings(
                         expected_width2, expected_height2, 0.0, HUGE_VAL,
-                        MediaStreamVideoSource::kDefaultFrameRate),
+                        MediaStreamVideoSource::kDefaultFrameRate,
+                        base::Optional<gfx::Size>()),
                     base::Optional<bool>(), false, 0.0);
 
     MockMediaStreamVideoSink sink1;
     sink1.ConnectToTrack(track1);
     EXPECT_EQ(0, sink1.number_of_frames());
 
     MockMediaStreamVideoSink sink2;
     sink2.ConnectToTrack(track2);
     EXPECT_EQ(0, sink2.number_of_frames());
 
@@ skipping 91 matching lines @@
 
 TEST_F(MediaStreamVideoSourceTest, TwoTracksWithVGAAndWVGA) {
   TestTwoTracksWithDifferentSettings(640, 480, 640, 480, 640, 360);
 }
 
 TEST_F(MediaStreamVideoSourceTest, TwoTracksWith720AndWVGA) {
   TestTwoTracksWithDifferentSettings(1280, 720, 1280, 720, 640, 360);
 }
 
 TEST_F(MediaStreamVideoSourceTest, SourceChangeFrameSize) {
-  MockConstraintFactory factory;
-  factory.AddAdvanced().width.SetMax(800);
-  factory.AddAdvanced().height.SetMax(700);
-
   // Expect the source to start capture with the supported resolution.
   // Disable frame-rate adjustment in spec-compliant mode to ensure no frames
   // are dropped.
   blink::WebMediaStreamTrack track = CreateTrackAndStartSource(800, 700, 0.0);
 
   MockMediaStreamVideoSink sink;
   sink.ConnectToTrack(track);
   EXPECT_EQ(0, sink.number_of_frames());
   DeliverVideoFrameAndWaitForRenderer(320, 240, &sink);
   EXPECT_EQ(1, sink.number_of_frames());
@@ skipping 11 matching lines @@
 
   DeliverVideoFrameAndWaitForRenderer(1280, 720, &sink);
   EXPECT_EQ(3, sink.number_of_frames());
   // Expect a frame to be cropped since its larger than max requested.
   EXPECT_EQ(800, sink.frame_size().width());
   EXPECT_EQ(700, sink.frame_size().height());
 
   sink.DisconnectFromTrack();
 }
 
+#if defined(OS_ANDROID)
+TEST_F(MediaStreamVideoSourceTest, RotatedSource) {
+  // Expect the source to start capture with the supported resolution.
+  // Disable frame-rate adjustment in spec-compliant mode to ensure no frames
+  // are dropped.
+  blink::WebMediaStreamTrack track =
+      CreateTrackAndStartSource(640, 480, 0.0, true);
+
+  MockMediaStreamVideoSink sink;
+  sink.ConnectToTrack(track);
+  EXPECT_EQ(0, sink.number_of_frames());
+  DeliverVideoFrameAndWaitForRenderer(640, 480, &sink);
+  EXPECT_EQ(1, sink.number_of_frames());
+  // Expect the delivered frame to be passed unchanged since its smaller than
+  // max requested.
+  EXPECT_EQ(640, sink.frame_size().width());
+  EXPECT_EQ(480, sink.frame_size().height());
+
+  DeliverRotatedVideoFrameAndWaitForRenderer(640, 480, &sink);
+  EXPECT_EQ(2, sink.number_of_frames());
+  // Expect the delivered frame to be passed unchanged since its detected as
+  // a valid frame on a rotated device.
+  EXPECT_EQ(480, sink.frame_size().width());
+  EXPECT_EQ(640, sink.frame_size().height());
+
+  sink.DisconnectFromTrack();
+}
+#endif
+
 // Test that a source producing no frames change the source ReadyState to muted.
 // that in a reasonable time frame the muted state turns to false.
 TEST_F(MediaStreamVideoSourceTest, MutedSource) {
   // Setup the source for support a frame rate of 999 fps in order to test
   // the muted event faster. This is since the frame monitoring uses
   // PostDelayedTask that is dependent on the source frame rate.
   // Note that media::limits::kMaxFramesPerSecond is 1000.
   blink::WebMediaStreamTrack track = CreateTrackAndStartSource(
       640, 480, media::limits::kMaxFramesPerSecond - 2);
   MockMediaStreamVideoSink sink;
@@ skipping 866 matching lines @@
        InvalidMandatoryAspectRatioFails) {
   MockConstraintFactory factory;
   factory.basic().aspect_ratio.SetMax(0.0);
   blink::WebMediaStreamTrack track =
       CreateTrack("123", factory.CreateWebMediaConstraints());
   mock_source()->CompleteGetSupportedFormats();
   EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks());
 }
 
 }  // namespace content