Remove old-style constraints from Chrome internals

content/renderer/media/media_stream_video_capturer_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 "content/renderer/media/media_stream_video_capturer_source.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/child/child_process.h"
 #include "content/public/renderer/media_stream_video_sink.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 "media/base/bind_to_current_loop.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/web/WebHeap.h"
 
 using ::testing::_;
 using ::testing::InSequence;
 using ::testing::Invoke;
 using ::testing::WithArgs;
 
@@ skipping 54 matching lines @@
 
     webkit_source_.initialize(base::UTF8ToUTF16("dummy_source_id"),
                               blink::WebMediaStreamSource::TypeVideo,
                               base::UTF8ToUTF16("dummy_source_name"),
                               false /* remote */,
                               true /* readonly */);
     webkit_source_.setExtraData(source_);
     webkit_source_id_ = webkit_source_.id();
   }
 
-  MockMediaConstraintFactory* constraint_factory() {
-    return &constraint_factory_;
-  }
+  MockConstraintFactory* constraint_factory() { return &constraint_factory_; }
 
   blink::WebMediaStreamTrack StartSource() {
     bool enabled = true;
     // CreateVideoTrack will trigger OnConstraintsApplied.
     return MediaStreamVideoTrack::CreateVideoTrack(
         source_, constraint_factory_.CreateWebMediaConstraints(),
         base::Bind(&MediaStreamVideoCapturerSourceTest::OnConstraintsApplied,
                    base::Unretained(this)),
         enabled);
   }
@@ skipping 18 matching lines @@
   // A ChildProcess and a MessageLoopForUI are both needed to fool the Tracks
   // and Sources below into believing they are on the right threads.
   base::MessageLoopForUI message_loop_;
   scoped_ptr<ChildProcess> child_process_;
 
   blink::WebMediaStreamSource webkit_source_;
   MediaStreamVideoCapturerSource* source_;  // owned by |webkit_source_|.
   MockVideoCapturerSource* delegate_;     // owned by |source|.
   blink::WebString webkit_source_id_;
   bool source_stopped_;
-  MockMediaConstraintFactory constraint_factory_;
+  MockConstraintFactory constraint_factory_;
 };
 
 TEST_F(MediaStreamVideoCapturerSourceTest, TabCaptureFixedResolutionByDefault) {
   StreamDeviceInfo device_info;
   device_info.device.type = MEDIA_TAB_VIDEO_CAPTURE;
   InitWithDeviceInfo(device_info);
 
   // No constraints are being provided to the implementation, so expect only
   // default values.
   media::VideoCaptureParams expected_params;
@@ skipping 40 matching lines @@
   EXPECT_CALL(mock_delegate(), StopCapture());
 }
 
 TEST_F(MediaStreamVideoCapturerSourceTest,
        TabCaptureConstraintsImplyFixedAspectRatio) {
   StreamDeviceInfo device_info;
   device_info.device.type = MEDIA_TAB_VIDEO_CAPTURE;
   InitWithDeviceInfo(device_info);
 
   // Specify max and min size constraints that have the same ~16:9 aspect ratio.
-  constraint_factory()->AddMandatory(MediaStreamVideoSource::kMaxWidth, 1920);
-  constraint_factory()->AddMandatory(MediaStreamVideoSource::kMaxHeight, 1080);
-  constraint_factory()->AddMandatory(MediaStreamVideoSource::kMinWidth, 854);
-  constraint_factory()->AddMandatory(MediaStreamVideoSource::kMinHeight, 480);
-  constraint_factory()->AddMandatory(MediaStreamVideoSource::kMaxFrameRate,
-                                     60.0);
+  constraint_factory()->basic().width.setMax(1920);
+  constraint_factory()->basic().height.setMax(1080);
+  constraint_factory()->basic().width.setMin(854);
+  constraint_factory()->basic().height.setMin(480);
+  constraint_factory()->basic().frameRate.setMax(60.0);
 
   media::VideoCaptureParams expected_params;
   expected_params.requested_format.frame_size.SetSize(1920, 1080);
   expected_params.requested_format.frame_rate = 60.0;
   expected_params.requested_format.pixel_format = media::PIXEL_FORMAT_I420;
   expected_params.resolution_change_policy =
       media::RESOLUTION_POLICY_FIXED_ASPECT_RATIO;
 
   InSequence s;
   EXPECT_CALL(mock_delegate(), GetCurrentSupportedFormats(_, _, _, _));
   EXPECT_CALL(
       mock_delegate(),
       StartCapture(
           testing::Field(&media::VideoCaptureParams::resolution_change_policy,
                          media::RESOLUTION_POLICY_FIXED_ASPECT_RATIO),
           _, _));
   blink::WebMediaStreamTrack track = StartSource();
   // When the track goes out of scope, the source will be stopped.
   EXPECT_CALL(mock_delegate(), StopCapture());
 }
 
 TEST_F(MediaStreamVideoCapturerSourceTest,
        TabCaptureConstraintsImplyAllowingAnyResolutionChange) {
   StreamDeviceInfo device_info;
   device_info.device.type = MEDIA_TAB_VIDEO_CAPTURE;
   InitWithDeviceInfo(device_info);
 
   // Specify max and min size constraints with different aspect ratios.
-  constraint_factory()->AddMandatory(MediaStreamVideoSource::kMaxWidth, 1920);
-  constraint_factory()->AddMandatory(MediaStreamVideoSource::kMaxHeight, 1080);
-  constraint_factory()->AddMandatory(MediaStreamVideoSource::kMinWidth, 0);
-  constraint_factory()->AddMandatory(MediaStreamVideoSource::kMinHeight, 0);
-  constraint_factory()->AddMandatory(MediaStreamVideoSource::kMaxFrameRate,
-                                     60.0);
+  constraint_factory()->basic().width.setMax(1920);
+  constraint_factory()->basic().height.setMax(1080);
+  constraint_factory()->basic().width.setMin(0);
+  constraint_factory()->basic().height.setMin(0);
+  constraint_factory()->basic().frameRate.setMax(60.0);
 
   media::VideoCaptureParams expected_params;
   expected_params.requested_format.frame_size.SetSize(1920, 1080);
   expected_params.requested_format.frame_rate = 60.0;
   expected_params.requested_format.pixel_format = media::PIXEL_FORMAT_I420;
   expected_params.resolution_change_policy =
       media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT;
 
   InSequence s;
   EXPECT_CALL(mock_delegate(), GetCurrentSupportedFormats(_, _, _, _));
   EXPECT_CALL(
       mock_delegate(),
       StartCapture(
           testing::Field(&media::VideoCaptureParams::resolution_change_policy,
                          media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT),
           _, _));
   blink::WebMediaStreamTrack track = StartSource();
   // When the track goes out of scope, the source will be stopped.
   EXPECT_CALL(mock_delegate(), StopCapture());
 }
 
 TEST_F(MediaStreamVideoCapturerSourceTest,
        DeviceCaptureConstraintsSupportPowerLineFrequency) {
   for (int frequency = -100; frequency < 100; ++frequency) {
     StreamDeviceInfo device_info;
     device_info.device.type = MEDIA_DEVICE_VIDEO_CAPTURE;
     InitWithDeviceInfo(device_info);
-    constraint_factory_ = MockMediaConstraintFactory();
+    constraint_factory_.Reset();
 
-    constraint_factory()->AddOptional(GetPowerLineFrequencyForTesting(),
-                                      frequency);
+    constraint_factory()->AddAdvanced().googPowerLineFrequency.setExact(
+        frequency);
 
     media::VideoCaptureParams expected_params;
     expected_params.requested_format.frame_size.SetSize(
         MediaStreamVideoSource::kDefaultWidth,
         MediaStreamVideoSource::kDefaultHeight);
     expected_params.requested_format.frame_rate =
         MediaStreamVideoSource::kDefaultFrameRate;
     expected_params.requested_format.pixel_format = media::PIXEL_FORMAT_I420;
     expected_params.resolution_change_policy =
         media::RESOLUTION_POLICY_FIXED_RESOLUTION;
@@ skipping 10 matching lines @@
 
     InSequence s;
     EXPECT_CALL(mock_delegate(), GetCurrentSupportedFormats(_, _, _, _));
     EXPECT_CALL(mock_delegate(), StartCapture(expected_params, _, _));
     blink::WebMediaStreamTrack track = StartSource();
     // When the track goes out of scope, the source will be stopped.
     EXPECT_CALL(mock_delegate(), StopCapture());
   }
 }
 
