Don't leak render thread on Stop().

media/audio/win/audio_low_latency_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/audio_low_latency_output_win.h"
 
 #include <Functiondiscoverykeys_devpkey.h>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 311 matching lines @@
     return AUDCLNT_SHAREMODE_EXCLUSIVE;
   return AUDCLNT_SHAREMODE_SHARED;
 }
 
 WASAPIAudioOutputStream::WASAPIAudioOutputStream(AudioManagerWin* manager,
                                                  const AudioParameters& params,
                                                  ERole device_role)
     : com_init_(ScopedCOMInitializer::kMTA),
       creating_thread_id_(base::PlatformThread::CurrentId()),
       manager_(manager),
-      render_thread_(NULL),
       opened_(false),
       started_(false),
       restart_rendering_mode_(false),
       volume_(1.0),
       endpoint_buffer_size_frames_(0),
       device_role_(device_role),
       share_mode_(GetShareMode()),
       client_channel_count_(params.channels()),
       num_written_frames_(0),
       source_(NULL) {
@@ skipping 178 matching lines @@
                                       AUDCLNT_BUFFERFLAGS_SILENT);
   num_written_frames_ = endpoint_buffer_size_frames_;
 
   // Sanity check: verify that the endpoint buffer is filled with silence.
   UINT32 num_queued_frames = 0;
   audio_client_->GetCurrentPadding(&num_queued_frames);
   DCHECK(num_queued_frames == num_written_frames_);
 
   // Create and start the thread that will drive the rendering by waiting for
   // render events.
-  render_thread_ = new base::DelegateSimpleThread(this, "wasapi_render_thread");
+  render_thread_.reset(
+      new base::DelegateSimpleThread(this, "wasapi_render_thread"));
   render_thread_->Start();
   if (!render_thread_->HasBeenStarted()) {
     DLOG(ERROR) << "Failed to start WASAPI render thread.";
     return;
   }
 
   // Start streaming data between the endpoint buffer and the audio engine.
   hr = audio_client_->Start();
   if (FAILED(hr)) {
     SetEvent(stop_render_event_.Get());
     render_thread_->Join();
-    render_thread_ = NULL;
+    render_thread_.reset();
     HandleError(hr);
     return;
   }
 
   started_ = true;
 }
 
 void WASAPIAudioOutputStream::Stop() {
   DCHECK_EQ(GetCurrentThreadId(), creating_thread_id_);
   if (!started_)
     return;
 
   // Shut down the render thread.
   if (stop_render_event_.IsValid()) {
     SetEvent(stop_render_event_.Get());
   }
 
   // Stop output audio streaming.
   HRESULT hr = audio_client_->Stop();
   if (FAILED(hr)) {
     DLOG_IF(ERROR, hr != AUDCLNT_E_NOT_INITIALIZED)
         << "Failed to stop output streaming: " << std::hex << hr;
   }
 
   // Wait until the thread completes and perform cleanup.
-  if (render_thread_) {
+  if (render_thread_.get()) {
     SetEvent(stop_render_event_.Get());
     render_thread_->Join();
-    render_thread_ = NULL;
+    render_thread_.reset();
   }
 
   // Flush all pending data and reset the audio clock stream position to 0.
   hr = audio_client_->Reset();
   if (FAILED(hr)) {
     DLOG_IF(ERROR, hr != AUDCLNT_E_NOT_INITIALIZED)
         << "Failed to reset streaming: " << std::hex << hr;
   }
 
   // Extra safety check to ensure that the buffers are cleared.
@@ skipping 735 matching lines @@
   // are now re-initiated and it is now possible to re-start audio rendering.
 
   // Start rendering again using the new default audio endpoint.
   hr = audio_client_->Start();
 
   restart_rendering_mode_ = false;
   return SUCCEEDED(hr);
 }
 
 }  // namespace media