Turn audio ducking on by default on Windows again.

media/audio/win/core_audio_util_win_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 "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/win/scoped_co_mem.h"
 #include "base/win/scoped_com_initializer.h"
 #include "base/win/scoped_handle.h"
@@ skipping 328 matching lines @@
   client = CoreAudioUtil::CreateDefaultClient(eRender, eConsole);
   EXPECT_TRUE(client);
 
   WAVEFORMATPCMEX format;
   EXPECT_TRUE(SUCCEEDED(CoreAudioUtil::GetSharedModeMixFormat(client,
                                                               &format)));
 
   // Perform a shared-mode initialization without event-driven buffer handling.
   uint32 endpoint_buffer_size = 0;
   HRESULT hr = CoreAudioUtil::SharedModeInitialize(client, &format, NULL,
-                                                   &endpoint_buffer_size);
+                                                   &endpoint_buffer_size, NULL);
   EXPECT_TRUE(SUCCEEDED(hr));
   EXPECT_GT(endpoint_buffer_size, 0u);
 
   // It is only possible to create a client once.
   hr = CoreAudioUtil::SharedModeInitialize(client, &format, NULL,
-                                           &endpoint_buffer_size);
+                                           &endpoint_buffer_size, NULL);
   EXPECT_FALSE(SUCCEEDED(hr));
   EXPECT_EQ(hr, AUDCLNT_E_ALREADY_INITIALIZED);
 
   // Verify that it is possible to reinitialize the client after releasing it.
   client = CoreAudioUtil::CreateDefaultClient(eRender, eConsole);
   EXPECT_TRUE(client);
   hr = CoreAudioUtil::SharedModeInitialize(client, &format, NULL,
-                                           &endpoint_buffer_size);
+                                           &endpoint_buffer_size, NULL);
   EXPECT_TRUE(SUCCEEDED(hr));
   EXPECT_GT(endpoint_buffer_size, 0u);
 
   // Use a non-supported format and verify that initialization fails.
   // A simple way to emulate an invalid format is to use the shared-mode
   // mixing format and modify the preferred sample.
   client = CoreAudioUtil::CreateDefaultClient(eRender, eConsole);
   EXPECT_TRUE(client);
   format.Format.nSamplesPerSec = format.Format.nSamplesPerSec + 1;
   EXPECT_FALSE(CoreAudioUtil::IsFormatSupported(
                   client, AUDCLNT_SHAREMODE_SHARED, &format));
   hr = CoreAudioUtil::SharedModeInitialize(client, &format, NULL,
-                                           &endpoint_buffer_size);
+                                           &endpoint_buffer_size, NULL);
   EXPECT_TRUE(FAILED(hr));
   EXPECT_EQ(hr, E_INVALIDARG);
 
   // Finally, perform a shared-mode initialization using event-driven buffer
   // handling. The event handle will be signaled when an audio buffer is ready
   // to be processed by the client (not verified here).
   // The event handle should be in the nonsignaled state.
   base::win::ScopedHandle event_handle(::CreateEvent(NULL, TRUE, FALSE, NULL));
   client = CoreAudioUtil::CreateDefaultClient(eRender, eConsole);
   EXPECT_TRUE(client);
   EXPECT_TRUE(SUCCEEDED(CoreAudioUtil::GetSharedModeMixFormat(client,
                                                               &format)));
   EXPECT_TRUE(CoreAudioUtil::IsFormatSupported(
                   client, AUDCLNT_SHAREMODE_SHARED, &format));
   hr = CoreAudioUtil::SharedModeInitialize(client, &format, event_handle.Get(),
-                                           &endpoint_buffer_size);
+                                           &endpoint_buffer_size, NULL);
   EXPECT_TRUE(SUCCEEDED(hr));
   EXPECT_GT(endpoint_buffer_size, 0u);
 }
 
 TEST_F(CoreAudioUtilWinTest, CreateRenderAndCaptureClients) {
   if (!CanRunAudioTest())
     return;
 
   EDataFlow data[] = {eRender, eCapture};
 
@@ skipping 10 matching lines @@
     EXPECT_TRUE(SUCCEEDED(CoreAudioUtil::GetSharedModeMixFormat(client,
                                                                 &format)));
     if (data[i] == eRender) {
       // It is not possible to create a render client using an unitialized
       // client interface.
       render_client = CoreAudioUtil::CreateRenderClient(client);
       EXPECT_FALSE(render_client);
 
       // Do a proper initialization and verify that it works this time.
       CoreAudioUtil::SharedModeInitialize(client, &format, NULL,
-                                          &endpoint_buffer_size);
+                                          &endpoint_buffer_size, NULL);
       render_client = CoreAudioUtil::CreateRenderClient(client);
       EXPECT_TRUE(render_client);
       EXPECT_GT(endpoint_buffer_size, 0u);
     } else if (data[i] == eCapture) {
       // It is not possible to create a capture client using an unitialized
       // client interface.
       capture_client = CoreAudioUtil::CreateCaptureClient(client);
       EXPECT_FALSE(capture_client);
 
       // Do a proper initialization and verify that it works this time.
       CoreAudioUtil::SharedModeInitialize(client, &format, NULL,
-                                          &endpoint_buffer_size);
+                                          &endpoint_buffer_size, NULL);
       capture_client = CoreAudioUtil::CreateCaptureClient(client);
       EXPECT_TRUE(capture_client);
       EXPECT_GT(endpoint_buffer_size, 0u);
     }
   }
 }
 
 TEST_F(CoreAudioUtilWinTest, FillRenderEndpointBufferWithSilence) {
   if (!CanRunAudioTest())
     return;
 
   // Create default clients using the default mixing format for shared mode.
   ScopedComPtr<IAudioClient> client(
       CoreAudioUtil::CreateDefaultClient(eRender, eConsole));
   EXPECT_TRUE(client);
 
   WAVEFORMATPCMEX format;
   uint32 endpoint_buffer_size = 0;
   EXPECT_TRUE(SUCCEEDED(CoreAudioUtil::GetSharedModeMixFormat(client,
                                                               &format)));
   CoreAudioUtil::SharedModeInitialize(client, &format, NULL,
-                                      &endpoint_buffer_size);
+                                      &endpoint_buffer_size, NULL);
   EXPECT_GT(endpoint_buffer_size, 0u);
 
   ScopedComPtr<IAudioRenderClient> render_client(
       CoreAudioUtil::CreateRenderClient(client));
   EXPECT_TRUE(render_client);
 
   // The endpoint audio buffer should not be filled up by default after being
   // created.
   UINT32 num_queued_frames = 0;
   client->GetCurrentPadding(&num_queued_frames);
@@ skipping 45 matching lines @@
 
 TEST_F(CoreAudioUtilWinTest, GetDefaultOutputDeviceID) {
   if (!CanRunAudioTest())
     return;
 
   std::string default_device_id(CoreAudioUtil::GetDefaultOutputDeviceID());
   EXPECT_FALSE(default_device_id.empty());
 }
 
 }  // namespace media