Chrome MediaStream VideoTrack implementation.

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/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/renderer/media/media_stream_video_source.h"
+#include "content/renderer/media/media_stream_video_track.h"
 #include "content/renderer/media/mock_media_stream_dependency_factory.h"
 #include "content/renderer/media/mock_media_stream_video_source.h"
 #include "media/base/video_frame.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 class ConstraintsFactory {
  public:
   void AddMandatory(const std::string& key, int value) {
@@ skipping 51 matching lines @@
                               blink::WebMediaStreamSource::TypeVideo,
                               base::UTF8ToUTF16("dummy_source_name"));
     webkit_source_.setExtraData(mock_source_);
   }
 
  protected:
   // Create a track that's associated with |webkit_source_|.
   blink::WebMediaStreamTrack CreateTrack(
       const std::string& id,
       const blink::WebMediaConstraints& constraints) {
-    blink::WebMediaStreamTrack track;
-    track.initialize(base::UTF8ToUTF16(id), webkit_source_);
-
-    MediaStreamVideoSource* source =
-        static_cast<MediaStreamVideoSource*>(track.source().extraData());
-
-    source->AddTrack(track,
-                     constraints,
-                     base::Bind(
-                         &MediaStreamVideoSourceTest::OnConstraintsApplied,
-                         base::Unretained(this)));
-    return track;
+    bool enabled = true;
+    MediaStreamDependencyFactory* factory = NULL;
+    return MediaStreamVideoTrack::CreateVideoTrack(
+        mock_source_, constraints,
+        base::Bind(
+            &MediaStreamVideoSourceTest::OnConstraintsApplied,
+            base::Unretained(this)),
+        enabled, factory);
   }
 
   blink::WebMediaStreamTrack CreateTrackAndStartSource(
       const blink::WebMediaConstraints& constraints,
       int expected_width,
       int expected_height,
       int expected_frame_rate) {
     blink::WebMediaStreamTrack track = CreateTrack("123", constraints);
 
     mock_source_->CompleteGetSupportedFormats();
@@ skipping 66 matching lines @@
   int number_of_failed_constraints_applied_;
   MockMediaStreamDependencyFactory factory_;
   blink::WebMediaStreamSource webkit_source_;
   // |mock_source_| is owned by |webkit_source_|.
   MockMediaStreamVideoSource* mock_source_;
 };
 
 TEST_F(MediaStreamVideoSourceTest, AddTrackAndStartSource) {
   blink::WebMediaConstraints constraints;
   constraints.initialize();
-  blink::WebMediaStreamTrack track = CreateTrack("123", constraints);
+  CreateTrack("123", constraints);
   mock_source()->CompleteGetSupportedFormats();
   mock_source()->StartMockedSource();
   EXPECT_EQ(1, NumberOfSuccessConstraintsCallbacks());
 }
 
 TEST_F(MediaStreamVideoSourceTest, AddTwoTracksBeforeSourceStarts) {
   blink::WebMediaConstraints constraints;
   constraints.initialize();
   blink::WebMediaStreamTrack track1 = CreateTrack("123", constraints);
   mock_source()->CompleteGetSupportedFormats();
   blink::WebMediaStreamTrack track2 = CreateTrack("123", constraints);
   EXPECT_EQ(0, NumberOfSuccessConstraintsCallbacks());
   mock_source()->StartMockedSource();
   EXPECT_EQ(2, NumberOfSuccessConstraintsCallbacks());
 }
 
 TEST_F(MediaStreamVideoSourceTest, AddTrackAfterSourceStarts) {
   blink::WebMediaConstraints constraints;
   constraints.initialize();
-  blink::WebMediaStreamTrack track1 = CreateTrack("123", constraints);
+  CreateTrack("123", constraints);
   mock_source()->CompleteGetSupportedFormats();
   mock_source()->StartMockedSource();
   EXPECT_EQ(1, NumberOfSuccessConstraintsCallbacks());
-  blink::WebMediaStreamTrack track2 = CreateTrack("123", constraints);
+  CreateTrack("123", constraints);
   EXPECT_EQ(2, NumberOfSuccessConstraintsCallbacks());
 }
 
 TEST_F(MediaStreamVideoSourceTest, AddTrackAndFailToStartSource) {
   blink::WebMediaConstraints constraints;
   constraints.initialize();
-  blink::WebMediaStreamTrack track = CreateTrack("123", constraints);
+  CreateTrack("123", constraints);
   mock_source()->CompleteGetSupportedFormats();
   mock_source()->FailToStartMockedSource();
   EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks());
 }
 
 TEST_F(MediaStreamVideoSourceTest, AddTwoTracksBeforeGetSupportedFormats) {
   blink::WebMediaConstraints constraints;
   constraints.initialize();
-  blink::WebMediaStreamTrack track1 = CreateTrack("123", constraints);
-  blink::WebMediaStreamTrack track2 = CreateTrack("123", constraints);
+  CreateTrack("123", constraints);
+  CreateTrack("123", constraints);
   mock_source()->CompleteGetSupportedFormats();
   mock_source()->StartMockedSource();
   EXPECT_EQ(2, NumberOfSuccessConstraintsCallbacks());
 }
 
 // Test that the capture output is CIF if we set max constraints to CIF.
 // and the capture device support CIF.
 TEST_F(MediaStreamVideoSourceTest, MandatoryConstraintCif5Fps) {
   ConstraintsFactory factory;
   factory.AddMandatory(MediaStreamVideoSource::kMaxWidth, 352);
@@ skipping 23 matching lines @@
   ConstraintsFactory 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.CreateConstraints(), 640, 480, 30);
 }
 
-// Test that ApplyConstraints fail if the mandatory aspect ratio
+// Test that AddTrack fail if the mandatory aspect ratio
 // is set higher than supported.
 TEST_F(MediaStreamVideoSourceTest, MandatoryAspectRatioTooHigh) {
   ConstraintsFactory factory;
   factory.AddMandatory(MediaStreamVideoSource::kMinAspectRatio, 2);
   CreateTrack("123", factory.CreateConstraints());
   mock_source()->CompleteGetSupportedFormats();
   EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks());
 }
 
 // Test that the source ignores an optional aspect ratio that is higher than
@@ skipping 26 matching lines @@
   constraints.initialize();
   CreateTrackAndStartSource(constraints,
                             MediaStreamVideoSource::kDefaultWidth,
                             MediaStreamVideoSource::kDefaultHeight,
                             30);
 }
 
 TEST_F(MediaStreamVideoSourceTest, InvalidMandatoryConstraint) {
   ConstraintsFactory factory;
   factory.AddMandatory("weird key", 640);
-
   CreateTrack("123", factory.CreateConstraints());
   mock_source()->CompleteGetSupportedFormats();
   EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks());
 }
 
 // Test that the source ignores an unknown optional constraint.
 TEST_F(MediaStreamVideoSourceTest, InvalidOptionalConstraint) {
   ConstraintsFactory factory;
   factory.AddOptional("weird key", 640);
 
@@ skipping 92 matching lines @@
 TEST_F(MediaStreamVideoSourceTest, DeliverSmallerSizeWhenTooLargeMax) {
   ConstraintsFactory 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.CreateConstraints(), 1280, 720);
 }
 
 }  // namespace content