Apply new-style constraints to video_source.

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"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/child/child_process.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_constraint_factory.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 "media/base/limits.h"
 #include "media/base/video_frame.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/web/WebHeap.h"
 
 using ::testing::_;
 using ::testing::DoAll;
 using ::testing::SaveArg;
 
 namespace content {
 
@@ skipping 260 matching lines @@
   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);
-  factory.AddMandatory(MediaStreamVideoSource::kMaxHeight, 288);
-  factory.AddMandatory(MediaStreamVideoSource::kMaxFrameRate, 5);
+  MockConstraintFactory factory;
+  factory.basic().width.setMax(352);
+  factory.basic().height.setMax(288);
+  factory.basic().frameRate.setMax(5.0);
 
   CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 352, 288, 5);
 }
 
 // Test that the capture output is 720P if the camera support it and the
 // optional constraint is set to 720P.
 TEST_F(MediaStreamVideoSourceTest, MandatoryMinVgaOptional720P) {
-  MockMediaConstraintFactory factory;
-  factory.AddMandatory(MediaStreamVideoSource::kMinWidth, 640);
-  factory.AddMandatory(MediaStreamVideoSource::kMinHeight, 480);
-  factory.AddOptional(MediaStreamVideoSource::kMinWidth, 1280);
-  factory.AddOptional(MediaStreamVideoSource::kMinAspectRatio, 1280.0 / 720);
+  MockConstraintFactory factory;
+  factory.basic().width.setMin(640);
+  factory.basic().height.setMin(480);
+  factory.AddAdvanced().width.setMin(1280);
+  factory.AddAdvanced().aspectRatio.setMin(1280.0 / 720);
 
   CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 1280, 720, 30);
 }
 
 // Test that the capture output have aspect ratio 4:3 if a mandatory constraint
 // 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);
+  MockConstraintFactory factory;
+  factory.basic().width.setMin(640);
+  factory.basic().height.setMin(480);
+  factory.basic().aspectRatio.setMax(640.0 / 480);
+  factory.AddAdvanced().width.setMin(1280);
 
   TestSourceCropFrame(1280, 720,
                       factory.CreateWebMediaConstraints(), 960, 720);
 }
 
 // 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);
+  MockConstraintFactory factory;
+  factory.basic().aspectRatio.setMin(2.0);
 
   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);
+  MockConstraintFactory factory;
+  factory.basic().aspectRatio.setMin(2.0);
+  factory.basic().aspectRatio.setMax(1.0);
   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);
+// This test doesn't seem to make sense. An optional constraint
+// should be disregarded even if it's nonsensical.

[mcasas, 2016/01/28 01:57:57]

nit: is this a TODO() or just a comment...?
Note that there is an InvalidOptionalConstraint,
so feel free to remove this test.

[hta - Chromium, 2016/01/28 08:51:40]

I'm making a change in behavior, and I think the old behavior (which is what
this test tested for) was wrong - the comment was intended to elicit comment on
this point :-)

I'll delete the test.

