Add different error codes for getUserMedia.

content/browser/renderer_host/media/media_stream_dispatcher_host_unittest.cc

 // Copyright (c) 2012 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 <queue>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 36 matching lines @@
       const ResourceContext::SaltCallback salt_callback,
       const scoped_refptr<base::MessageLoopProxy>& message_loop,
       MediaStreamManager* manager)
       : MediaStreamDispatcherHost(kProcessId, salt_callback, manager),
         message_loop_(message_loop) {}
 
   // A list of mock methods.
   MOCK_METHOD4(OnStreamGenerated,
                void(int routing_id, int request_id, int audio_array_size,
                     int video_array_size));
-  MOCK_METHOD2(OnStreamGenerationFailed, void(int routing_id, int request_id));
+  MOCK_METHOD3(OnStreamGenerationFailed, void(int routing_id,
+                                              int request_id,
+                                              MediaStreamRequestResult result));
   MOCK_METHOD1(OnDeviceStopped, void(int routing_id));
   MOCK_METHOD2(OnDeviceOpened, void(int routing_id, int request_id));
 
   // Accessor to private functions.
   void OnGenerateStream(int render_view_id,
                         int page_request_id,
                         const StreamOptions& components,
                         const GURL& security_origin,
                         const base::Closure& quit_closure) {
     quit_closures_.push(quit_closure);
@@ skipping 73 matching lines @@
     // Notify that the event have occurred.
     base::Closure quit_closure = quit_closures_.front();
     quit_closures_.pop();
     message_loop_->PostTask(FROM_HERE, base::ResetAndReturn(&quit_closure));
 
     label_ = label;
     audio_devices_ = audio_device_list;
     video_devices_ = video_device_list;
   }
 
-  void OnStreamGenerationFailed(const IPC::Message& msg, int request_id) {
-    OnStreamGenerationFailed(msg.routing_id(), request_id);
+  void OnStreamGenerationFailed(
+      const IPC::Message& msg,
+      int request_id,
+      content::MediaStreamRequestResult result) {
+    OnStreamGenerationFailed(msg.routing_id(), request_id, result);
     if (!quit_closures_.empty()) {
       base::Closure quit_closure = quit_closures_.front();
       quit_closures_.pop();
       message_loop_->PostTask(FROM_HERE, base::ResetAndReturn(&quit_closure));
     }
 
     label_= "";
   }
 
   void OnDeviceStopped(const IPC::Message& msg,
@@ skipping 101 matching lines @@
                                                 expected_video_array_size));
     host_->OnGenerateStream(render_view_id, page_request_id, options, origin_,
                             run_loop.QuitClosure());
     run_loop.Run();
     EXPECT_FALSE(DoesContainRawIds(host_->audio_devices_));
     EXPECT_FALSE(DoesContainRawIds(host_->video_devices_));
     EXPECT_TRUE(DoesEveryDeviceMapToRawId(host_->audio_devices_, origin_));
     EXPECT_TRUE(DoesEveryDeviceMapToRawId(host_->video_devices_, origin_));
   }
 
-  void GenerateStreamAndWaitForFailure(int render_view_id,
-                                       int page_request_id,
-                                       const StreamOptions& options) {
+  void GenerateStreamAndWaitForFailure(
+    int render_view_id,
+    int page_request_id,
+    const StreamOptions& options,
+    MediaStreamRequestResult expected_result) {
       base::RunLoop run_loop;
       EXPECT_CALL(*host_.get(),
-                  OnStreamGenerationFailed(render_view_id, page_request_id));
+                  OnStreamGenerationFailed(render_view_id,
+                                           page_request_id,
+                                           expected_result));
       host_->OnGenerateStream(render_view_id, page_request_id, options, origin_,
                               run_loop.QuitClosure());
       run_loop.Run();
   }
 
   void OpenVideoDeviceAndWaitForResult(int render_view_id,
                                        int page_request_id,
                                        const std::string& device_id) {
     base::RunLoop run_loop;
     host_->OnOpenDevice(render_view_id, page_request_id, device_id,
@@ skipping 102 matching lines @@
   SetupFakeUI(true);
   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
 
   EXPECT_EQ(host_->audio_devices_.size(), 1u);
   EXPECT_EQ(host_->video_devices_.size(), 0u);
 }
 
 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamWithNothing) {
   StreamOptions options(false, false);
 
-  GenerateStreamAndWaitForFailure(kRenderId, kPageRequestId, options);
+  GenerateStreamAndWaitForFailure(
+      kRenderId,
+      kPageRequestId,
+      options,
+      MEDIA_DEVICE_INVALID_STATE);
 }
 
 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamWithAudioAndVideo) {
   StreamOptions options(true, true);
 
   SetupFakeUI(true);
   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
 
   EXPECT_EQ(host_->audio_devices_.size(), 1u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
@@ skipping 191 matching lines @@
     EXPECT_EQ(host_->video_devices_[0].device.id, source_id);
   }
 }
 
 // Test that generating a stream with an invalid mandatory video source id fail.
 TEST_F(MediaStreamDispatcherHostTest,
        GenerateStreamsWithInvalidMandatoryVideoSourceId) {
   StreamOptions options(true, true);
   AddSourceIdConstraint("invalid source id", &options.mandatory_video);
 
-  GenerateStreamAndWaitForFailure(kRenderId, kPageRequestId, options);
+  GenerateStreamAndWaitForFailure(
+      kRenderId,
+      kPageRequestId,
+      options,
+      MEDIA_DEVICE_CAPTURE_FAILURE);
 }
 
 // Test that generating a stream with an invalid mandatory audio source id fail.
 TEST_F(MediaStreamDispatcherHostTest,
        GenerateStreamsWithInvalidMandatoryAudioSourceId) {
   StreamOptions options(true, true);
   AddSourceIdConstraint("invalid source id", &options.mandatory_audio);
 
-  GenerateStreamAndWaitForFailure(kRenderId, kPageRequestId, options);
+  GenerateStreamAndWaitForFailure(
+      kRenderId,
+      kPageRequestId,
+      options,
+      MEDIA_DEVICE_CAPTURE_FAILURE);
 }
 
 // Test that generating a stream with an invalid optional video source id
 // succeed.
 TEST_F(MediaStreamDispatcherHostTest,
        GenerateStreamsWithInvalidOptionalVideoSourceId) {
   StreamOptions options(true, true);
   AddSourceIdConstraint("invalid source id", &options.optional_video);
 
   SetupFakeUI(true);
@@ skipping 190 matching lines @@
   EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
                                    MEDIA_DEVICE_AUDIO_CAPTURE);
 }
 
 TEST_F(MediaStreamDispatcherHostTest, EnumerateVideoDevices) {
   EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
                                    MEDIA_DEVICE_VIDEO_CAPTURE);
 }
 
 };  // namespace content