Revert 141476 - Do not stop audio physical stream immediately after logical one had stopped.

media/audio/win/audio_output_win_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 <windows.h>
 #include <mmsystem.h>
 
 #include "base/basictypes.h"
 #include "base/base_paths.h"
 #include "base/file_util.h"
@@ skipping 58 matching lines @@
 
   void set_error(bool error) {
     had_error_ += error ? 1 : 0;
   }
 
  private:
   int callback_count_;
   int had_error_;
 };
 
-const int kMaxNumBuffers = 3;
+const int kNumBuffers = 3;
 // Specializes TestSourceBasic to detect that the AudioStream is using
 // triple buffering correctly.
 class TestSourceTripleBuffer : public TestSourceBasic {
  public:
   TestSourceTripleBuffer() {
     buffer_address_[0] = NULL;
     buffer_address_[1] = NULL;
     buffer_address_[2] = NULL;
   }
   // Override of TestSourceBasic::OnMoreData.
   virtual uint32 OnMoreData(uint8* dest,
                             uint32 max_size,
                             AudioBuffersState buffers_state) {
     // Call the base, which increments the callback_count_.
     TestSourceBasic::OnMoreData(dest, max_size, buffers_state);
-    if (callback_count() % NumberOfWaveOutBuffers() == 2) {
+    if (callback_count() % kNumBuffers == 2) {
       set_error(!CompareExistingIfNotNULL(2, dest));
-    } else if (callback_count() % NumberOfWaveOutBuffers() == 1) {
+    } else if (callback_count() % kNumBuffers == 1) {
       set_error(!CompareExistingIfNotNULL(1, dest));
     } else {
       set_error(!CompareExistingIfNotNULL(0, dest));
     }
-    if (callback_count() > kMaxNumBuffers) {
+    if (callback_count() > kNumBuffers) {
       set_error(buffer_address_[0] == buffer_address_[1]);
       set_error(buffer_address_[1] == buffer_address_[2]);
     }
     return max_size;
   }
 
  private:
   bool CompareExistingIfNotNULL(uint32 index, void* address) {
     void*& entry = buffer_address_[index];
     if (!entry)
       entry = address;
     return (entry == address);
   }
 
-  void* buffer_address_[kMaxNumBuffers];
+  void* buffer_address_[kNumBuffers];
 };
 
 // Specializes TestSourceBasic to simulate a source that blocks for some time
 // in the OnMoreData callback.
 class TestSourceLaggy : public TestSourceBasic {
  public:
   TestSourceLaggy(int laggy_after_buffer, int lag_in_ms)
       : laggy_after_buffer_(laggy_after_buffer), lag_in_ms_(lag_in_ms) {
   }
   virtual uint32 OnMoreData(uint8* dest,
                             uint32 max_size,
                             AudioBuffersState buffers_state) {
     // Call the base, which increments the callback_count_.
     TestSourceBasic::OnMoreData(dest, max_size, buffers_state);
-    if (callback_count() > kMaxNumBuffers) {
+    if (callback_count() > kNumBuffers) {
       ::Sleep(lag_in_ms_);
     }
     return max_size;
   }
  private:
   int laggy_after_buffer_;
   int lag_in_ms_;
 };
 
 class MockAudioSource : public AudioOutputStream::AudioSourceCallback {
@@ skipping 162 matching lines @@
   }
 
   AudioOutputStream* oas = audio_man->MakeAudioOutputStream(
       AudioParameters(AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_MONO,
                       16000, 16, 256));
   ASSERT_TRUE(NULL != oas);
   TestSourceTripleBuffer test_triple_buffer;
   EXPECT_TRUE(oas->Open());
   oas->Start(&test_triple_buffer);
   ::Sleep(300);
-  EXPECT_GT(test_triple_buffer.callback_count(), kMaxNumBuffers);
+  EXPECT_GT(test_triple_buffer.callback_count(), kNumBuffers);
   EXPECT_FALSE(test_triple_buffer.had_error());
   oas->Stop();
   ::Sleep(500);
   oas->Close();
 }
 
 // Test potential deadlock situation if the source is slow or blocks for some
 // time. The actual EXPECT_GT are mostly meaningless and the real test is that
 // the test completes in reasonable time.
 TEST(WinAudioTest, PCMWaveSlowSource) {
@@ skipping 267 matching lines @@
   AudioOutputStream* oas = audio_man->MakeAudioOutputStream(
       AudioParameters(AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_MONO,
                       AudioParameters::kAudioCDSampleRate, 16, samples_100_ms));
   ASSERT_TRUE(NULL != oas);
 
   NiceMock<MockAudioSource> source;
   EXPECT_TRUE(oas->Open());
 
   uint32 bytes_100_ms = samples_100_ms * 2;
 
-  // Audio output stream has either a double or triple buffer scheme.
-  // We expect the amount of pending bytes will reaching up to 2 times of
-  // |bytes_100_ms| depending on number of buffers used.
+  // We expect the amount of pending bytes will reaching 2 times of
+  // |bytes_100_ms| because the audio output stream has a triple buffer scheme.
   // From that it would decrease as we are playing the data but not providing
   // new one. And then we will try to provide zero data so the amount of
   // pending bytes will go down and eventually read zero.
   InSequence s;
-
   EXPECT_CALL(source, OnMoreData(NotNull(), bytes_100_ms,
                                  Field(&AudioBuffersState::pending_bytes, 0)))
       .WillOnce(Return(bytes_100_ms));
-  switch (NumberOfWaveOutBuffers()) {
-    case 2:
-      break;  // Calls are the same as at end of 3-buffer scheme.
-    case 3:
-      EXPECT_CALL(source, OnMoreData(NotNull(), bytes_100_ms,
-                                     Field(&AudioBuffersState::pending_bytes,
-                                           bytes_100_ms)))
-          .WillOnce(Return(bytes_100_ms));
-      EXPECT_CALL(source, OnMoreData(NotNull(), bytes_100_ms,
-                                     Field(&AudioBuffersState::pending_bytes,
-                                           2 * bytes_100_ms)))
-          .WillOnce(Return(bytes_100_ms));
-      EXPECT_CALL(source, OnMoreData(NotNull(), bytes_100_ms,
-                                     Field(&AudioBuffersState::pending_bytes,
-                                           2 * bytes_100_ms)))
-          .Times(AnyNumber())
-          .WillRepeatedly(Return(0));
-    default:
-      ASSERT_TRUE(false) << "Unexpected number of buffers";
-  }
+  EXPECT_CALL(source, OnMoreData(NotNull(), bytes_100_ms,
+                                 Field(&AudioBuffersState::pending_bytes,
+                                       bytes_100_ms)))
+      .WillOnce(Return(bytes_100_ms));
+  EXPECT_CALL(source, OnMoreData(NotNull(), bytes_100_ms,
+                                 Field(&AudioBuffersState::pending_bytes,
+                                       2 * bytes_100_ms)))
+      .WillOnce(Return(bytes_100_ms));
+  EXPECT_CALL(source, OnMoreData(NotNull(), bytes_100_ms,
+                                 Field(&AudioBuffersState::pending_bytes,
+                                       2 * bytes_100_ms)))
+      .Times(AnyNumber())
+      .WillRepeatedly(Return(0));
   EXPECT_CALL(source, OnMoreData(NotNull(), bytes_100_ms,
                                  Field(&AudioBuffersState::pending_bytes,
                                        bytes_100_ms)))
       .Times(AnyNumber())
       .WillRepeatedly(Return(0));
   EXPECT_CALL(source, OnMoreData(NotNull(), bytes_100_ms,
                                  Field(&AudioBuffersState::pending_bytes, 0)))
       .Times(AnyNumber())
       .WillRepeatedly(Return(0));
 
@@ skipping 107 matching lines @@
   oas->Start(&source);
 
   ::WaitForSingleObject(thread, INFINITE);
   ::CloseHandle(thread);
 
   oas->Stop();
   oas->Close();
 }
 
 }  // namespace media