Unmute Tab Audio For Desktop Share

content/browser/media/capture/audio_mirroring_manager_unittest.cc

 // Copyright (c) 2013 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/browser/media/capture/audio_mirroring_manager.h"
 
 #include <map>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "content/browser/browser_thread_impl.h"
 #include "media/audio/audio_parameters.h"
+#include "media/audio/virtual_audio_sink.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using media::AudioOutputStream;
 using media::AudioParameters;
+using media::AudioPushSink;
 using testing::_;
 using testing::Invoke;
 using testing::NotNull;
 using testing::Ref;
 using testing::Return;
 using testing::ReturnRef;
 
 namespace content {
 
 namespace {
 
 class MockDiverter : public AudioMirroringManager::Diverter {
  public:
   MOCK_METHOD0(GetAudioParameters, const AudioParameters&());
   MOCK_METHOD1(StartDiverting, void(AudioOutputStream*));
   MOCK_METHOD0(StopDiverting, void());
+  MOCK_METHOD1(StartDuplicating, void(AudioPushSink*));
+  MOCK_METHOD1(StopDuplicating, void(AudioPushSink*));
 };
 
 class MockMirroringDestination
     : public AudioMirroringManager::MirroringDestination {
  public:
   typedef AudioMirroringManager::SourceFrameRef SourceFrameRef;
 
   MockMirroringDestination(int render_process_id, int render_frame_id)
       : render_process_id_(render_process_id),
         render_frame_id_(render_frame_id),
         query_count_(0) {}
 
   MOCK_METHOD2(QueryForMatches,
                void(const std::set<SourceFrameRef>& candidates,
                     const MatchesCallback& results_callback));
   MOCK_METHOD1(AddInput,
                media::AudioOutputStream*(const media::AudioParameters& params));
 
+  MOCK_METHOD1(AddPushInput,
+               media::AudioPushSink*(const media::AudioParameters& params));
+
+  bool IsDuplication() override { return false; }
+
   void SimulateQuery(const std::set<SourceFrameRef>& candidates,
                      const MatchesCallback& results_callback) {
     ++query_count_;
 
     std::set<SourceFrameRef> result;
     if (candidates.find(SourceFrameRef(render_process_id_, render_frame_id_)) !=
             candidates.end()) {
       result.insert(SourceFrameRef(render_process_id_, render_frame_id_));
     }
     results_callback.Run(result);
@@ skipping 480 matching lines @@
   EXPECT_EQ(0, CountStreamsDivertedTo(destination));
   EXPECT_EQ(2, another_destination->query_count());
   EXPECT_EQ(0, CountStreamsDivertedTo(another_destination));
   EXPECT_EQ(2, yet_another_destination->query_count());
   EXPECT_EQ(0, CountStreamsDivertedTo(yet_another_destination));
 
   ExpectNoLongerManagingAnything();
 }
 
 }  // namespace content