Implement ConstraintNotSatisfiedError for getusermedia

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"
@@ skipping 18 matching lines @@
   closure.Run();
 }
 
 class MediaStreamVideoSourceTest
     : public ::testing::Test {
  public:
   MediaStreamVideoSourceTest()
       : child_process_(new ChildProcess()),
         number_of_successful_constraints_applied_(0),
         number_of_failed_constraints_applied_(0),
+        result_(MEDIA_DEVICE_OK),
+        result_name_(""),
         mock_source_(new MockMediaStreamVideoSource(true)) {
     media::VideoCaptureFormats formats;
     formats.push_back(media::VideoCaptureFormat(
         gfx::Size(1280, 720), 30, media::PIXEL_FORMAT_I420));
     formats.push_back(media::VideoCaptureFormat(
         gfx::Size(640, 480), 30, media::PIXEL_FORMAT_I420));
     formats.push_back(media::VideoCaptureFormat(
         gfx::Size(352, 288), 30, media::PIXEL_FORMAT_I420));
     formats.push_back(media::VideoCaptureFormat(
         gfx::Size(320, 240), 30, media::PIXEL_FORMAT_I420));
@@ skipping 40 matching lines @@
   }
 
   int NumberOfSuccessConstraintsCallbacks() const {
     return number_of_successful_constraints_applied_;
   }
 
   int NumberOfFailedConstraintsCallbacks() const {
     return number_of_failed_constraints_applied_;
   }
 
+  content::MediaStreamRequestResult error_type() const { return result_; }
+  blink::WebString error_name() const { return result_name_; }
+
   MockMediaStreamVideoSource* mock_source() { return mock_source_; }
 
   // Test that the source crops/scales to the requested width and
   // height even though the camera delivers a larger frame.
   void TestSourceCropFrame(int capture_width,
                            int capture_height,
                            const blink::WebMediaConstraints& constraints,
                            int expected_width,
                            int expected_height) {
     // Expect the source to start capture with the supported resolution.
@@ skipping 83 matching lines @@
     MediaStreamVideoSink::RemoveFromVideoTrack(&sink1, track1);
     MediaStreamVideoSink::RemoveFromVideoTrack(&sink2, track2);
   }
 
   void ReleaseTrackAndSourceOnAddTrackCallback(
       const blink::WebMediaStreamTrack& track_to_release) {
     track_to_release_ = track_to_release;
   }
 
  private:
-  void OnConstraintsApplied(MediaStreamSource* source, bool success) {
+  void OnConstraintsApplied(MediaStreamSource* source,
+                            MediaStreamRequestResult result,
+                            const blink::WebString& result_name) {
     ASSERT_EQ(source, webkit_source_.extraData());
 
-    if (success)
+    if (result == MEDIA_DEVICE_OK) {
       ++number_of_successful_constraints_applied_;
-    else
+    } else {
+      result_ = result;
+      result_name_ = result_name;
       ++number_of_failed_constraints_applied_;
+    }
 
     if (!track_to_release_.isNull()) {
       mock_source_ = NULL;
       webkit_source_.reset();
       track_to_release_.reset();
     }
   }
   base::MessageLoopForUI message_loop_;
   scoped_ptr<ChildProcess> child_process_;
   blink::WebMediaStreamTrack track_to_release_;
   int number_of_successful_constraints_applied_;
   int number_of_failed_constraints_applied_;
+  content::MediaStreamRequestResult result_;
+  blink::WebString result_name_;
   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);
   mock_source()->CompleteGetSupportedFormats();
@@ skipping 202 matching lines @@
                             MediaStreamVideoSource::kDefaultHeight,
                             30);
 }
 
 TEST_F(MediaStreamVideoSourceTest, InvalidMandatoryConstraint) {
   MockMediaConstraintFactory factory;
   factory.AddMandatory("weird key", 640);
   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(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,
@@ skipping 348 matching lines @@
   // TODO(mcasas): When added, check |track|'s (WebMediaStreamTrack) Muted
   // attribute, should be true. In the meantime, check the MediaStreamTrack's.
   EXPECT_EQ(MediaStreamTrack::GetTrack(track1)->GetMutedState(), true);
   EXPECT_EQ(MediaStreamTrack::GetTrack(track2)->GetMutedState(), true);
 
   MediaStreamVideoSink::RemoveFromVideoTrack(&sink1, track1);
   MediaStreamVideoSink::RemoveFromVideoTrack(&sink2, track2);
 }
 
 }  // namespace content