+TEST_F(MediaStreamVideoSourceTest, DISABLED_MaxAspectRatioZero) {
+  MockConstraintFactory factory;
+  factory.AddAdvanced().aspectRatio.setMax(0.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);
+  MockConstraintFactory factory;
+  factory.basic().width.setMin(640);
+  factory.basic().width.setMax(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);
+  MockConstraintFactory factory;
+  factory.basic().height.setMin(480);
+  factory.basic().height.setMax(360);
+
   blink::WebMediaStreamTrack track = CreateTrack(
       "123", factory.CreateWebMediaConstraints());
   mock_source()->CompleteGetSupportedFormats();
   EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks());
 }
 
 TEST_F(MediaStreamVideoSourceTest, MinFrameRateLargerThanMaxFrameRate) {
-  MockMediaConstraintFactory factory;
-  factory.AddMandatory(MediaStreamVideoSource::kMinFrameRate, 25);
-  factory.AddMandatory(MediaStreamVideoSource::kMaxFrameRate, 15);
+  MockConstraintFactory factory;
+  factory.basic().frameRate.setMin(25);
+  factory.basic().frameRate.setMax(15);
   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;
+  MockConstraintFactory 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::kMinWidth, 99999);
+  MockConstraintFactory factory;
+  factory.basic().width.setMin(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
 // supported.
 TEST_F(MediaStreamVideoSourceTest, OptionalAspectRatioTooHigh) {
-  MockMediaConstraintFactory factory;
-  factory.AddOptional(MediaStreamVideoSource::kMinAspectRatio, 2);
+  MockConstraintFactory factory;
+  factory.AddAdvanced().aspectRatio.setMin(2.0);
   blink::WebMediaStreamTrack track = CreateTrack(
       "123", factory.CreateWebMediaConstraints());
   mock_source()->CompleteGetSupportedFormats();
 
   const media::VideoCaptureFormat& format = mock_source()->start_format();
   const double aspect_ratio = static_cast<double>(format.frame_size.width()) /
                               format.frame_size.height();
   EXPECT_LT(aspect_ratio, 2);
 }
 
@@ skipping 10 matching lines @@
 
   blink::WebMediaConstraints constraints;
   constraints.initialize();
   CreateTrackAndStartSource(constraints,
                             MediaStreamVideoSource::kDefaultWidth,
                             MediaStreamVideoSource::kDefaultHeight,
                             30);
 }
 
 TEST_F(MediaStreamVideoSourceTest, InvalidMandatoryConstraint) {
-  MockMediaConstraintFactory factory;
-  factory.AddMandatory("weird key", 640);
+  MockConstraintFactory factory;
+  // Use a constraint that is only known for audio.
+  factory.basic().echoCancellation.setExact(true);
   blink::WebMediaStreamTrack track = CreateTrack(
       "123", factory.CreateWebMediaConstraints());
   mock_source()->CompleteGetSupportedFormats();
   EXPECT_EQ(MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED, error_type());
-  EXPECT_EQ("weird key", error_name());
+  EXPECT_EQ("echoCancellation", error_name());
   EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks());
 }
 
 // Test that the source ignores an unknown optional constraint.
 TEST_F(MediaStreamVideoSourceTest, InvalidOptionalConstraint) {
-  MockMediaConstraintFactory factory;
-  factory.AddOptional("weird key", 640);
+  MockConstraintFactory factory;
+  factory.AddAdvanced().echoCancellation.setExact(true);
 
   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);
+  MockConstraintFactory factory;
+  factory.basic().width.setMax(480);
+  factory.basic().height.setMax(270);
 
   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;
+  MockConstraintFactory factory;
   // Min width of 2056 pixels can not be fulfilled.
-  factory.AddOptional(MediaStreamVideoSource::kMinWidth, 2056);
-  factory.AddOptional(MediaStreamVideoSource::kMinWidth, 641);
+  factory.AddAdvanced().width.setMin(2056);
+  factory.AddAdvanced().width.setMin(641);
   // Since min width is set to 641 pixels, max width 640 can not be fulfilled.
-  factory.AddOptional(MediaStreamVideoSource::kMaxWidth, 640);
+  factory.AddAdvanced().width.setMax(640);
   CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 1280, 720, 30);
 }
 
 // Test that the source crops to the requested max width and
 // height even though the camera delivers a larger frame.
 TEST_F(MediaStreamVideoSourceTest, DeliverCroppedVideoFrameOptional640360) {
-  MockMediaConstraintFactory factory;
-  factory.AddOptional(MediaStreamVideoSource::kMaxWidth, 640);
-  factory.AddOptional(MediaStreamVideoSource::kMaxHeight, 360);
+  MockConstraintFactory factory;
+  factory.AddAdvanced().width.setMax(640);
+  factory.AddAdvanced().height.setMax(360);
   TestSourceCropFrame(640, 480, factory.CreateWebMediaConstraints(), 640, 360);
 }
 
 TEST_F(MediaStreamVideoSourceTest, DeliverCroppedVideoFrameMandatory640360) {
-  MockMediaConstraintFactory factory;
-  factory.AddMandatory(MediaStreamVideoSource::kMaxWidth, 640);
-  factory.AddMandatory(MediaStreamVideoSource::kMaxHeight, 360);
+  MockConstraintFactory factory;
+  factory.basic().width.setMax(640);
+  factory.basic().height.setMax(360);
   TestSourceCropFrame(640, 480, factory.CreateWebMediaConstraints(), 640, 360);
 }
 
 TEST_F(MediaStreamVideoSourceTest, DeliverCroppedVideoFrameMandatory732489) {
-  MockMediaConstraintFactory factory;
-  factory.AddMandatory(MediaStreamVideoSource::kMaxWidth, 732);
-  factory.AddMandatory(MediaStreamVideoSource::kMaxHeight, 489);
-  factory.AddMandatory(MediaStreamVideoSource::kMinWidth, 732);
-  factory.AddMandatory(MediaStreamVideoSource::kMinWidth, 489);
+  MockConstraintFactory factory;
+  factory.basic().width.setMax(732);
+  factory.basic().height.setMax(489);
+  factory.basic().width.setMin(732);
+  factory.basic().height.setMin(489);
   TestSourceCropFrame(1280, 720, factory.CreateWebMediaConstraints(), 732, 489);
 }
 
 // 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);
