Switch audio synchronization from sleep() based to select() based.

media/audio/audio_output_device_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 <vector>
 
 #include "base/at_exit.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/process/process_handle.h"
 #include "base/sync_socket.h"
 #include "base/test/test_timeouts.h"
 #include "media/audio/audio_output_device.h"
 #include "media/audio/sample_rates.h"
-#include "media/audio/shared_memory_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gmock_mutant.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::CancelableSyncSocket;
 using base::SharedMemory;
 using base::SyncSocket;
 using testing::_;
 using testing::DoAll;
 using testing::Invoke;
@@ skipping 100 matching lines @@
 
 int AudioOutputDeviceTest::CalculateMemorySize() {
   // Calculate output and input memory size.
   int output_memory_size =
       AudioBus::CalculateMemorySize(default_audio_parameters_);
 
   int frames = default_audio_parameters_.frames_per_buffer();
   int input_memory_size =
       AudioBus::CalculateMemorySize(input_channels_, frames);
 
-  int io_buffer_size = output_memory_size + input_memory_size;
-
-  // This is where it gets a bit hacky.  The shared memory contract between
-  // AudioOutputDevice and its browser side counter part includes a bit more
-  // than just the audio data, so we must call TotalSharedMemorySizeInBytes()
-  // to get the actual size needed to fit the audio data plus the extra data.
-  return TotalSharedMemorySizeInBytes(io_buffer_size);
+  return output_memory_size + input_memory_size;
 }
 
 AudioOutputDeviceTest::AudioOutputDeviceTest()
     : synchronized_io_(GetParam()),
       input_channels_(synchronized_io_ ? 2 : 0) {
   default_audio_parameters_.Reset(
       AudioParameters::AUDIO_PCM_LINEAR,
       CHANNEL_LAYOUT_STEREO, 2, input_channels_,
       48000, 16, 1024);
 
@@ skipping 33 matching lines @@
   // ownership will be transferred and AudioOutputDevice is responsible for
   // freeing.
   SyncSocket::Handle audio_device_socket = SyncSocket::kInvalidHandle;
   ASSERT_TRUE(DuplicateSocketHandle(renderer_socket_.handle(),
                                     &audio_device_socket));
   base::SharedMemoryHandle duplicated_memory_handle;
   ASSERT_TRUE(shared_memory_.ShareToProcess(base::GetCurrentProcessHandle(),
                                             &duplicated_memory_handle));
 
   audio_device_->OnStreamCreated(duplicated_memory_handle, audio_device_socket,
-                                 PacketSizeInBytes(kMemorySize));
+                                 kMemorySize);
   io_loop_.RunUntilIdle();
 }
 
 void AudioOutputDeviceTest::ExpectRenderCallback() {
   // We should get a 'play' notification when we call OnStreamCreated().
   // Respond by asking for some audio data.  This should ask our callback
   // to provide some audio data that AudioOutputDevice then writes into the
   // shared memory section.
   const int kMemorySize = CalculateMemorySize();
 
@@ skipping 76 matching lines @@
   ExpectRenderCallback();
   CreateStream();
   WaitUntilRenderCallback();
   StopAudioDevice();
 }
 
 INSTANTIATE_TEST_CASE_P(Render, AudioOutputDeviceTest, Values(false));
 INSTANTIATE_TEST_CASE_P(RenderIO, AudioOutputDeviceTest, Values(true));
 
 }  // namespace media.