Add CHECKs to find root cause of Windows-only crash.

media/audio/win/waveout_output_win.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 "media/audio/win/waveout_output_win.h"
 
 #include <windows.h>
 #include <mmsystem.h>
 #pragma comment(lib, "winmm.lib")
 
@@ skipping 69 matching lines @@
     UINT device_id)
     : state_(PCMA_BRAND_NEW),
       manager_(manager),
       device_id_(device_id),
       waveout_(NULL),
       callback_(NULL),
       num_buffers_(num_buffers),
       buffer_size_(params.GetPacketSize()),
       volume_(1),
       channels_(params.channels),
-      pending_bytes_(0) {
+      pending_bytes_(0),
+      thread_id_(GetCurrentThreadId()) {
   format_.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
   format_.Format.nChannels = params.channels;
   format_.Format.nSamplesPerSec = params.sample_rate;
   format_.Format.wBitsPerSample = params.bits_per_sample;
   format_.Format.cbSize = sizeof(format_) - sizeof(WAVEFORMATEX);
   // The next are computed from above.
   format_.Format.nBlockAlign = (format_.Format.nChannels *
                                 format_.Format.wBitsPerSample) / 8;
   format_.Format.nAvgBytesPerSec = format_.Format.nBlockAlign *
                                    format_.Format.nSamplesPerSec;
   if (params.channels > kMaxChannelsToMask) {
     format_.dwChannelMask = kChannelsToMask[kMaxChannelsToMask];
   } else {
     format_.dwChannelMask = kChannelsToMask[params.channels];
   }
   format_.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
   format_.Samples.wValidBitsPerSample = params.bits_per_sample;
 }
 
 PCMWaveOutAudioOutputStream::~PCMWaveOutAudioOutputStream() {
   DCHECK(NULL == waveout_);
 }
 
 bool PCMWaveOutAudioOutputStream::Open() {
+  CHECK_EQ(thread_id_, GetCurrentThreadId());
   if (state_ != PCMA_BRAND_NEW)
     return false;
   if (BufferSize() * num_buffers_ > kMaxOpenBufferSize)
     return false;
   if (num_buffers_ < 2 || num_buffers_ > 5)
     return false;
 
   // Create buffer event.
   buffer_event_.Set(::CreateEvent(NULL,    // Security attributes.
                                   FALSE,   // It will auto-reset.
@@ skipping 13 matching lines @@
       CALLBACK_EVENT);
   if (result != MMSYSERR_NOERROR)
     return false;
 
   SetupBuffers();
   state_ = PCMA_READY;
   return true;
 }
 
 void PCMWaveOutAudioOutputStream::SetupBuffers() {
+  CHECK_EQ(thread_id_, GetCurrentThreadId());
   buffers_.reset(new char[BufferSize() * num_buffers_]);
   for (int ix = 0; ix != num_buffers_; ++ix) {
     WAVEHDR* buffer = GetBuffer(ix);
     buffer->lpData = reinterpret_cast<char*>(buffer) + sizeof(WAVEHDR);
     buffer->dwBufferLength = buffer_size_;
     buffer->dwBytesRecorded = 0;
     buffer->dwFlags = WHDR_DONE;
     buffer->dwLoops = 0;
     // Tell windows sound drivers about our buffers. Not documented what
     // this does but we can guess that causes the OS to keep a reference to
     // the memory pages so the driver can use them without worries.
     ::waveOutPrepareHeader(waveout_, buffer, sizeof(WAVEHDR));
   }
 }
 
 void PCMWaveOutAudioOutputStream::FreeBuffers() {
+  CHECK_EQ(thread_id_, GetCurrentThreadId());
   for (int ix = 0; ix != num_buffers_; ++ix) {
     ::waveOutUnprepareHeader(waveout_, GetBuffer(ix), sizeof(WAVEHDR));
   }
   buffers_.reset(NULL);
 }
 
 // Initially we ask the source to fill up all audio buffers. If we don't do
 // this then we would always get the driver callback when it is about to run
 // samples and that would leave too little time to react.
 void PCMWaveOutAudioOutputStream::Start(AudioSourceCallback* callback) {
+  CHECK_EQ(thread_id_, GetCurrentThreadId());
   if (state_ != PCMA_READY)
     return;
   callback_ = callback;
 
   // Start watching for buffer events.
   {
     HANDLE waiting_handle = NULL;
     ::RegisterWaitForSingleObject(&waiting_handle,
                                   buffer_event_.Get(),
                                   &BufferCallback,
                                   this,
                                   INFINITE,
                                   WT_EXECUTEDEFAULT);
     if (!waiting_handle) {
+      volatile DWORD code = GetLastError();
+      CHECK(false);
       HandleError(MMSYSERR_ERROR);
       return;
     }
     waiting_handle_.Set(waiting_handle);
   }
 
   state_ = PCMA_PLAYING;
 
   // Queue the buffers.
   pending_bytes_ = 0;
   for (int ix = 0; ix != num_buffers_; ++ix) {
     WAVEHDR* buffer = GetBuffer(ix);
     // Caller waits for 1st packet to become available, but not for others,
     // so we wait for them here.
     if (ix != 0)
       callback_->WaitTillDataReady();
     QueueNextPacket(buffer);  // Read more data.
     pending_bytes_ += buffer->dwBufferLength;
   }
 
   // From now on |pending_bytes_| would be accessed by callback thread.
   // Most likely waveOutPause() or waveOutRestart() has its own memory barrier,
   // but issuing our own is safer.
   MemoryBarrier();
 
   MMRESULT result = ::waveOutPause(waveout_);
   if (result != MMSYSERR_NOERROR) {
+    CHECK(false);
     HandleError(result);
     return;
   }
 
   // Send the buffers to the audio driver. Note that the device is paused
   // so we avoid entering the callback method while still here.
   for (int ix = 0; ix != num_buffers_; ++ix) {
     result = ::waveOutWrite(waveout_, GetBuffer(ix), sizeof(WAVEHDR));
     if (result != MMSYSERR_NOERROR) {
+      CHECK(false);
       HandleError(result);
       break;
     }
   }
   result = ::waveOutRestart(waveout_);
   if (result != MMSYSERR_NOERROR) {
+    CHECK(false);
     HandleError(result);
     return;
   }
 }
 
 // Stopping is tricky if we want it be fast.
 // For now just do it synchronously and avoid all the complexities.
 // TODO(enal): if we want faster Stop() we can create singleton that keeps track
 //             of all currently playing streams. Then you don't have to wait
 //             till all callbacks are completed. Of course access to singleton
 //             should be under its own lock, and checking the liveness and
 //             acquiring the lock on stream should be done atomically.
 void PCMWaveOutAudioOutputStream::Stop() {
+  CHECK_EQ(thread_id_, GetCurrentThreadId());
   if (state_ != PCMA_PLAYING)
     return;
   state_ = PCMA_STOPPING;
   MemoryBarrier();
 
   // Stop playback.
   MMRESULT res = ::waveOutReset(waveout_);
   if (res != MMSYSERR_NOERROR) {
+    CHECK(false);
     state_ = PCMA_PLAYING;
     HandleError(res);
     return;
   }
 
   // waveOutReset() leaves buffers in the unpredictable state, causing
   // problems if we want to close, release, or reuse them. Fix the states.
   for (int ix = 0; ix != num_buffers_; ++ix) {
     GetBuffer(ix)->dwFlags = WHDR_PREPARED;
   }
 
   // Stop watching for buffer event, wait till all the callbacks are complete.
   // If UnregisterWaitEx() fails we cannot do anything, just continue normal
   // Stop() -- event would never be signalled because we already stopped the
   // stream.
   HANDLE waiting_handle = waiting_handle_.Take();
   if (waiting_handle) {
     BOOL unregister  = UnregisterWaitEx(waiting_handle, INVALID_HANDLE_VALUE);
     if (!unregister) {
+      volatile DWORD code = GetLastError();
+      CHECK(false);
       state_ = PCMA_PLAYING;
       HandleError(MMSYSERR_ERROR);
     }
   }
 
   // Don't use callback after Stop().
   callback_ = NULL;
 
   state_ = PCMA_READY;
 }
 
 // We can Close in any state except that trying to close a stream that is
 // playing Windows generates an error. We cannot propagate it to the source,
 // as callback_ is set to NULL. Just print it and hope somebody somehow
 // will find it...
 void PCMWaveOutAudioOutputStream::Close() {
+  CHECK_EQ(thread_id_, GetCurrentThreadId());
   Stop();  // Just to be sure. No-op if not playing.
   if (waveout_) {
     MMRESULT res = ::waveOutClose(waveout_);
-    // The callback was cleared by the call to Stop(), so there's no point in
-    // calling HandleError at this point.  Also, even though waveOutClose might
-    // fail, we do not want to attempt to close the handle again, so we always
-    // transfer to the closed state and NULL the handle. Moreover, we must
-    // always call ReleaseOutputStream().
-    DLOG_IF(ERROR, res != MMSYSERR_NOERROR) << "waveOutClose() failed";
+    if (res != MMSYSERR_NOERROR) {
+      CHECK(false);
+      HandleError(res);
+    }
+    // Even though waveOutClose might fail, we do not want to attempt to close
+    // the handle again, so we always transfer to the closed state and NULL the
+    // handle. Moreover, we must always call ReleaseOutputStream().
     state_ = PCMA_CLOSED;
     waveout_ = NULL;
     FreeBuffers();
   }
   // Tell the audio manager that we have been released. This can result in
   // the manager destroying us in-place so this needs to be the last thing
   // we do on this function.
   manager_->ReleaseOutputStream(this);
 }
 
 void PCMWaveOutAudioOutputStream::SetVolume(double volume) {
+  CHECK_EQ(thread_id_, GetCurrentThreadId());
   if (!waveout_)
     return;
   volume_ = static_cast<float>(volume);
 }
 
 void PCMWaveOutAudioOutputStream::GetVolume(double* volume) {
+  CHECK_EQ(thread_id_, GetCurrentThreadId());
   if (!waveout_)
     return;
   *volume = volume_;
 }
 
 void PCMWaveOutAudioOutputStream::HandleError(MMRESULT error) {
+  CHECK_EQ(thread_id_, GetCurrentThreadId());
   DLOG(WARNING) << "PCMWaveOutAudio error " << error;
   if (callback_)
     callback_->OnError(this, error);
 }
 
 void PCMWaveOutAudioOutputStream::QueueNextPacket(WAVEHDR *buffer) {
   // Call the source which will fill our buffer with pleasant sounds and
   // return to us how many bytes were used.
   // If we are down sampling to a smaller number of channels, we need to
   // scale up the amount of pending bytes.
@@ skipping 62 matching lines @@
       // the same buffers we can get away without calling waveOutPrepareHeader.
       MMRESULT result = ::waveOutWrite(stream->waveout_,
                                        buffer,
                                        sizeof(WAVEHDR));
       if (result != MMSYSERR_NOERROR)
         stream->HandleError(result);
       stream->pending_bytes_ += buffer->dwBufferLength;
     }
   }
 }