Turn audio ducking on by default on Windows again.

media/audio/win/core_audio_util_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/core_audio_util_win.h"
 
 #include <audioclient.h>
 #include <devicetopology.h>
 #include <functiondiscoverykeys_devpkey.h>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/scoped_co_mem.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/scoped_propvariant.h"
 #include "base/win/windows_version.h"
 #include "media/base/media_switches.h"
 
 using base::win::ScopedCoMem;
 using base::win::ScopedHandle;
 
 namespace media {
 
+// See header file for documentation.
+// {BE39AF4F-087C-423F-9303-234EC1E5B8EE}
+const GUID kCommunicationsSessionId = {
+  0xbe39af4f, 0x87c, 0x423f, { 0x93, 0x3, 0x23, 0x4e, 0xc1, 0xe5, 0xb8, 0xee }
+};
+
 enum { KSAUDIO_SPEAKER_UNSUPPORTED = 0 };
 
 // Converts Microsoft's channel configuration to ChannelLayout.
 // This mapping is not perfect but the best we can do given the current
 // ChannelLayout enumerator and the Windows-specific speaker configurations
 // defined in ksmedia.h. Don't assume that the channel ordering in
 // ChannelLayout is exactly the same as the Windows specific configuration.
 // As an example: KSAUDIO_SPEAKER_7POINT1_SURROUND is mapped to
 // CHANNEL_LAYOUT_7_1 but the positions of Back L, Back R and Side L, Side R
 // speakers are different in these two definitions.
@@ skipping 692 matching lines @@
   if (!client || FAILED(GetSharedModeMixFormat(client, &format)))
     return 0;
 
   return static_cast<ChannelConfig>(format.dwChannelMask);
 }
 
 HRESULT CoreAudioUtil::SharedModeInitialize(IAudioClient* client,
                                             const WAVEFORMATPCMEX* format,
                                             HANDLE event_handle,
                                             uint32* endpoint_buffer_size) {
+  return SharedModeInitializeWithSession(
+      client, format, event_handle, endpoint_buffer_size, NULL);
+}
+
+HRESULT CoreAudioUtil::SharedModeInitializeWithSession(
+    IAudioClient* client, const WAVEFORMATPCMEX* format, HANDLE event_handle,
+    uint32* endpoint_buffer_size, const GUID* session_guid) {
   DCHECK(IsSupported());
 
   // Use default flags (i.e, dont set AUDCLNT_STREAMFLAGS_NOPERSIST) to
   // ensure that the volume level and muting state for a rendering session
   // are persistent across system restarts. The volume level and muting
   // state for a capture session are never persistent.
   DWORD stream_flags = 0;
 
   // Enable event-driven streaming if a valid event handle is provided.
   // After the stream starts, the audio engine will signal the event handle
   // to notify the client each time a buffer becomes ready to process.
   // Event-driven buffering is supported for both rendering and capturing.
   // Both shared-mode and exclusive-mode streams can use event-driven buffering.
   bool use_event = (event_handle != NULL &&
                     event_handle != INVALID_HANDLE_VALUE);
   if (use_event)
     stream_flags |= AUDCLNT_STREAMFLAGS_EVENTCALLBACK;
   DVLOG(2) << "stream_flags: 0x" << std::hex << stream_flags;
 
   // Initialize the shared mode client for minimal delay.
   HRESULT hr = client->Initialize(AUDCLNT_SHAREMODE_SHARED,
                                   stream_flags,
                                   0,
                                   0,
                                   reinterpret_cast<const WAVEFORMATEX*>(format),
-                                  NULL);
+                                  session_guid);
   if (FAILED(hr)) {
     DVLOG(1) << "IAudioClient::Initialize: " << std::hex << hr;
     return hr;
   }
 
   if (use_event) {
     hr = client->SetEventHandle(event_handle);
     if (FAILED(hr)) {
       DVLOG(1) << "IAudioClient::SetEventHandle: " << std::hex << hr;
       return hr;
@@ skipping 68 matching lines @@
     return false;
 
   // Using the AUDCLNT_BUFFERFLAGS_SILENT flag eliminates the need to
   // explicitly write silence data to the rendering buffer.
   DVLOG(2) << "filling up " << num_frames_to_fill << " frames with silence";
   return SUCCEEDED(render_client->ReleaseBuffer(num_frames_to_fill,
                                                 AUDCLNT_BUFFERFLAGS_SILENT));
 }
 
 }  // namespace media