MediaStream audio sourcing: Bypass audio processing for non-WebRTC cases.

content/renderer/media/speech_recognition_audio_sink_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/speech_recognition_audio_sink.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
-#include "content/renderer/media/media_stream_audio_source.h"
+#include "content/renderer/media/media_stream_audio_track.h"
 #include "content/renderer/media/mock_media_constraint_factory.h"
-#include "content/renderer/media/webrtc/webrtc_local_audio_track_adapter.h"
-#include "content/renderer/media/webrtc_local_audio_track.h"
+#include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h"
+#include "content/renderer/media/webrtc/processed_local_audio_source.h"
 #include "media/audio/audio_parameters.h"
 #include "media/base/audio_bus.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/WebKit/public/web/WebHeap.h"
 
 namespace {
 
 // Supported speech recognition audio parameters.
@@ skipping 207 matching lines @@
         media::AudioBus::Create(kInputChannels, input_frames_per_buffer);
     source_bus_->Zero();
     first_frame_capture_time_ = base::TimeTicks::Now();
     sample_frames_captured_ = 0;
 
     // Prepare the track and audio source.
     blink::WebMediaStreamTrack blink_track;
     PrepareBlinkTrackOfType(MEDIA_DEVICE_AUDIO_CAPTURE, &blink_track);
 
     // Get the native track from the blink track and initialize.
-    native_track_ =
-        static_cast<WebRtcLocalAudioTrack*>(blink_track.extraData());
-    native_track_->OnSetFormat(source_params_);
+    native_track_ = MediaStreamAudioTrack::Get(blink_track);
+    native_track_->SetFormat(source_params_);
 
     // Create and initialize the consumer.
     recognizer_.reset(new FakeSpeechRecognizer());
     base::SharedMemoryHandle foreign_memory_handle;
     recognizer_->Initialize(blink_track, sink_params_, &foreign_memory_handle);
 
     // Create the producer.
     scoped_ptr<base::SyncSocket> sending_socket(recognizer_->sending_socket());
     speech_audio_sink_.reset(new SpeechRecognitionAudioSink(
         blink_track, sink_params_, foreign_memory_handle,
         std::move(sending_socket),
         base::Bind(&SpeechRecognitionAudioSinkTest::StoppedCallback,
                    base::Unretained(this))));
 
     // Return number of buffers needed to trigger resampling and consumption.
     return static_cast<uint32_t>(std::ceil(
         static_cast<double>(output_frames_per_buffer * input_sample_rate) /
         (input_frames_per_buffer * output_sample_rate)));
   }
 
   // Mock callback expected to be called when the track is stopped.
   MOCK_METHOD0(StoppedCallback, void());
 
  protected:
   // Prepares a blink track of a given MediaStreamType and attaches the native
   // track which can be used to capture audio data and pass it to the producer.
