Update MediaStreamTrack::Stop to latest draft.

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"
@@ skipping 83 matching lines @@
   // Test that the source crops to the requested max width and
   // height even though the camera delivers a larger frame.
   // TODO(perkj): Frame resolution should be verified in MediaStreamVideoTrack
   // and not in the adapter.
   void TestSourceCropFrame(int capture_width,
                            int capture_height,
                            const blink::WebMediaConstraints& constraints,
                            int expected_height,
                            int expected_width) {
     // Expect the source to start capture with the supported resolution.
-    CreateTrackAndStartSource(constraints, capture_width, capture_height , 30);
+    blink::WebMediaStreamTrack track = CreateTrackAndStartSource(
+        constraints, capture_width, capture_height , 30);
 
     ASSERT_TRUE(mock_source()->GetAdapter());
     MockVideoSource* adapter = static_cast<MockVideoSource*>(
         mock_source()->GetAdapter());
     EXPECT_EQ(0, adapter->GetFrameNum());
 
     scoped_refptr<media::VideoFrame> frame =
         media::VideoFrame::CreateBlackFrame(gfx::Size(capture_width,
                                                       capture_height));
     mock_source()->DeliverVideoFrame(frame);
@@ skipping 18 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();
-  CreateTrack("123", constraints);
+  blink::WebMediaStreamTrack track = 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();
-  CreateTrack("123", constraints);
+  blink::WebMediaStreamTrack track1 = CreateTrack("123", constraints);
   mock_source()->CompleteGetSupportedFormats();
   mock_source()->StartMockedSource();
   EXPECT_EQ(1, NumberOfSuccessConstraintsCallbacks());
-  CreateTrack("123", constraints);
+  blink::WebMediaStreamTrack track2 = CreateTrack("123", constraints);
   EXPECT_EQ(2, NumberOfSuccessConstraintsCallbacks());
 }
 
 TEST_F(MediaStreamVideoSourceTest, AddTrackAndFailToStartSource) {
   blink::WebMediaConstraints constraints;
   constraints.initialize();
-  CreateTrack("123", constraints);
+  blink::WebMediaStreamTrack track = CreateTrack("123", constraints);
   mock_source()->CompleteGetSupportedFormats();
   mock_source()->FailToStartMockedSource();
   EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks());
 }
 
 TEST_F(MediaStreamVideoSourceTest, AddTwoTracksBeforeGetSupportedFormats) {
   blink::WebMediaConstraints constraints;
   constraints.initialize();
-  CreateTrack("123", constraints);
-  CreateTrack("123", constraints);
+  blink::WebMediaStreamTrack track1 = CreateTrack("123", constraints);
+  blink::WebMediaStreamTrack track2 = 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) {
   MockMediaConstraintFactory factory;
   factory.AddMandatory(MediaStreamVideoSource::kMaxWidth, 352);
@@ skipping 28 matching lines @@
   factory.AddOptional(MediaStreamVideoSource::kMinWidth, 1280);
 
   CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 640, 480, 30);
 }
 
 // Test that AddTrack fail if the mandatory aspect ratio
 // is set higher than supported.
 TEST_F(MediaStreamVideoSourceTest, MandatoryAspectRatioTooHigh) {
   MockMediaConstraintFactory factory;
   factory.AddMandatory(MediaStreamVideoSource::kMinAspectRatio, 2);
-  CreateTrack("123", factory.CreateWebMediaConstraints());
+  blink::WebMediaStreamTrack track = CreateTrack(
+      "123", factory.CreateWebMediaConstraints());
   mock_source()->CompleteGetSupportedFormats();
   EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks());
 }
 
 // Test that the source ignores an optional aspect ratio that is higher than
 // supported.
 TEST_F(MediaStreamVideoSourceTest, OptionalAspectRatioTooHigh) {
   MockMediaConstraintFactory factory;
   factory.AddOptional(MediaStreamVideoSource::kMinAspectRatio, 2);
-  CreateTrack("123", factory.CreateWebMediaConstraints());
+  blink::WebMediaStreamTrack track = CreateTrack(
+      "123", factory.CreateWebMediaConstraints());
   mock_source()->CompleteGetSupportedFormats();
 
   const media::VideoCaptureParams& params = mock_source()->start_params();
   double aspect_ratio =
       static_cast<double>(params.requested_format.frame_size.width()) /
       params.requested_format.frame_size.height();
   EXPECT_LT(aspect_ratio, 2);
 }
 
 // Test that the source starts video with the default resolution if the
