// 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 "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

using media::AudioOutputStream;
using media::AudioParameters;
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());
};

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));

  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);
  }

  media::AudioOutputStream* SimulateAddInput(
      const media::AudioParameters& params) {
    static AudioOutputStream* const kNonNullPointer =
        reinterpret_cast<AudioOutputStream*>(0x11111110);
    return kNonNullPointer;
  }

  int query_count() const {
    return query_count_;
  }

 private:
  const int render_process_id_;
  const int render_frame_id_;
  int query_count_;
};

}  // namespace

class AudioMirroringManagerTest : public testing::Test {
 public:
  typedef AudioMirroringManager::Diverter Diverter;
  typedef AudioMirroringManager::MirroringDestination MirroringDestination;
  typedef AudioMirroringManager::StreamRoutes StreamRoutes;

  AudioMirroringManagerTest()
      : io_thread_(BrowserThread::IO, &message_loop_),
        params_(AudioParameters::AUDIO_FAKE, media::CHANNEL_LAYOUT_STEREO,
                AudioParameters::kAudioCDSampleRate, 16,
                AudioParameters::kAudioCDSampleRate / 10) {}

  MockDiverter* CreateStream(
      int render_process_id, int render_frame_id, int expected_times_diverted) {
    MockDiverter* const diverter = new MockDiverter();
    if (expected_times_diverted > 0) {
      EXPECT_CALL(*diverter, GetAudioParameters())
          .Times(expected_times_diverted)
          .WillRepeatedly(ReturnRef(params_));
      EXPECT_CALL(*diverter, StartDiverting(NotNull()))
          .Times(expected_times_diverted);
      EXPECT_CALL(*diverter, StopDiverting())
          .Times(expected_times_diverted);
    }

    mirroring_manager_.AddDiverter(
        render_process_id, render_frame_id, diverter);

    return diverter;
  }

  void KillStream(MockDiverter* diverter) {
    mirroring_manager_.RemoveDiverter(diverter);
    delete diverter;
  }

  void StartMirroringTo(const scoped_ptr<MockMirroringDestination>& dest,
                        int expected_inputs_added) {
    EXPECT_CALL(*dest, QueryForMatches(_, _))
        .WillRepeatedly(Invoke(dest.get(),
                               &MockMirroringDestination::SimulateQuery));
    if (expected_inputs_added > 0) {
      EXPECT_CALL(*dest, AddInput(Ref(params_)))
          .Times(expected_inputs_added)
          .WillRepeatedly(Invoke(dest.get(),
                                 &MockMirroringDestination::SimulateAddInput))
          .RetiresOnSaturation();
    }

    mirroring_manager_.StartMirroring(dest.get());
  }

  void StopMirroringTo(const scoped_ptr<MockMirroringDestination>& dest) {
    mirroring_manager_.StopMirroring(dest.get());
  }

  int CountStreamsDivertedTo(
      const scoped_ptr<MockMirroringDestination>& dest) const {
    int count = 0;
    for (StreamRoutes::const_iterator it = mirroring_manager_.routes_.begin();
         it != mirroring_manager_.routes_.end(); ++it) {
      if (it->destination == dest.get())
        ++count;
    }
    return count;
  }

  void ExpectNoLongerManagingAnything() const {
    EXPECT_TRUE(mirroring_manager_.routes_.empty());
    EXPECT_TRUE(mirroring_manager_.sessions_.empty());
  }

 private:
  base::MessageLoopForIO message_loop_;
  BrowserThreadImpl io_thread_;
  AudioParameters params_;
  AudioMirroringManager mirroring_manager_;

  DISALLOW_COPY_AND_ASSIGN(AudioMirroringManagerTest);
};

namespace {
const int kRenderProcessId = 123;
const int kRenderFrameId = 456;
const int kAnotherRenderProcessId = 789;
const int kAnotherRenderFrameId = 1234;
const int kYetAnotherRenderProcessId = 4560;
const int kYetAnotherRenderFrameId = 7890;
}

TEST_F(AudioMirroringManagerTest, MirroringSessionOfNothing) {
  const scoped_ptr<MockMirroringDestination> destination(
      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
  StartMirroringTo(destination, 0);
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));

  StopMirroringTo(destination);
  EXPECT_EQ(0, destination->query_count());

  ExpectNoLongerManagingAnything();
}

TEST_F(AudioMirroringManagerTest, TwoMirroringSessionsOfNothing) {
  const scoped_ptr<MockMirroringDestination> destination(
      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
  StartMirroringTo(destination, 0);
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));

  StopMirroringTo(destination);
  EXPECT_EQ(0, destination->query_count());

  const scoped_ptr<MockMirroringDestination> another_destination(
      new MockMirroringDestination(kAnotherRenderProcessId,
                                   kAnotherRenderFrameId));
  StartMirroringTo(another_destination, 0);
  EXPECT_EQ(0, CountStreamsDivertedTo(another_destination));

  StopMirroringTo(another_destination);
  EXPECT_EQ(0, another_destination->query_count());

  ExpectNoLongerManagingAnything();
}

