MediaStream audio: Refactor 3 separate "glue" implementations into one.

content/renderer/media/user_media_client_impl_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 "content/renderer/media/user_media_client_impl.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 44 matching lines @@
   UserMediaClientImplUnderTest(
       PeerConnectionDependencyFactory* dependency_factory,
       std::unique_ptr<MediaStreamDispatcher> media_stream_dispatcher)
       : UserMediaClientImpl(NULL,
                             dependency_factory,
                             std::move(media_stream_dispatcher)),
         state_(REQUEST_NOT_STARTED),
         result_(NUM_MEDIA_REQUEST_RESULTS),
         result_name_(""),
         factory_(dependency_factory),
+        create_source_that_fails_(false),
         video_source_(NULL) {}
 
   void RequestUserMedia(const blink::WebUserMediaRequest& user_media_request) {
     state_ = REQUEST_NOT_COMPLETE;
     requestUserMedia(user_media_request);
   }
 
   void RequestUserMedia() {
     blink::WebUserMediaRequest user_media_request;
     RequestUserMedia(user_media_request);
@@ skipping 35 matching lines @@
     last_devices_ = devices;
   }
 
   void EnumerateSourcesSucceded(
       blink::WebMediaStreamTrackSourcesRequest* request,
       blink::WebVector<blink::WebSourceInfo>& sources) override {
     state_ = REQUEST_SUCCEEDED;
     last_sources_ = sources;
   }
 
+  void SetCreateSourceThatFails(bool should_fail) {
+    create_source_that_fails_ = should_fail;
+  }
+
+  MediaStreamAudioSource* CreateAudioSource(
+      const StreamDeviceInfo& device,
+      const blink::WebMediaConstraints& constraints) override {
+    MediaStreamAudioSource* source;
+    if (create_source_that_fails_) {
+      class FailedAtLifeAudioSource : public MediaStreamAudioSource {
+       public:
+        FailedAtLifeAudioSource() : MediaStreamAudioSource(true) {}
+        ~FailedAtLifeAudioSource() override {}
+       protected:
+        bool EnsureSourceIsStarted() override {
+          return false;
+        }
+      };
+      source = new FailedAtLifeAudioSource();
+    } else {
+      source = new MediaStreamAudioSource(true);
+    }
+    source->SetDeviceInfo(device);
+    return source;
+  }
+
   MediaStreamVideoSource* CreateVideoSource(
       const StreamDeviceInfo& device,
       const MediaStreamSource::SourceStoppedCallback& stop_callback) override {
     video_source_ = new MockMediaStreamVideoCapturerSource(device,
                                                            stop_callback,
                                                            factory_);
     return video_source_;
   }
 
   const blink::WebMediaStream& last_generated_stream() {
@@ skipping 33 matching lines @@
   }
 
  private:
   blink::WebMediaStream last_generated_stream_;
   RequestState state_;
   content::MediaStreamRequestResult result_;
   blink::WebString result_name_;
   blink::WebVector<blink::WebMediaDeviceInfo> last_devices_;
   blink::WebVector<blink::WebSourceInfo> last_sources_;
   PeerConnectionDependencyFactory* factory_;
+  bool create_source_that_fails_;
   MockMediaStreamVideoCapturerSource* video_source_;
 };
 
 class UserMediaClientImplTest : public ::testing::Test {
  public:
   void SetUp() override {
     // Create our test object.
     child_process_.reset(new ChildProcess());
     dependency_factory_.reset(new MockPeerConnectionDependencyFactory());
     ms_dispatcher_ = new MockMediaStreamDispatcher();
@@ skipping 72 matching lines @@
   }
 
   void FailToStartMockedVideoSource() {
     MockMediaStreamVideoCapturerSource* video_source =
         used_media_impl_->last_created_video_source();
     if (video_source->SourceHasAttemptedToStart())
       video_source->FailToStartMockedSource();
     blink::WebHeap::collectGarbageForTesting();
   }
 
-  void FailToCreateNextAudioCapturer() {
-    dependency_factory_->FailToCreateNextAudioCapturer();
-    blink::WebHeap::collectGarbageForTesting();
-  }
-
   bool AudioRequestHasAutomaticDeviceSelection(
       const blink::WebMediaConstraints& audio_constraints) {
     blink::WebMediaConstraints null_constraints;
     blink::WebUserMediaRequest request =
         blink::WebUserMediaRequest::createForTesting(audio_constraints,
                                                      null_constraints);
     used_media_impl_->RequestUserMedia(request);
     bool result = used_media_impl_->UserMediaRequestHasAutomaticDeviceSelection(
         ms_dispatcher_->audio_input_request_id());
     used_media_impl_->DeleteRequest(ms_dispatcher_->audio_input_request_id());
@@ skipping 156 matching lines @@
   EXPECT_EQ(MEDIA_DEVICE_TRACK_START_FAILURE,
             used_media_impl_->error_reason());
   blink::WebHeap::collectAllGarbageForTesting();
   EXPECT_EQ(1, ms_dispatcher_->request_stream_counter());
   EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter());
   EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter());
 }
 
 // This test what happens if an audio source fail to initialize.
 TEST_F(UserMediaClientImplTest, MediaAudioSourceFailToInitialize) {
-  FailToCreateNextAudioCapturer();
+  used_media_impl_->SetCreateSourceThatFails(true);
   used_media_impl_->RequestUserMedia();
   FakeMediaStreamDispatcherRequestUserMediaComplete();
   StartMockedVideoSource();
   EXPECT_EQ(UserMediaClientImplUnderTest::REQUEST_FAILED,
             used_media_impl_->request_state());
   EXPECT_EQ(MEDIA_DEVICE_TRACK_START_FAILURE,
             used_media_impl_->error_reason());
   blink::WebHeap::collectAllGarbageForTesting();
   EXPECT_EQ(1, ms_dispatcher_->request_stream_counter());
   EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter());
@@ skipping 201 matching lines @@
   // Now we close the web frame, if in the above Stop() call,
   // UserMediaClientImpl accidentally removed audio track, then video track will
   // be removed again here, which is incorrect.
   used_media_impl_->FrameWillClose();
   blink::WebHeap::collectAllGarbageForTesting();
   EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter());
   EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter());
 }
 
 }  // namespace content