Move audio decoding to protocol layer

remoting/client/audio_player_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 "remoting/client/audio_player.h"
 
 #include <stdint.h>
 
 #include <memory>
 
+#include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 const int kAudioSamplesPerFrame = 25;
 const int kAudioSampleBytes = 4;
 const int kAudioFrameBytes = kAudioSamplesPerFrame * kAudioSampleBytes;
 const int kPaddingBytes = 16;
 
@@ skipping 89 matching lines @@
 }
 
 std::unique_ptr<AudioPacket> CreatePacket48000Hz(int samples) {
   return CreatePacketWithSamplingRate(AudioPacket::SAMPLING_RATE_48000,
                                       samples);
 }
 
 TEST_F(AudioPlayerTest, Init) {
   ASSERT_EQ(0, GetNumQueuedPackets());
 
-  audio_->AddAudioPacket(CreatePacket44100Hz(10));
+  audio_->ProcessAudioPacket(CreatePacket44100Hz(10), base::Closure());
   ASSERT_EQ(1, GetNumQueuedPackets());
 }
 
 TEST_F(AudioPlayerTest, MultipleSamples) {
-  audio_->AddAudioPacket(CreatePacket44100Hz(10));
+  audio_->ProcessAudioPacket(CreatePacket44100Hz(10), base::Closure());
   ASSERT_EQ(10, GetNumQueuedSamples());
   ASSERT_EQ(1, GetNumQueuedPackets());
 
-  audio_->AddAudioPacket(CreatePacket44100Hz(20));
+  audio_->ProcessAudioPacket(CreatePacket44100Hz(20), base::Closure());
   ASSERT_EQ(30, GetNumQueuedSamples());
   ASSERT_EQ(2, GetNumQueuedPackets());
 }
 
 TEST_F(AudioPlayerTest, ChangeSampleRate) {
-  audio_->AddAudioPacket(CreatePacket44100Hz(10));
+  audio_->ProcessAudioPacket(CreatePacket44100Hz(10), base::Closure());
   ASSERT_EQ(10, GetNumQueuedSamples());
   ASSERT_EQ(1, GetNumQueuedPackets());
 
   // New packet with different sampling rate causes previous samples to
   // be removed.
-  audio_->AddAudioPacket(CreatePacket48000Hz(20));
+  audio_->ProcessAudioPacket(CreatePacket48000Hz(20), base::Closure());
   ASSERT_EQ(20, GetNumQueuedSamples());
   ASSERT_EQ(1, GetNumQueuedPackets());
 }
 
 TEST_F(AudioPlayerTest, ExceedLatency) {
   // Push about 4 seconds worth of samples.
   for (int i = 0; i < 100; ++i) {
-    audio_->AddAudioPacket(CreatePacket48000Hz(2000));
+    audio_->ProcessAudioPacket(CreatePacket48000Hz(2000), base::Closure());
   }
 
   // Verify that we don't have more than 0.5s.
   EXPECT_LT(GetNumQueuedSamples(), 24000);
 }
 
 // Incoming packets: 100
 // Consume: 25 (w/ 75 remaining, offset 25 into packet)
 TEST_F(AudioPlayerTest, ConsumePartialPacket) {
   int total_samples = 0;
   int bytes_consumed = 0;
 
   // Process 100 samples.
   int packet1_samples = 100;
   total_samples += packet1_samples;
-  audio_->AddAudioPacket(CreatePacket44100Hz(packet1_samples));
+  audio_->ProcessAudioPacket(CreatePacket44100Hz(packet1_samples),
+                             base::Closure());
   ASSERT_EQ(total_samples, GetNumQueuedSamples());
   ASSERT_EQ(1, GetNumQueuedPackets());
   ASSERT_EQ(bytes_consumed, GetBytesConsumed());
 
   // Consume one frame (=25) of samples.
   ConsumeAudioFrame();
   total_samples -= kAudioSamplesPerFrame;
   bytes_consumed += kAudioFrameBytes;
   ASSERT_EQ(total_samples, GetNumQueuedSamples());
   ASSERT_EQ(1, GetNumQueuedPackets());
   ASSERT_EQ(bytes_consumed, GetBytesConsumed());
   CheckAudioFrameBytes(kAudioFrameBytes);
 
   // Remaining samples.
   ASSERT_EQ(75, total_samples);
   ASSERT_EQ(25 * kAudioSampleBytes, bytes_consumed);
 }
 
 // Incoming packets: 20, 70
 // Consume: 25, 25 (w/ 40 remaining, offset 30 into packet)
 TEST_F(AudioPlayerTest, ConsumeAcrossPackets) {
   int total_samples = 0;
   int bytes_consumed = 0;
 
   // Packet 1.
   int packet1_samples = 20;
   total_samples += packet1_samples;
-  audio_->AddAudioPacket(CreatePacket44100Hz(packet1_samples));
+  audio_->ProcessAudioPacket(CreatePacket44100Hz(packet1_samples),
+                             base::Closure());
   ASSERT_EQ(total_samples, GetNumQueuedSamples());
 
   // Packet 2.
   int packet2_samples = 70;
   total_samples += packet2_samples;
-  audio_->AddAudioPacket(CreatePacket44100Hz(packet2_samples));
+  audio_->ProcessAudioPacket(CreatePacket44100Hz(packet2_samples),
+                             base::Closure());
   ASSERT_EQ(total_samples, GetNumQueuedSamples());
   ASSERT_EQ(bytes_consumed, GetBytesConsumed());
 
   // Consume 1st frame of 25 samples.
   // This will consume the entire 1st packet.
   ConsumeAudioFrame();
   total_samples -= kAudioSamplesPerFrame;
   bytes_consumed += kAudioFrameBytes - (packet1_samples * kAudioSampleBytes);
   ASSERT_EQ(total_samples, GetNumQueuedSamples());
   ASSERT_EQ(1, GetNumQueuedPackets());
@@ skipping 16 matching lines @@
 
 // Incoming packets: 50, 30
 // Consume: 25, 25, 25 (w/ 5 remaining, offset 25 into packet)
 TEST_F(AudioPlayerTest, ConsumeEntirePacket) {
   int total_samples = 0;
   int bytes_consumed = 0;
 
   // Packet 1.
   int packet1_samples = 50;
   total_samples += packet1_samples;
-  audio_->AddAudioPacket(CreatePacket44100Hz(packet1_samples));
+  audio_->ProcessAudioPacket(CreatePacket44100Hz(packet1_samples),
+                             base::Closure());
   ASSERT_EQ(total_samples, GetNumQueuedSamples());
   ASSERT_EQ(bytes_consumed, GetBytesConsumed());
 
   // Packet 2.
   int packet2_samples = 30;
   total_samples += packet2_samples;
-  audio_->AddAudioPacket(CreatePacket44100Hz(packet2_samples));
+  audio_->ProcessAudioPacket(CreatePacket44100Hz(packet2_samples),
+                             base::Closure());
   ASSERT_EQ(total_samples, GetNumQueuedSamples());
   ASSERT_EQ(bytes_consumed, GetBytesConsumed());
 
   // Consume 1st frame of 25 samples.
   ConsumeAudioFrame();
   total_samples -= kAudioSamplesPerFrame;
   bytes_consumed += kAudioFrameBytes;
   ASSERT_EQ(total_samples, GetNumQueuedSamples());
   ASSERT_EQ(2, GetNumQueuedPackets());
   ASSERT_EQ(bytes_consumed, GetBytesConsumed());
@@ skipping 38 matching lines @@
 
 // Incoming packets: 10
 // Consume: 25
 TEST_F(AudioPlayerTest, NotEnoughDataToConsume) {
   int total_samples = 0;
   int bytes_consumed = 0;
 
   // Packet 1.
   int packet1_samples = 10;
   total_samples += packet1_samples;
-  audio_->AddAudioPacket(CreatePacket44100Hz(packet1_samples));
+  audio_->ProcessAudioPacket(CreatePacket44100Hz(packet1_samples),
+                             base::Closure());
   ASSERT_EQ(total_samples, GetNumQueuedSamples());
   ASSERT_EQ(bytes_consumed, GetBytesConsumed());
 
   // Attempt to consume a frame of 25 samples.
   ConsumeAudioFrame();
   ASSERT_EQ(0, GetNumQueuedSamples());
   ASSERT_EQ(0, GetNumQueuedPackets());
   ASSERT_EQ(0, GetBytesConsumed());
   CheckAudioFrameBytes(packet1_samples * kAudioSampleBytes);
 }
 
 }  // namespace remoting