// Tests that a mirroring session starts after, and ends before, a stream that
// will be diverted to it.
TEST_F(AudioMirroringManagerTest, StreamLifetimeAroundMirroringSession) {
  MockDiverter* const stream =
      CreateStream(kRenderProcessId, kRenderFrameId, 1);
  const scoped_ptr<MockMirroringDestination> destination(
      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
  StartMirroringTo(destination, 1);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(1, CountStreamsDivertedTo(destination));

  StopMirroringTo(destination);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));

  KillStream(stream);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));

  ExpectNoLongerManagingAnything();
}

// Tests that a mirroring session starts before, and ends after, a stream that
// will be diverted to it.
TEST_F(AudioMirroringManagerTest, StreamLifetimeWithinMirroringSession) {
  const scoped_ptr<MockMirroringDestination> destination(
      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
  StartMirroringTo(destination, 1);
  EXPECT_EQ(0, destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));

  MockDiverter* const stream =
      CreateStream(kRenderProcessId, kRenderFrameId, 1);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(1, CountStreamsDivertedTo(destination));

  KillStream(stream);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));

  StopMirroringTo(destination);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));

  ExpectNoLongerManagingAnything();
}

// Tests that a stream is diverted correctly as two mirroring sessions come and
// go.
TEST_F(AudioMirroringManagerTest, StreamLifetimeAcrossTwoMirroringSessions) {
  MockDiverter* const stream =
      CreateStream(kRenderProcessId, kRenderFrameId, 2);

  const scoped_ptr<MockMirroringDestination> destination(
      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
  StartMirroringTo(destination, 1);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(1, CountStreamsDivertedTo(destination));

  StopMirroringTo(destination);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));

  const scoped_ptr<MockMirroringDestination> second_destination(
      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
  StartMirroringTo(second_destination, 1);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
  EXPECT_EQ(1, second_destination->query_count());
  EXPECT_EQ(1, CountStreamsDivertedTo(second_destination));

  StopMirroringTo(second_destination);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
  EXPECT_EQ(1, second_destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(second_destination));

  KillStream(stream);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
  EXPECT_EQ(1, second_destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(second_destination));

  ExpectNoLongerManagingAnything();
}