-  static void PrepareBlinkTrackOfType(
-      const MediaStreamType device_type,
-      blink::WebMediaStreamTrack* blink_track) {
-    StreamDeviceInfo device_info(device_type, "Mock device",
-                                 "mock_device_id");
-    MockMediaConstraintFactory constraint_factory;
-    const blink::WebMediaConstraints constraints =
-        constraint_factory.CreateWebMediaConstraints();
-    scoped_refptr<WebRtcAudioCapturer> capturer(
-        WebRtcAudioCapturer::CreateCapturer(-1, device_info, constraints, NULL,
-                                            NULL));
-    scoped_refptr<WebRtcLocalAudioTrackAdapter> adapter(
-        WebRtcLocalAudioTrackAdapter::Create(std::string(), NULL));
-    scoped_ptr<WebRtcLocalAudioTrack> native_track(
-        new WebRtcLocalAudioTrack(adapter.get(), capturer, NULL));
+  void PrepareBlinkTrackOfType(const MediaStreamType device_type,
+                               blink::WebMediaStreamTrack* blink_track) {
     blink::WebMediaStreamSource blink_audio_source;
     blink_audio_source.initialize(base::UTF8ToUTF16("dummy_source_id"),
                                   blink::WebMediaStreamSource::TypeAudio,
                                   base::UTF8ToUTF16("dummy_source_name"),
                                   false /* remote */, true /* readonly */);
-    MediaStreamSource::SourceStoppedCallback cb;
-    blink_audio_source.setExtraData(
-        new MediaStreamAudioSource(-1, device_info, cb, NULL));
+    ProcessedLocalAudioSource* const audio_source =
+        new ProcessedLocalAudioSource(
+            -1 /* consumer_render_frame_id is N/A for non-browser tests */,
+            StreamDeviceInfo(device_type, "Mock device", "mock_device_id"),
+            &mock_dependency_factory_);
+    audio_source->SetAllowInvalidRenderFrameIdForTesting(true);
+    audio_source->SetSourceConstraints(
+        MockMediaConstraintFactory().CreateWebMediaConstraints());
+    blink_audio_source.setExtraData(audio_source);  // Takes ownership.
+
     blink_track->initialize(blink::WebString::fromUTF8("dummy_track"),
                             blink_audio_source);
-    blink_track->setExtraData(native_track.release());
+    ASSERT_TRUE(audio_source->ConnectToTrack(*blink_track));
   }
 
   // Emulates an audio capture device capturing data from the source.
   inline void CaptureAudio(const uint32_t buffers) {
     for (uint32_t i = 0; i < buffers; ++i) {
       const base::TimeTicks estimated_capture_time = first_frame_capture_time_ +
           (sample_frames_captured_ * base::TimeDelta::FromSeconds(1) /
                source_params_.sample_rate());
-      native_track()->Capture(*source_bus_, estimated_capture_time, false);
+      native_track()->DeliverDataToSinks(*source_bus_, estimated_capture_time);
       sample_frames_captured_ += source_bus_->frames();
     }
   }
 
   // Used to simulate a problem with sockets.
   void SetFailureModeOnForeignSocket(bool in_failure_mode) {
     recognizer()->sending_socket()->SetFailureMode(in_failure_mode);
   }
 
   // Helper method for verifying captured audio data has been consumed.
@@ skipping 33 matching lines @@
           << ")";
     }
   }
 
   media::AudioBus* source_bus() const { return source_bus_.get(); }
 
   FakeSpeechRecognizer* recognizer() const { return recognizer_.get(); }
 
   const media::AudioParameters& sink_params() const { return sink_params_; }
 
-  WebRtcLocalAudioTrack* native_track() const { return native_track_; }
+  MediaStreamAudioTrack* native_track() const { return native_track_; }
 
  private:
+  MockPeerConnectionDependencyFactory mock_dependency_factory_;
+
   // Producer.
   scoped_ptr<SpeechRecognitionAudioSink> speech_audio_sink_;
 
   // Consumer.
   scoped_ptr<FakeSpeechRecognizer> recognizer_;
 
   // Audio related members.
   scoped_ptr<media::AudioBus> source_bus_;
   media::AudioParameters source_params_;
   media::AudioParameters sink_params_;
-  WebRtcLocalAudioTrack* native_track_;
+  MediaStreamAudioTrack* native_track_;
 
   base::TimeTicks first_frame_capture_time_;
   int64_t sample_frames_captured_;
 
   DISALLOW_COPY_AND_ASSIGN(SpeechRecognitionAudioSinkTest);
 };
 
 // Not all types of tracks are supported. This test checks if that policy is
 // implemented correctly.
 TEST_F(SpeechRecognitionAudioSinkTest, CheckIsSupportedAudioTrack) {
@@ skipping 141 matching lines @@
   const uint32_t buffers_per_notification = Initialize(44100, 441, 16000, 1600);
   AssertConsumedBuffers(0U);
   CaptureAudioAndAssertConsumedBuffers(buffers_per_notification, 1U);
   EXPECT_CALL(*this, StoppedCallback()).Times(1);
 
   native_track()->Stop();
   CaptureAudioAndAssertConsumedBuffers(buffers_per_notification, 1U);
 }
 
 }  // namespace content