Turn audio ducking on by default on Windows again.

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/debug/trace_event.h"
@@ skipping 53 matching lines @@
       packet_size_frames_(0),
       packet_size_bytes_(0),
       endpoint_buffer_size_frames_(0),
       device_id_(device_id),
       device_role_(device_role),
       share_mode_(GetShareMode()),
       num_written_frames_(0),
       source_(NULL),
       audio_bus_(AudioBus::Create(params)) {
   DCHECK(manager_);
+
   VLOG(1) << "WASAPIAudioOutputStream::WASAPIAudioOutputStream()";
   VLOG_IF(1, share_mode_ == AUDCLNT_SHAREMODE_EXCLUSIVE)
       << "Core Audio (WASAPI) EXCLUSIVE MODE is enabled.";
 
   // Load the Avrt DLL if not already loaded. Required to support MMCSS.
   bool avrt_init = avrt::Initialize();
   DCHECK(avrt_init) << "Failed to load the avrt.dll";
 
   // Set up the desired render format specified by the client. We use the
   // WAVE_FORMAT_EXTENSIBLE structure to ensure that multiple channel ordering
@@ skipping 29 matching lines @@
   // Create the event which the audio engine will signal each time
   // a buffer becomes ready to be processed by the client.
   audio_samples_render_event_.Set(CreateEvent(NULL, FALSE, FALSE, NULL));
   DCHECK(audio_samples_render_event_.IsValid());
 
   // Create the event which will be set in Stop() when capturing shall stop.
   stop_render_event_.Set(CreateEvent(NULL, FALSE, FALSE, NULL));
   DCHECK(stop_render_event_.IsValid());
 }
 
-WASAPIAudioOutputStream::~WASAPIAudioOutputStream() {}
+WASAPIAudioOutputStream::~WASAPIAudioOutputStream() {
+  DCHECK_EQ(GetCurrentThreadId(), creating_thread_id_);
+}
 
 bool WASAPIAudioOutputStream::Open() {
   VLOG(1) << "WASAPIAudioOutputStream::Open()";
   DCHECK_EQ(GetCurrentThreadId(), creating_thread_id_);
   if (opened_)
     return true;
 
+  DCHECK(!audio_client_);
+  DCHECK(!audio_render_client_);
+
+  // Will be set to true if we ended up opening the default communications
+  // device.
+  bool communications_device = false;
+
   // Create an IAudioClient interface for the default rendering IMMDevice.
   ScopedComPtr<IAudioClient> audio_client;
   if (device_id_.empty() ||
       CoreAudioUtil::DeviceIsDefault(eRender, device_role_, device_id_)) {
     audio_client = CoreAudioUtil::CreateDefaultClient(eRender, device_role_);
+    communications_device = (device_role_ == eCommunications);
   } else {
     ScopedComPtr<IMMDevice> device(CoreAudioUtil::CreateDevice(device_id_));
     DLOG_IF(ERROR, !device) << "Failed to open device: " << device_id_;
     if (device)
       audio_client = CoreAudioUtil::CreateClient(device);
   }
 
   if (!audio_client)
     return false;
 
   // Extra sanity to ensure that the provided device format is still valid.
   if (!CoreAudioUtil::IsFormatSupported(audio_client,
                                         share_mode_,
                                         &format_)) {
     LOG(ERROR) << "Audio parameters are not supported.";
     return false;
   }
 
   HRESULT hr = S_FALSE;
   if (share_mode_ == AUDCLNT_SHAREMODE_SHARED) {
     // Initialize the audio stream between the client and the device in shared
     // mode and using event-driven buffer handling.
     hr = CoreAudioUtil::SharedModeInitialize(
         audio_client, &format_, audio_samples_render_event_.Get(),
-        &endpoint_buffer_size_frames_);
+        &endpoint_buffer_size_frames_,
+        communications_device ? &kCommunicationsSessionId : NULL);
     if (FAILED(hr))
       return false;
 
     // We know from experience that the best possible callback sequence is
     // achieved when the packet size (given by the native device period)
     // is an even divisor of the endpoint buffer size.
     // Examples: 48kHz => 960 % 480, 44.1kHz => 896 % 448 or 882 % 441.
     if (endpoint_buffer_size_frames_ % packet_size_frames_ != 0) {
       LOG(ERROR)
           << "Bailing out due to non-perfect timing.  Buffer size of "
@@ skipping 20 matching lines @@
   }
 
   // Create an IAudioRenderClient client for an initialized IAudioClient.
   // The IAudioRenderClient interface enables us to write output data to
   // a rendering endpoint buffer.
   ScopedComPtr<IAudioRenderClient> audio_render_client =
       CoreAudioUtil::CreateRenderClient(audio_client);
   if (!audio_render_client)
     return false;
 
-   // Store valid COM interfaces.
+  // Store valid COM interfaces.
   audio_client_ = audio_client;
   audio_render_client_ = audio_render_client;
 
   hr = audio_client_->GetService(__uuidof(IAudioClock),
                                  audio_clock_.ReceiveVoid());
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to get IAudioClock service.";
     return false;
   }
 
@@ skipping 396 matching lines @@
 
     // Ensure that we don't quit the main thread loop immediately next
     // time Start() is called.
     ResetEvent(stop_render_event_.Get());
   }
 
   source_ = NULL;
 }
 
 }  // namespace media