// Tests that a stream does not flip-flop between two destinations that are a
// match for it.
TEST_F(AudioMirroringManagerTest, StreamDivertingStickyToOneDestination_1) {
  MockDiverter* const stream =
      CreateStream(kRenderProcessId, kRenderFrameId, 2);

  const scoped_ptr<MockMirroringDestination> destination(
      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
  StartMirroringTo(destination, 1);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(1, CountStreamsDivertedTo(destination));

  const scoped_ptr<MockMirroringDestination> replacement_destination(
      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
  StartMirroringTo(replacement_destination, 1);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(1, CountStreamsDivertedTo(destination));
  EXPECT_EQ(0, replacement_destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(replacement_destination));

  StopMirroringTo(destination);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
  EXPECT_EQ(1, replacement_destination->query_count());
  EXPECT_EQ(1, CountStreamsDivertedTo(replacement_destination));

  StopMirroringTo(replacement_destination);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
  EXPECT_EQ(1, replacement_destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(replacement_destination));

  KillStream(stream);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
  EXPECT_EQ(1, replacement_destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(replacement_destination));

  ExpectNoLongerManagingAnything();
}

// Same as StreamDivertingStickyToOneDestination_1, with a different order of
// operations that should have the same effects.
TEST_F(AudioMirroringManagerTest, StreamDivertingStickyToOneDestination_2) {
  MockDiverter* const stream =
      CreateStream(kRenderProcessId, kRenderFrameId, 2);

  const scoped_ptr<MockMirroringDestination> destination(
      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
  StartMirroringTo(destination, 1);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(1, CountStreamsDivertedTo(destination));

  const scoped_ptr<MockMirroringDestination> replacement_destination(
      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
  StartMirroringTo(replacement_destination, 1);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(1, CountStreamsDivertedTo(destination));
  EXPECT_EQ(0, replacement_destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(replacement_destination));

  StopMirroringTo(destination);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
  EXPECT_EQ(1, replacement_destination->query_count());
  EXPECT_EQ(1, CountStreamsDivertedTo(replacement_destination));

  KillStream(stream);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
  EXPECT_EQ(1, replacement_destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(replacement_destination));

  StopMirroringTo(replacement_destination);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
  EXPECT_EQ(1, replacement_destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(replacement_destination));

  ExpectNoLongerManagingAnything();
}

// Same as StreamDivertingStickyToOneDestination_1, except that the stream is
// killed before the first destination is stopped.  Therefore, the second
// destination should never see the stream.
TEST_F(AudioMirroringManagerTest, StreamDivertingStickyToOneDestination_3) {
  MockDiverter* const stream =
      CreateStream(kRenderProcessId, kRenderFrameId, 1);

  const scoped_ptr<MockMirroringDestination> destination(
      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
  StartMirroringTo(destination, 1);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(1, CountStreamsDivertedTo(destination));

  const scoped_ptr<MockMirroringDestination> replacement_destination(
      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
  StartMirroringTo(replacement_destination, 0);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(1, CountStreamsDivertedTo(destination));
  EXPECT_EQ(0, replacement_destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(replacement_destination));

  KillStream(stream);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
  EXPECT_EQ(0, replacement_destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(replacement_destination));

  StopMirroringTo(destination);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
  EXPECT_EQ(0, replacement_destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(replacement_destination));

  StopMirroringTo(replacement_destination);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
  EXPECT_EQ(0, replacement_destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(replacement_destination));

  ExpectNoLongerManagingAnything();
}

// Tests that multiple streams are diverted/mixed to one destination.
TEST_F(AudioMirroringManagerTest, MultipleStreamsInOneMirroringSession) {
  MockDiverter* const stream1 =
      CreateStream(kRenderProcessId, kRenderFrameId, 1);

  const scoped_ptr<MockMirroringDestination> destination(
      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
  StartMirroringTo(destination, 3);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(1, CountStreamsDivertedTo(destination));

  MockDiverter* const stream2 =
      CreateStream(kRenderProcessId, kRenderFrameId, 1);
  EXPECT_EQ(2, destination->query_count());
  EXPECT_EQ(2, CountStreamsDivertedTo(destination));

  MockDiverter* const stream3 =
      CreateStream(kRenderProcessId, kRenderFrameId, 1);
  EXPECT_EQ(3, destination->query_count());
  EXPECT_EQ(3, CountStreamsDivertedTo(destination));

  KillStream(stream2);
  EXPECT_EQ(3, destination->query_count());
  EXPECT_EQ(2, CountStreamsDivertedTo(destination));

  StopMirroringTo(destination);
  EXPECT_EQ(3, destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));

  KillStream(stream3);
  EXPECT_EQ(3, destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));

  KillStream(stream1);
  EXPECT_EQ(3, destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));

  ExpectNoLongerManagingAnything();
}

// A random interleaving of operations for three separate targets, each of which
// has one stream mirrored to one destination.
TEST_F(AudioMirroringManagerTest, ThreeSeparateMirroringSessions) {
  MockDiverter* const stream =
      CreateStream(kRenderProcessId, kRenderFrameId, 1);

  const scoped_ptr<MockMirroringDestination> destination(
      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
  StartMirroringTo(destination, 1);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(1, CountStreamsDivertedTo(destination));

  const scoped_ptr<MockMirroringDestination> another_destination(
      new MockMirroringDestination(kAnotherRenderProcessId,
                                   kAnotherRenderFrameId));
  StartMirroringTo(another_destination, 1);
  EXPECT_EQ(1, destination->query_count());
  EXPECT_EQ(1, CountStreamsDivertedTo(destination));
  EXPECT_EQ(0, another_destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(another_destination));

  MockDiverter* const another_stream =
      CreateStream(kAnotherRenderProcessId, kAnotherRenderFrameId, 1);
  EXPECT_EQ(2, destination->query_count());
  EXPECT_EQ(1, CountStreamsDivertedTo(destination));
  EXPECT_EQ(1, another_destination->query_count());
  EXPECT_EQ(1, CountStreamsDivertedTo(another_destination));

  KillStream(stream);
  EXPECT_EQ(2, destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
  EXPECT_EQ(1, another_destination->query_count());
  EXPECT_EQ(1, CountStreamsDivertedTo(another_destination));

  MockDiverter* const yet_another_stream =
      CreateStream(kYetAnotherRenderProcessId, kYetAnotherRenderFrameId, 1);
  EXPECT_EQ(3, destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
  EXPECT_EQ(2, another_destination->query_count());
  EXPECT_EQ(1, CountStreamsDivertedTo(another_destination));

  const scoped_ptr<MockMirroringDestination> yet_another_destination(
      new MockMirroringDestination(kYetAnotherRenderProcessId,
                                   kYetAnotherRenderFrameId));
  StartMirroringTo(yet_another_destination, 1);
  EXPECT_EQ(3, destination->query_count());
  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
  EXPECT_EQ(2, another_destination->query_count());
  EXPECT_EQ(1, CountStreamsDivertedTo(another_destination));
  EXPECT_EQ(1, yet_another_destination->query_count());
  EXPECT_EQ(1, CountStreamsDivertedTo(yet_another_destination));

  StopMirroringTo(another_destination);
  EXPECT_EQ(4, destination->query_count());
  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(1, CountStreamsDivertedTo(yet_another_destination));

  StopMirroringTo(yet_another_destination);
  EXPECT_EQ(5, destination->query_count());
  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));

  StopMirroringTo(destination);
  EXPECT_EQ(5, destination->query_count());
  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));

  KillStream(another_stream);
  EXPECT_EQ(5, destination->query_count());
  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));

  KillStream(yet_another_stream);
  EXPECT_EQ(5, destination->query_count());
  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