+  MockConstraintFactory factory;
+  factory.AddAdvanced().width.setMax(637);
+  factory.AddAdvanced().height.setMax(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);
+  MockConstraintFactory factory;
+  factory.basic().width.setMax(320);
+  factory.basic().height.setMax(320);
+  factory.basic().height.setMin(320);
+  factory.basic().width.setMax(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);
+  MockConstraintFactory factory;
+  factory.AddAdvanced().width.setMax(1920);
+  factory.AddAdvanced().height.setMax(1080);
+  factory.AddAdvanced().width.setMin(1280);
+  factory.AddAdvanced().height.setMin(720);
   TestSourceCropFrame(1280, 720, factory.CreateWebMediaConstraints(),
                       1280, 720);
 }
 
 TEST_F(MediaStreamVideoSourceTest, TwoTracksWithVGAAndWVGA) {
-  MockMediaConstraintFactory factory1;
-  factory1.AddOptional(MediaStreamVideoSource::kMaxWidth, 640);
-  factory1.AddOptional(MediaStreamVideoSource::kMaxHeight, 480);
+  MockConstraintFactory factory1;
+  factory1.AddAdvanced().width.setMax(640);
+  factory1.AddAdvanced().height.setMax(480);
 
-  MockMediaConstraintFactory factory2;
-  factory2.AddOptional(MediaStreamVideoSource::kMaxHeight, 360);
+  MockConstraintFactory factory2;
+  factory2.AddAdvanced().height.setMax(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);
+  MockConstraintFactory factory1;
+  factory1.AddAdvanced().width.setMin(1280);
+  factory1.AddAdvanced().height.setMin(720);
 
-
-  MockMediaConstraintFactory factory2;
-  factory2.AddMandatory(MediaStreamVideoSource::kMaxWidth, 640);
-  factory2.AddMandatory(MediaStreamVideoSource::kMaxHeight, 360);
+  MockConstraintFactory factory2;
+  factory2.basic().width.setMax(640);
+  factory2.basic().height.setMax(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);
+  MockConstraintFactory factory1;
+  factory1.AddAdvanced().width.setMin(1280);
+  factory1.AddAdvanced().height.setMin(720);
 
-  MockMediaConstraintFactory factory2;
-  factory2.AddMandatory(MediaStreamVideoSource::kMaxWidth, 700);
-  factory2.AddMandatory(MediaStreamVideoSource::kMaxHeight, 700);
+  MockConstraintFactory factory2;
+  factory2.basic().width.setMax(700);
+  factory2.basic().height.setMax(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);
+  MockConstraintFactory factory1;
+  factory1.AddAdvanced().width.setMin(1280);
+  factory1.AddAdvanced().height.setMin(720);
 
-  MockMediaConstraintFactory factory2;
-  factory2.AddMandatory(MediaStreamVideoSource::kMaxAspectRatio, 640.0 / 480);
+  MockConstraintFactory factory2;
+  factory2.basic().aspectRatio.setMax(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);
+  MockConstraintFactory factory1;
+  factory1.AddAdvanced().width.setMax(640);
+  factory1.AddAdvanced().height.setMax(480);
 
-  MockMediaConstraintFactory factory2;
-  factory2.AddMandatory(MediaStreamVideoSource::kMinAspectRatio, 640.0 / 360);
+  MockConstraintFactory factory2;
+  factory2.basic().aspectRatio.setMin(640.0 / 360);
 
   TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(),
                                         factory2.CreateWebMediaConstraints(),
                                         640, 480,
                                         640, 480,
                                         640, 360);
 }
 
 TEST_F(MediaStreamVideoSourceTest,
        TwoTracksWithSecondTrackFrameRateHigherThanFirst) {
-  MockMediaConstraintFactory factory1;
-  factory1.AddMandatory(MediaStreamVideoSource::kMinFrameRate, 15);
-  factory1.AddMandatory(MediaStreamVideoSource::kMaxFrameRate, 15);
+  MockConstraintFactory factory1;
+  factory1.basic().frameRate.setMin(15);
+  factory1.basic().frameRate.setMax(15);
 
   blink::WebMediaStreamTrack track1 =
       CreateTrackAndStartSource(factory1.CreateWebMediaConstraints(),
                                 MediaStreamVideoSource::kDefaultWidth,
                                 MediaStreamVideoSource::kDefaultHeight,
                                 15);
 
-  MockMediaConstraintFactory factory2;
-  factory2.AddMandatory(MediaStreamVideoSource::kMinFrameRate, 30);
+  MockConstraintFactory factory2;
+  factory2.basic().frameRate.setMin(30);
   blink::WebMediaStreamTrack track2 = CreateTrack(
       "123", factory2.CreateWebMediaConstraints());
   EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks());
 }
 
 // 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);
