Change the way audio mixer gets "pending bytes" (amount of data currently buffered

media/audio/audio_output_proxy_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 <string>
 
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/threading/platform_thread.h"
 #include "media/audio/audio_output_dispatcher_impl.h"
 #include "media/audio/audio_output_mixer.h"
 #include "media/audio/audio_output_proxy.h"
 #include "media/audio/audio_manager.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
+using ::testing::AllOf;
+using ::testing::Field;
 using ::testing::Mock;
 using ::testing::Return;
 using media::AudioBuffersState;
 using media::AudioInputStream;
 using media::AudioManager;
 using media::AudioOutputDispatcher;
 using media::AudioOutputProxy;
 using media::AudioOutputStream;
 using media::AudioParameters;
 
@@ skipping 399 matching lines @@
   proxy1->Start(&callback_);
   proxy2->Start(&callback_);
   proxy1->Stop();
   proxy2->Stop();
 
   proxy1->Close();
   proxy2->Close();
 }
 
 // Two streams, both are playing. Still have to use single device.
+// Also verifies that every proxy stream gets its own pending_bytes.
 TEST_F(AudioOutputProxyTest, TwoStreams_BothPlaying_Mixer) {
   MockAudioOutputStream stream;
 
   InitDispatcher(base::TimeDelta::FromMilliseconds(kTestCloseDelayMs));
 
   EXPECT_CALL(manager(), MakeAudioOutputStream(_))
       .WillOnce(Return(&stream));
 
   EXPECT_CALL(stream, Open())
       .WillOnce(Return(true));
   EXPECT_CALL(stream, Start(_))
       .Times(1);
   EXPECT_CALL(stream, SetVolume(_))
       .Times(1);
   EXPECT_CALL(stream, Stop())
       .Times(1);
   EXPECT_CALL(stream, Close())
       .Times(1);
 
   AudioOutputProxy* proxy1 = new AudioOutputProxy(mixer_);
   AudioOutputProxy* proxy2 = new AudioOutputProxy(mixer_);
   EXPECT_TRUE(proxy1->Open());
   EXPECT_TRUE(proxy2->Open());
 
   proxy1->Start(&callback_);
+  uint8 buf1[4] = {0};
+  EXPECT_CALL(callback_,
+      OnMoreData(_, 4,
+                 AllOf(Field(&AudioBuffersState::pending_bytes, 0),
+                       Field(&AudioBuffersState::hardware_delay_bytes, 0))))
+      .WillOnce(Return(4));
+  mixer_->OnMoreData(buf1, sizeof(buf1), AudioBuffersState(0, 0));
   proxy2->Start(&callback_);
+  uint8 buf2[4] = {0};
+  EXPECT_CALL(callback_,
+      OnMoreData(_, 4,
+                 AllOf(Field(&AudioBuffersState::pending_bytes, 4),
+                       Field(&AudioBuffersState::hardware_delay_bytes, 0))))
+      .WillOnce(Return(4));
+  EXPECT_CALL(callback_,
+      OnMoreData(_, 4,
+                 AllOf(Field(&AudioBuffersState::pending_bytes, 0),
+                       Field(&AudioBuffersState::hardware_delay_bytes, 0))))
+      .WillOnce(Return(4));
+  mixer_->OnMoreData(buf2, sizeof(buf2), AudioBuffersState(4, 0));
   proxy1->Stop();
   proxy2->Stop();
 
   proxy1->Close();
   proxy2->Close();
   WaitForCloseTimer(kTestCloseDelayMs);
 }
 
 TEST_F(AudioOutputProxyTest, OpenFailed) {
   OpenFailed(dispatcher_impl_);
@@ skipping 77 matching lines @@
 
   proxy2->Start(&callback_);
 
   Mock::VerifyAndClear(&callback_);
 
   proxy2->Close();
   WaitForCloseTimer(kTestCloseDelayMs);
 }
 
 }  // namespace media