@@ skipping 11 matching lines @@
   constraints.initialize();
   CreateTrackAndStartSource(constraints,
                             MediaStreamVideoSource::kDefaultWidth,
                             MediaStreamVideoSource::kDefaultHeight,
                             30);
 }
 
 TEST_F(MediaStreamVideoSourceTest, InvalidMandatoryConstraint) {
   MockMediaConstraintFactory factory;
   factory.AddMandatory("weird key", 640);
-  CreateTrack("123", factory.CreateWebMediaConstraints());
+  blink::WebMediaStreamTrack track = CreateTrack(
+      "123", factory.CreateWebMediaConstraints());
   mock_source()->CompleteGetSupportedFormats();
   EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks());
 }
 
 // Test that the source ignores an unknown optional constraint.
 TEST_F(MediaStreamVideoSourceTest, InvalidOptionalConstraint) {
   MockMediaConstraintFactory factory;
   factory.AddOptional("weird key", 640);
 
   CreateTrackAndStartSource(factory.CreateWebMediaConstraints(),
                             MediaStreamVideoSource::kDefaultWidth,
                             MediaStreamVideoSource::kDefaultHeight,
                             30);
 }
 
 // Tests that the source starts video with the max width and height set by
 // constraints for screencast.
 TEST_F(MediaStreamVideoSourceTest, ScreencastResolutionWithConstraint) {
   media::VideoCaptureFormats formats;
       formats.push_back(media::VideoCaptureFormat(
           gfx::Size(480, 270), 30, media::PIXEL_FORMAT_I420));
   mock_source()->SetSupportedFormats(formats);
   MockMediaConstraintFactory factory;
   factory.AddMandatory(MediaStreamVideoSource::kMaxWidth, 480);
   factory.AddMandatory(MediaStreamVideoSource::kMaxHeight, 270);
 
-  CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 480, 270, 30);
+  blink::WebMediaStreamTrack track = CreateTrackAndStartSource(
+      factory.CreateWebMediaConstraints(), 480, 270, 30);
   EXPECT_EQ(480, mock_source()->max_requested_height());
   EXPECT_EQ(270, mock_source()->max_requested_width());
 }
 
 // Test that optional constraints are applied in order.
 TEST_F(MediaStreamVideoSourceTest, OptionalConstraints) {
   MockMediaConstraintFactory factory;
   // Min width of 2056 pixels can not be fulfilled.
   factory.AddOptional(MediaStreamVideoSource::kMinWidth, 2056);
   factory.AddOptional(MediaStreamVideoSource::kMinWidth, 641);
   // Since min width is set to 641 pixels, max width 640 can not be fulfilled.
   factory.AddOptional(MediaStreamVideoSource::kMaxWidth, 640);
   CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 1280, 720, 30);
 }
 
 // Test that the webrtc video adapter can be created and that it received
 // video frames if the source deliver video frames.
 TEST_F(MediaStreamVideoSourceTest, AdapterReceiveVideoFrame) {
   MockMediaConstraintFactory factory;
-  CreateTrackAndStartSource(factory.CreateWebMediaConstraints(),
-                            MediaStreamVideoSource::kDefaultWidth,
-                            MediaStreamVideoSource::kDefaultHeight,
-                            MediaStreamVideoSource::kDefaultFrameRate);
+  blink::WebMediaStreamTrack track = CreateTrackAndStartSource(
+      factory.CreateWebMediaConstraints(),
+      MediaStreamVideoSource::kDefaultWidth,
+      MediaStreamVideoSource::kDefaultHeight,
+      MediaStreamVideoSource::kDefaultFrameRate);
   ASSERT_TRUE(mock_source()->GetAdapter());
   MockVideoSource* adapter = static_cast<MockVideoSource*>(
       mock_source()->GetAdapter());
   EXPECT_EQ(0, adapter->GetFrameNum());
 
   scoped_refptr<media::VideoFrame> frame =
       media::VideoFrame::CreateBlackFrame(
           gfx::Size(MediaStreamVideoSource::kDefaultWidth,
                     MediaStreamVideoSource::kDefaultHeight));
    mock_source()->DeliverVideoFrame(frame);
@@ skipping 112 matching lines @@
   EXPECT_TRUE(MediaStreamVideoSource::IsConstraintSupported(
         MediaStreamVideoSource::kMaxHeight));
   EXPECT_TRUE(MediaStreamVideoSource::IsConstraintSupported(
       MediaStreamVideoSource::kMinHeight));
   EXPECT_TRUE(MediaStreamVideoSource::IsConstraintSupported(
         MediaStreamVideoSource::kMaxAspectRatio));
   EXPECT_TRUE(MediaStreamVideoSource::IsConstraintSupported(
       MediaStreamVideoSource::kMinAspectRatio));
 
   EXPECT_FALSE(MediaStreamVideoSource::IsConstraintSupported(
-      "googCpuAdaptation"));
+      "something unsupported"));
 }
 
 }  // namespace content