+  MockConstraintFactory factory;
+  factory.AddAdvanced().width.setMax(800);
+  factory.AddAdvanced().height.setMax(700);
 
   // Expect the source to start capture with the supported resolution.
   blink::WebMediaStreamTrack track =
       CreateTrackAndStartSource(factory.CreateWebMediaConstraints(),
                                 640, 480, 30);
 
   MockMediaStreamVideoSink sink;
   MediaStreamVideoSink::AddToVideoTrack(
       &sink, sink.GetDeliverFrameCB(), track);
   EXPECT_EQ(0, sink.number_of_frames());
@@ skipping 68 matching lines @@
   // Expect the delivered frame to be passed unchanged since its smaller than
   // max requested.
   EXPECT_EQ(320, sink.frame_size().width());
   EXPECT_EQ(240, sink.frame_size().height());
   MediaStreamVideoSink::RemoveFromVideoTrack(&sink, track);
 }
 
 // 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 2000fps in order to test
+  // 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.
   media::VideoCaptureFormats formats;
   formats.push_back(media::VideoCaptureFormat(
-      gfx::Size(640, 480), 2000, media::PIXEL_FORMAT_I420));
+      gfx::Size(640, 480), media::limits::kMaxFramesPerSecond - 1,
+      media::PIXEL_FORMAT_I420));
   SetSourceSupportedFormats(formats);
 
-  MockMediaConstraintFactory factory;
+  MockConstraintFactory factory;
   blink::WebMediaStreamTrack track =
-      CreateTrackAndStartSource(factory.CreateWebMediaConstraints(),
-                                640, 480, 2000);
+      CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 640, 480,
+                                media::limits::kMaxFramesPerSecond - 1);
   MockMediaStreamVideoSink sink;
   MediaStreamVideoSink::AddToVideoTrack(&sink, sink.GetDeliverFrameCB(), track);
   EXPECT_EQ(track.source().readyState(),
             blink::WebMediaStreamSource::ReadyStateLive);
 
   base::RunLoop run_loop;
   base::Closure quit_closure = run_loop.QuitClosure();
   bool muted_state = false;
   EXPECT_CALL(*mock_source(), DoSetMutedState(_))
       .WillOnce(DoAll(SaveArg<0>(&muted_state), RunClosure(quit_closure)));
@@ skipping 11 matching lines @@
   run_loop2.Run();
 
   EXPECT_EQ(muted_state, false);
   EXPECT_EQ(track.source().readyState(),
             blink::WebMediaStreamSource::ReadyStateLive);
 
   MediaStreamVideoSink::RemoveFromVideoTrack(&sink, track);
 }
 
 }  // namespace content