Revert of [Chromecast] Process streams with different post-processing.

chromecast/media/cma/backend/alsa/stream_mixer_alsa_unittest.cc

 // Copyright 2015 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 "chromecast/media/cma/backend/alsa/stream_mixer_alsa.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chromecast/media/cma/backend/alsa/mock_alsa_wrapper.h"
-#include "media/audio/audio_device_description.h"
 #include "media/base/audio_bus.h"
 #include "media/base/vector_math.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 
 namespace chromecast {
 namespace media {
 
@@ skipping 91 matching lines @@
 std::unique_ptr<::media::AudioBus> GetTestData(size_t index) {
   CHECK_LT(index, NUM_DATA_SETS);
   int frames = NUM_SAMPLES / kNumChannels;
   auto data = ::media::AudioBus::Create(kNumChannels, frames);
   data->FromInterleaved(kTestData[index], frames, kBytesPerSample);
   return data;
 }
 
 class MockInputQueue : public StreamMixerAlsa::InputQueue {
  public:
-  explicit MockInputQueue(int samples_per_second,
-                          const std::string& device_id =
-                              ::media::AudioDeviceDescription::kDefaultDeviceId)
+  explicit MockInputQueue(int samples_per_second)
       : paused_(true),
         samples_per_second_(samples_per_second),
         max_read_size_(kTestMaxReadSize),
         multiplier_(1.0),
         primary_(true),
-        deleting_(false),
-        device_id_(device_id),
-        filter_group_(nullptr) {
+        deleting_(false) {
     ON_CALL(*this, GetResampledData(_, _)).WillByDefault(
         testing::Invoke(this, &MockInputQueue::DoGetResampledData));
     ON_CALL(*this, VolumeScaleAccumulate(_, _, _, _)).WillByDefault(
         testing::Invoke(this, &MockInputQueue::DoVolumeScaleAccumulate));
     ON_CALL(*this, PrepareToDelete(_)).WillByDefault(
         testing::Invoke(this, &MockInputQueue::DoPrepareToDelete));
   }
   ~MockInputQueue() override {}
 
   bool paused() const { return paused_; }
 
   // StreamMixerAlsa::InputQueue implementation:
   int input_samples_per_second() const override { return samples_per_second_; }
   bool primary() const override { return primary_; }
   bool IsDeleting() const override { return deleting_; }
   MOCK_METHOD1(Initialize,
                void(const MediaPipelineBackendAlsa::RenderingDelay&
                         mixer_rendering_delay));
-  std::string device_id() const override { return device_id_; }
-  void set_filter_group(FilterGroup* group) override { filter_group_ = group; }
-  FilterGroup* filter_group() override { return filter_group_; }
   int MaxReadSize() override { return max_read_size_; }
   MOCK_METHOD2(GetResampledData, void(::media::AudioBus* dest, int frames));
   MOCK_METHOD4(
       VolumeScaleAccumulate,
       void(bool repeat_transition, const float* src, int frames, float* dest));
   MOCK_METHOD0(OnSkipped, void());
   MOCK_METHOD1(AfterWriteFrames,
                void(const MediaPipelineBackendAlsa::RenderingDelay&
                         mixer_rendering_delay));
   MOCK_METHOD1(SignalError, void(StreamMixerAlsaInput::MixerError error));
@@ skipping 43 matching lines @@
     deleting_ = true;
     delete_cb.Run(this);
   }
 
   bool paused_;
   int samples_per_second_;
   int max_read_size_;
   float multiplier_;
   bool primary_;
   bool deleting_;
-  const std::string device_id_;
-  FilterGroup* filter_group_;
-
   std::unique_ptr<::media::AudioBus> data_;
 
   DISALLOW_COPY_AND_ASSIGN(MockInputQueue);
 };
 
 // Given |inputs|, returns mixed audio data according to the mixing method used
 // by the mixer.
 std::unique_ptr<::media::AudioBus> GetMixedAudioData(
     const std::vector<testing::StrictMock<MockInputQueue>*>& inputs) {
   int read_size = std::numeric_limits<int>::max();
@@ skipping 257 matching lines @@
   std::vector<testing::StrictMock<MockInputQueue>*> inputs;
   const int kNumInputs = 2;
   for (int i = 0; i < kNumInputs; ++i) {
     inputs.push_back(
         new testing::StrictMock<MockInputQueue>(kTestSamplesPerSecond));
     inputs.back()->SetPaused(false);
   }
 
   StreamMixerAlsa* mixer = StreamMixerAlsa::Get();
   for (size_t i = 0; i < inputs.size(); ++i) {
-    EXPECT_CALL(*inputs[i], Initialize(_)).Times(1);
-    mixer->AddInput(base::WrapUnique(inputs[i]));
-  }
-
-  // Poll the inputs for data.
-  const int kNumFrames = 32;
-  for (size_t i = 0; i < inputs.size(); ++i) {
-    inputs[i]->SetData(GetTestData(i));
-    EXPECT_CALL(*inputs[i], GetResampledData(_, kNumFrames));
-    EXPECT_CALL(*inputs[i], VolumeScaleAccumulate(_, _, kNumFrames, _))
-        .Times(kNumChannels);
-    EXPECT_CALL(*inputs[i], AfterWriteFrames(_));
-  }
-
-  EXPECT_CALL(*mock_alsa(), PcmWritei(_, _, kNumFrames)).Times(1);
-  mixer->WriteFramesForTest();
-
-  // Mix the inputs manually.
-  auto expected = GetMixedAudioData(inputs);
-
-  // Get the actual stream rendered to ALSA, and compare it against the
-  // expected stream. The stream should match exactly.
-  auto actual = ::media::AudioBus::Create(kNumChannels, kNumFrames);
-  actual->FromInterleaved(&(mock_alsa()->data()[0]), kNumFrames,
-                          kBytesPerSample);
-  CompareAudioData(*expected, *actual);
-}
-
-TEST_F(StreamMixerAlsaTest, TwoUnscaledStreamsWithDifferentIdsMixProperly) {
-  // Create a group of input streams.
-  std::vector<testing::StrictMock<MockInputQueue>*> inputs;
-  inputs.push_back(new testing::StrictMock<MockInputQueue>(
-      kTestSamplesPerSecond,
-      ::media::AudioDeviceDescription::kDefaultDeviceId));
-  inputs.back()->SetPaused(false);
-  inputs.push_back(new testing::StrictMock<MockInputQueue>(
-      kTestSamplesPerSecond,
-      ::media::AudioDeviceDescription::kCommunicationsDeviceId));
-  inputs.back()->SetPaused(false);
-
-  StreamMixerAlsa* mixer = StreamMixerAlsa::Get();
-  for (size_t i = 0; i < inputs.size(); ++i) {
     EXPECT_CALL(*inputs[i], Initialize(_)).Times(1);
     mixer->AddInput(base::WrapUnique(inputs[i]));
   }
 
   // Poll the inputs for data.
   const int kNumFrames = 32;
   for (size_t i = 0; i < inputs.size(); ++i) {
     inputs[i]->SetData(GetTestData(i));
     EXPECT_CALL(*inputs[i], GetResampledData(_, kNumFrames));
     EXPECT_CALL(*inputs[i], VolumeScaleAccumulate(_, _, kNumFrames, _))
@@ skipping 228 matching lines @@
   EXPECT_CALL(*inputs[1], VolumeScaleAccumulate(_, _, _, _)).Times(0);
   EXPECT_CALL(*inputs[1], OnSkipped());
   EXPECT_CALL(*inputs[1], AfterWriteFrames(_));
 
   EXPECT_CALL(*mock_alsa(), PcmWritei(_, _, kNumFrames)).Times(1);
   mixer->WriteFramesForTest();
 }
 
 }  // namespace media
 }  // namespace chromecast