-TEST_F(MediaStreamVideoCapturerSourceTest,
-       InvalidPowerLineFrequencyHandledProperly) {
-  // Test out other varieties of invalid input, like non-numeric strings.
-  StreamDeviceInfo device_info;
-  device_info.device.type = MEDIA_DEVICE_VIDEO_CAPTURE;
-  InitWithDeviceInfo(device_info);
-  constraint_factory_ = MockMediaConstraintFactory();
-
-  constraint_factory()->AddOptional(GetPowerLineFrequencyForTesting(),
-                                    std::string("this is not a frequency"));
-
-  media::VideoCaptureParams expected_params;
-  expected_params.requested_format.frame_size.SetSize(
-      MediaStreamVideoSource::kDefaultWidth,
-      MediaStreamVideoSource::kDefaultHeight);
-  expected_params.requested_format.frame_rate =
-      MediaStreamVideoSource::kDefaultFrameRate;
-  expected_params.requested_format.pixel_format = media::PIXEL_FORMAT_I420;
-  expected_params.resolution_change_policy =
-      media::RESOLUTION_POLICY_FIXED_RESOLUTION;
-  // Invalid frequencies should result in default setting.
-  expected_params.power_line_frequency =
-      media::PowerLineFrequency::FREQUENCY_DEFAULT;
-
-  InSequence s;
-  EXPECT_CALL(mock_delegate(), GetCurrentSupportedFormats(_, _, _, _));
-  EXPECT_CALL(mock_delegate(), StartCapture(expected_params, _, _));
-  blink::WebMediaStreamTrack track = StartSource();
-  // When the track goes out of scope, the source will be stopped.
-  EXPECT_CALL(mock_delegate(), StopCapture());
-}
-
 TEST_F(MediaStreamVideoCapturerSourceTest, Ended) {
   scoped_ptr<MockVideoCapturerSource> delegate(new MockVideoCapturerSource());
   delegate_ = delegate.get();
   source_ = new MediaStreamVideoCapturerSource(
       base::Bind(&MediaStreamVideoCapturerSourceTest::OnSourceStopped,
                  base::Unretained(this)),
       std::move(delegate));
   webkit_source_.initialize(base::UTF8ToUTF16("dummy_source_id"),
                             blink::WebMediaStreamSource::TypeVideo,
                             base::UTF8ToUTF16("dummy_source_name"),
@@ skipping 85 matching lines @@
   run_loop.Run();
   FakeMediaStreamVideoSink::RemoveFromVideoTrack(&fake_sink, track);
   EXPECT_EQ(reference_capture_time, capture_time);
   double metadata_value;
   EXPECT_TRUE(metadata.GetDouble(media::VideoFrameMetadata::FRAME_RATE,
                                  &metadata_value));
   EXPECT_EQ(30.0, metadata_value);
 }
 
 }  // namespace content