Remove the Windows Wave audio device implementation.

webrtc/modules/audio_device/test/audio_device_test_api.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 145 matching lines @@
   AudioDeviceAPITest() {}
 
   ~AudioDeviceAPITest() override {}
 
   static void SetUpTestCase() {
     process_thread_ = ProcessThread::Create("ProcessThread");
     process_thread_->Start();
 
     // Windows:
     //      if (WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
-    //          user can select between default (Core) or Wave
-    //      else
-    //          user can select between default (Wave) or Wave
+    //          user can select only the default (Core)
     const int32_t kId = 444;
 
-#if defined(_WIN32)
-    EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kLinuxAlsaAudio)) == NULL);
 #if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
     TEST_LOG("WEBRTC_WINDOWS_CORE_AUDIO_BUILD is defined!\n\n");
     // create default implementation (=Core Audio) instance
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
                 kId, AudioDeviceModule::kPlatformDefaultAudio)) != NULL);
     EXPECT_EQ(0, audio_device_.release()->Release());
-    // create non-default (=Wave Audio) instance
-    EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kWindowsWaveAudio)) != NULL);
-    EXPECT_EQ(0, audio_device_.release()->Release());
     // explicitly specify usage of Core Audio (same as default)
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
                 kId, AudioDeviceModule::kWindowsCoreAudio)) != NULL);
-#else
-    TEST_LOG("WEBRTC_WINDOWS_CORE_AUDIO_BUILD is *not* defined!\n");
-    EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kWindowsCoreAudio)) == NULL);
-    // create default implementation (=Wave Audio) instance
-    EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kPlatformDefaultAudio)) != NULL);
-    EXPECT_EQ(0, audio_device_.release()->Release());
-    // explicitly specify usage of Wave Audio (same as default)
-    EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kWindowsWaveAudio)) != NULL);
-#endif
 #endif
 
 #if defined(ANDROID)
     // Fails tests
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kWindowsWaveAudio)) == NULL);
-    EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
                 kId, AudioDeviceModule::kWindowsCoreAudio)) == NULL);
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
                 kId, AudioDeviceModule::kLinuxAlsaAudio)) == NULL);
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
                 kId, AudioDeviceModule::kLinuxPulseAudio)) == NULL);
     // Create default implementation instance
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
                 kId, AudioDeviceModule::kPlatformDefaultAudio)) != NULL);
 #elif defined(WEBRTC_LINUX)
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kWindowsWaveAudio)) == NULL);
-    EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
                 kId, AudioDeviceModule::kWindowsCoreAudio)) == NULL);
     // create default implementation instance
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
                 kId, AudioDeviceModule::kPlatformDefaultAudio)) != NULL);
     EXPECT_EQ(0, audio_device_->Terminate());
     EXPECT_EQ(0, audio_device_.release()->Release());
     // explicitly specify usage of Pulse Audio (same as default)
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
                 kId, AudioDeviceModule::kLinuxPulseAudio)) != NULL);
 #endif
 
 #if defined(WEBRTC_MAC)
     // Fails tests
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kWindowsWaveAudio)) == NULL);
-    EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
                 kId, AudioDeviceModule::kWindowsCoreAudio)) == NULL);
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
                 kId, AudioDeviceModule::kLinuxAlsaAudio)) == NULL);
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
                 kId, AudioDeviceModule::kLinuxPulseAudio)) == NULL);
     // Create default implementation instance
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
                 kId, AudioDeviceModule::kPlatformDefaultAudio)) != NULL);
 #endif
 
@@ skipping 220 matching lines @@
       AudioDeviceModule::kDefaultDevice) == -1);
 #endif
   for (int i = 0; i < no_devices; i++) {
     EXPECT_EQ(0, audio_device_->SetRecordingDevice(i));
   }
 }
 #endif  // 0
 
 TEST_F(AudioDeviceAPITest, PlayoutIsAvailable) {
   bool available;
-#ifdef _WIN32
+#if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
   EXPECT_TRUE(audio_device_->SetPlayoutDevice(
           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
   EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
   // Availability check should not initialize.
   EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
 
   EXPECT_EQ(0,
             audio_device_->SetPlayoutDevice(AudioDeviceModule::kDefaultDevice));
   EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
   EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
 #endif
 
   int16_t no_devices = audio_device_->PlayoutDevices();
   for (int i = 0; i < no_devices; i++) {
     EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i));
     EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
     EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
   }
 }
 
 TEST_F(AudioDeviceAPITest, RecordingIsAvailable) {
   bool available;
-#ifdef _WIN32
+#if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
   EXPECT_EQ(0, audio_device_->SetRecordingDevice(
       AudioDeviceModule::kDefaultCommunicationDevice));
   EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
   EXPECT_FALSE(audio_device_->RecordingIsInitialized());
 
   EXPECT_EQ(0, audio_device_->SetRecordingDevice(
       AudioDeviceModule::kDefaultDevice));
   EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
   EXPECT_FALSE(audio_device_->RecordingIsInitialized());
 #endif
@@ skipping 108 matching lines @@
 
 TEST_F(AudioDeviceAPITest, StartAndStopPlayout) {
   bool available;
   EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL));
 
   CheckInitialPlayoutStates();
 
   EXPECT_EQ(-1, audio_device_->StartPlayout());
   EXPECT_EQ(0, audio_device_->StopPlayout());
 
-#ifdef _WIN32
+#if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
   // kDefaultCommunicationDevice
   EXPECT_TRUE(audio_device_->SetPlayoutDevice(
           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
   EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
   if (available)
   {
     EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
     EXPECT_EQ(0, audio_device_->InitPlayout());
     EXPECT_EQ(0, audio_device_->StartPlayout());
     EXPECT_TRUE(audio_device_->Playing());
@@ skipping 38 matching lines @@
 
 TEST_F(AudioDeviceAPITest, StartAndStopRecording) {
   bool available;
   EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL));
 
   CheckInitialRecordingStates();
 
   EXPECT_EQ(-1, audio_device_->StartRecording());
   EXPECT_EQ(0, audio_device_->StopRecording());
 
-#ifdef _WIN32
+#if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
   // kDefaultCommunicationDevice
   EXPECT_TRUE(audio_device_->SetRecordingDevice(
           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
   EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
   if (available)
   {
     EXPECT_FALSE(audio_device_->RecordingIsInitialized());
     EXPECT_EQ(0, audio_device_->InitRecording());
     EXPECT_EQ(0, audio_device_->StartRecording());
     EXPECT_TRUE(audio_device_->Recording());
@@ skipping 29 matching lines @@
       EXPECT_EQ(0, audio_device_->StartRecording());
       EXPECT_TRUE(audio_device_->Recording());
       EXPECT_EQ(-1, audio_device_->RegisterAudioCallback(audio_transport_));
       EXPECT_EQ(0, audio_device_->StopRecording());
       EXPECT_FALSE(audio_device_->Recording());
       EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL));
     }
   }
 }
 
-#if defined(_WIN32) && !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
-TEST_F(AudioDeviceAPITest, SetAndGetWaveOutVolume) {
-  uint32_t vol(0);
-  // NOTE 1: Windows Wave only!
-  // NOTE 2: It seems like the waveOutSetVolume API returns
-  // MMSYSERR_NOTSUPPORTED on some Vista machines!
-  const uint16_t maxVol(0xFFFF);
-  uint16_t volL, volR;
-
-  CheckInitialPlayoutStates();
-
-  // make dummy test to see if this API is supported
-  int32_t works = audio_device_->SetWaveOutVolume(vol, vol);
-  WARNING(works == 0);
-
-  if (works == 0)
-  {
-    // set volume without open playout device
-    for (vol = 0; vol <= maxVol; vol += (maxVol/5))
-    {
-      EXPECT_EQ(0, audio_device_->SetWaveOutVolume(vol, vol));
-      EXPECT_EQ(0, audio_device_->WaveOutVolume(volL, volR));
-      EXPECT_TRUE((volL == vol) && (volR == vol));
-    }
-
-    // repeat test but this time with an open (default) output device
-    EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
-        AudioDeviceModule::kDefaultDevice));
-    EXPECT_EQ(0, audio_device_->InitPlayout());
-    EXPECT_TRUE(audio_device_->PlayoutIsInitialized());
-    for (vol = 0; vol <= maxVol; vol += (maxVol/5))
-    {
-      EXPECT_EQ(0, audio_device_->SetWaveOutVolume(vol, vol));
-      EXPECT_EQ(0, audio_device_->WaveOutVolume(volL, volR));
-      EXPECT_TRUE((volL == vol) && (volR == vol));
-    }
-
-    // as above but while playout is active
-    EXPECT_EQ(0, audio_device_->StartPlayout());
-    EXPECT_TRUE(audio_device_->Playing());
-    for (vol = 0; vol <= maxVol; vol += (maxVol/5))
-    {
-      EXPECT_EQ(0, audio_device_->SetWaveOutVolume(vol, vol));
-      EXPECT_EQ(0, audio_device_->WaveOutVolume(volL, volR));
-      EXPECT_TRUE((volL == vol) && (volR == vol));
-    }
-  }
-
-  EXPECT_EQ(0, audio_device_->StopPlayout());
-  EXPECT_FALSE(audio_device_->Playing());
-}
-#endif  // defined(_WIN32) && !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
 
 TEST_F(AudioDeviceAPITest, InitSpeaker) {
   // NOTE: By calling Terminate (in TearDown) followed by Init (in SetUp) we
   // ensure that any existing output mixer handle is set to NULL.
   // The mixer handle is closed and reopened again for each call to
   // SetPlayoutDevice.
   CheckInitialPlayoutStates();
 
   // kDefaultCommunicationDevice
   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
@@ skipping 53 matching lines @@
   for (int i = 0; i < no_devices; i++) {
     EXPECT_EQ(0, audio_device_->SetRecordingDevice(i));
     EXPECT_EQ(0, audio_device_->InitMicrophone());
   }
 }
 
 TEST_F(AudioDeviceAPITest, SpeakerVolumeIsAvailable) {
   CheckInitialPlayoutStates();
   bool available;
 
-#ifdef _WIN32
+#if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
   // check the kDefaultCommunicationDevice
   EXPECT_TRUE(audio_device_->SetPlayoutDevice(
           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
   EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available));
   // check for availability should not lead to initialization
   EXPECT_FALSE(audio_device_->SpeakerIsInitialized());
 #endif
 
   // check the kDefaultDevice
   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE));
@@ skipping 26 matching lines @@
   CheckInitialPlayoutStates();
 
   // fail tests
   EXPECT_EQ(-1, audio_device_->SetSpeakerVolume(0));
   // speaker must be initialized first
   EXPECT_EQ(-1, audio_device_->SpeakerVolume(&volume));
   EXPECT_EQ(-1, audio_device_->MaxSpeakerVolume(&maxVolume));
   EXPECT_EQ(-1, audio_device_->MinSpeakerVolume(&minVolume));
   EXPECT_EQ(-1, audio_device_->SpeakerVolumeStepSize(&stepSize));
 
-#if defined(_WIN32) && !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
-  // test for warning (can e.g. happen on Vista with Wave API)
-  EXPECT_EQ(0,
-            audio_device_->SetPlayoutDevice(AudioDeviceModule::kDefaultDevice));
-  EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available));
-  if (available) {
-    EXPECT_EQ(0, audio_device_->InitSpeaker());
-    EXPECT_EQ(0, audio_device_->SetSpeakerVolume(19001));
-    EXPECT_EQ(0, audio_device_->SpeakerVolume(&volume));
-    WARNING(volume == 19001);
-  }
-#endif
-
-#ifdef _WIN32
+#if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
   // use kDefaultCommunicationDevice and modify/retrieve the volume
   EXPECT_TRUE(audio_device_->SetPlayoutDevice(
           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
   EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available));
   if (available) {
     EXPECT_EQ(0, audio_device_->InitSpeaker());
     EXPECT_EQ(0, audio_device_->MaxSpeakerVolume(&maxVolume));
     EXPECT_EQ(0, audio_device_->MinSpeakerVolume(&minVolume));
     EXPECT_EQ(0, audio_device_->SpeakerVolumeStepSize(&stepSize));
     for (vol = minVolume; vol < (unsigned int)maxVolume; vol += 20*stepSize) {
@@ skipping 63 matching lines @@
   EXPECT_EQ(0, audio_device_->SetAGC(true));
   EXPECT_TRUE(audio_device_->AGC());
   EXPECT_EQ(0, audio_device_->SetAGC(false));
   EXPECT_FALSE(audio_device_->AGC());
 }
 
 TEST_F(AudioDeviceAPITest, MicrophoneVolumeIsAvailable) {
   CheckInitialRecordingStates();
   bool available;
 
-#ifdef _WIN32
+#if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
   // check the kDefaultCommunicationDevice
   EXPECT_TRUE(audio_device_->SetRecordingDevice(
           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
   EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available));
   // check for availability should not lead to initialization
   EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
 #endif
 
   // check the kDefaultDevice
   EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
@@ skipping 32 matching lines @@
   CheckInitialRecordingStates();
 
   // fail tests
   EXPECT_EQ(-1, audio_device_->SetMicrophoneVolume(0));
   // must be initialized first
   EXPECT_EQ(-1, audio_device_->MicrophoneVolume(&volume));
   EXPECT_EQ(-1, audio_device_->MaxMicrophoneVolume(&maxVolume));
   EXPECT_EQ(-1, audio_device_->MinMicrophoneVolume(&minVolume));
   EXPECT_EQ(-1, audio_device_->MicrophoneVolumeStepSize(&stepSize));
 
-#if defined(_WIN32) && !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
-  // test for warning (can e.g. happen on Vista with Wave API)
-  EXPECT_EQ(0, audio_device_->SetRecordingDevice(
-      AudioDeviceModule::kDefaultDevice));
-  EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available));
-  if (available)
-  {
-    EXPECT_EQ(0, audio_device_->InitMicrophone());
-    EXPECT_EQ(0, audio_device_->SetMicrophoneVolume(19001));
-    EXPECT_EQ(0, audio_device_->MicrophoneVolume(&volume));
-    WARNING(volume == 19001);
-  }
-#endif
-
-#ifdef _WIN32
+#if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
   // initialize kDefaultCommunicationDevice and modify/retrieve the volume
   EXPECT_TRUE(audio_device_->SetRecordingDevice(
           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
   EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available));
   if (available)
   {
     EXPECT_EQ(0, audio_device_->InitMicrophone());
     EXPECT_EQ(0, audio_device_->MaxMicrophoneVolume(&maxVolume));
     EXPECT_EQ(0, audio_device_->MinMicrophoneVolume(&minVolume));
     EXPECT_EQ(0, audio_device_->MicrophoneVolumeStepSize(&stepSize));
@@ skipping 45 matching lines @@
   if (available) {
     EXPECT_EQ(0, audio_device_->InitMicrophone());
     EXPECT_EQ(0, audio_device_->MaxMicrophoneVolume(&maxVolume));
     EXPECT_EQ(0, audio_device_->SetMicrophoneVolume(maxVolume/10));
   }
 }
 
 TEST_F(AudioDeviceAPITest, SpeakerMuteIsAvailable) {
   bool available;
   CheckInitialPlayoutStates();
-#ifdef _WIN32
+#if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
   // check the kDefaultCommunicationDevice
   EXPECT_TRUE(audio_device_->SetPlayoutDevice(
           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
   EXPECT_EQ(0, audio_device_->SpeakerMuteIsAvailable(&available));
   // check for availability should not lead to initialization
   EXPECT_FALSE(audio_device_->SpeakerIsInitialized());
 #endif
 
   // check the kDefaultDevice
   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE));
   EXPECT_EQ(0, audio_device_->SpeakerMuteIsAvailable(&available));
   EXPECT_FALSE(audio_device_->SpeakerIsInitialized());
 
   // check all availiable devices
   int16_t no_devices = audio_device_->PlayoutDevices();
   for (int i = 0; i < no_devices; i++) {
     EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i));
     EXPECT_EQ(0, audio_device_->SpeakerMuteIsAvailable(&available));
     EXPECT_FALSE(audio_device_->SpeakerIsInitialized());
   }
 }
 
 TEST_F(AudioDeviceAPITest, MicrophoneMuteIsAvailable) {
   bool available;
   CheckInitialRecordingStates();
-#ifdef _WIN32
+#if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
   // check the kDefaultCommunicationDevice
   EXPECT_TRUE(audio_device_->SetRecordingDevice(
           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
   EXPECT_EQ(0, audio_device_->MicrophoneMuteIsAvailable(&available));
   // check for availability should not lead to initialization
 #endif
   EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
 
   // check the kDefaultDevice
   EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
   EXPECT_EQ(0, audio_device_->MicrophoneMuteIsAvailable(&available));
   EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
 
   // check all availiable devices
   int16_t no_devices = audio_device_->RecordingDevices();
   for (int i = 0; i < no_devices; i++) {
     EXPECT_EQ(0, audio_device_->SetRecordingDevice(i));
     EXPECT_EQ(0, audio_device_->MicrophoneMuteIsAvailable(&available));
     EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
   }
 }
 
 TEST_F(AudioDeviceAPITest, MicrophoneBoostIsAvailable) {
   bool available;
   CheckInitialRecordingStates();
-#ifdef _WIN32
+#if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
   // check the kDefaultCommunicationDevice
   EXPECT_TRUE(audio_device_->SetRecordingDevice(
           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
   EXPECT_EQ(0, audio_device_->MicrophoneBoostIsAvailable(&available));
   // check for availability should not lead to initialization
   EXPECT_FALSE(audio_device_->MicrophoneIsInitialized());
 #endif
 
   // check the kDefaultDevice
   EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
@@ skipping 11 matching lines @@
 
 TEST_F(AudioDeviceAPITest, SpeakerMuteTests) {
   bool available;
   bool enabled;
   CheckInitialPlayoutStates();
   // fail tests
   EXPECT_EQ(-1, audio_device_->SetSpeakerMute(true));
   // requires initialization
   EXPECT_EQ(-1, audio_device_->SpeakerMute(&enabled));
 
-#ifdef _WIN32
+#if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
   // initialize kDefaultCommunicationDevice and modify/retrieve the mute state
   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
       AudioDeviceModule::kDefaultCommunicationDevice));
   EXPECT_EQ(0, audio_device_->SpeakerMuteIsAvailable(&available));
   if (available)
   {
     EXPECT_EQ(0, audio_device_->InitSpeaker());
     EXPECT_EQ(0, audio_device_->SetSpeakerMute(true));
     EXPECT_EQ(0, audio_device_->SpeakerMute(&enabled));
     EXPECT_TRUE(enabled);
@@ skipping 33 matching lines @@
 TEST_F(AudioDeviceAPITest, MicrophoneMuteTests) {
   CheckInitialRecordingStates();
 
   // fail tests
   EXPECT_EQ(-1, audio_device_->SetMicrophoneMute(true));
   // requires initialization
   bool available;
   bool enabled;
   EXPECT_EQ(-1, audio_device_->MicrophoneMute(&enabled));
 
-#ifdef _WIN32
+#if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
   // initialize kDefaultCommunicationDevice and modify/retrieve the mute
   EXPECT_TRUE(audio_device_->SetRecordingDevice(
           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
   EXPECT_EQ(0, audio_device_->MicrophoneMuteIsAvailable(&available));
   if (available)
   {
     EXPECT_EQ(0, audio_device_->InitMicrophone());
     EXPECT_EQ(0, audio_device_->SetMicrophoneMute(true));
     EXPECT_EQ(0, audio_device_->MicrophoneMute(&enabled));
     EXPECT_TRUE(enabled);
@@ skipping 33 matching lines @@
 TEST_F(AudioDeviceAPITest, MicrophoneBoostTests) {
   bool available;
   bool enabled;
   CheckInitialRecordingStates();
 
   // fail tests
   EXPECT_EQ(-1, audio_device_->SetMicrophoneBoost(true));
   // requires initialization
   EXPECT_EQ(-1, audio_device_->MicrophoneBoost(&enabled));
 
-#ifdef _WIN32
+#if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
   // initialize kDefaultCommunicationDevice and modify/retrieve the boost
   EXPECT_TRUE(audio_device_->SetRecordingDevice(
           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
   EXPECT_EQ(0, audio_device_->MicrophoneBoostIsAvailable(&available));
   if (available)
   {
     EXPECT_EQ(0, audio_device_->InitMicrophone());
     EXPECT_EQ(0, audio_device_->SetMicrophoneBoost(true));
     EXPECT_EQ(0, audio_device_->MicrophoneBoost(&enabled));
     EXPECT_TRUE(enabled);
@@ skipping 158 matching lines @@
     EXPECT_FALSE(enabled);
   }
 }
 
 TEST_F(AudioDeviceAPITest, PlayoutBufferTests) {
   AudioDeviceModule::BufferType bufferType;
   uint16_t sizeMS(0);
 
   CheckInitialPlayoutStates();
   EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS));
-#if defined(_WIN32) || defined(ANDROID) || defined(WEBRTC_IOS)
+#if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD) || defined(ANDROID) || \
+    defined(WEBRTC_IOS)
   EXPECT_EQ(AudioDeviceModule::kAdaptiveBufferSize, bufferType);
 #else
   EXPECT_EQ(AudioDeviceModule::kFixedBufferSize, bufferType);
 #endif
 
   // fail tests
   EXPECT_EQ(-1, audio_device_->InitPlayout());
   // must set device first
   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
       MACRO_DEFAULT_COMMUNICATION_DEVICE));
 
   // TODO(kjellander): Fix so these tests pass on Mac.
 #if !defined(WEBRTC_MAC)
   EXPECT_EQ(0, audio_device_->InitPlayout());
   EXPECT_TRUE(audio_device_->PlayoutIsInitialized());
 #endif
   EXPECT_TRUE(audio_device_->SetPlayoutBuffer(
       AudioDeviceModule::kAdaptiveBufferSize, 100) == -1);
   EXPECT_EQ(0, audio_device_->StopPlayout());
   EXPECT_TRUE(audio_device_->SetPlayoutBuffer(
       AudioDeviceModule::kFixedBufferSize, kAdmMinPlayoutBufferSizeMs-1) == -1);
   EXPECT_TRUE(audio_device_->SetPlayoutBuffer(
       AudioDeviceModule::kFixedBufferSize, kAdmMaxPlayoutBufferSizeMs+1) == -1);
 
   // bulk tests (all should be successful)
   EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
-#ifdef _WIN32
+#if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
   EXPECT_EQ(0, audio_device_->SetPlayoutBuffer(
       AudioDeviceModule::kAdaptiveBufferSize, 0));
   EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS));
   EXPECT_EQ(AudioDeviceModule::kAdaptiveBufferSize, bufferType);
   EXPECT_EQ(0, audio_device_->SetPlayoutBuffer(
       AudioDeviceModule::kAdaptiveBufferSize, 10000));
   EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS));
   EXPECT_EQ(AudioDeviceModule::kAdaptiveBufferSize, bufferType);
 #endif
 #if defined(ANDROID) || defined(WEBRTC_IOS)
@@ skipping 11 matching lines @@
   EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS));
   EXPECT_EQ(AudioDeviceModule::kFixedBufferSize, bufferType);
   EXPECT_EQ(kAdmMaxPlayoutBufferSizeMs, sizeMS);
   EXPECT_EQ(0, audio_device_->SetPlayoutBuffer(
       AudioDeviceModule::kFixedBufferSize, 100));
   EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS));
   EXPECT_EQ(AudioDeviceModule::kFixedBufferSize, bufferType);
   EXPECT_EQ(100, sizeMS);
 #endif
 
-#ifdef _WIN32
+#if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
   // restore default
   EXPECT_EQ(0, audio_device_->SetPlayoutBuffer(
       AudioDeviceModule::kAdaptiveBufferSize, 0));
   EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS));
 #endif
 }
 
 TEST_F(AudioDeviceAPITest, PlayoutDelay) {
   // NOTE: this API is better tested in a functional test
   uint16_t sizeMS(0);
@@ skipping 11 matching lines @@
   // bulk tests
   EXPECT_EQ(0, audio_device_->RecordingDelay(&sizeMS));
   EXPECT_EQ(0, audio_device_->RecordingDelay(&sizeMS));
 }
 
 TEST_F(AudioDeviceAPITest, CPULoad) {
   // NOTE: this API is better tested in a functional test
   uint16_t load(0);
 
   // bulk tests
-#ifdef _WIN32
+#if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
   EXPECT_EQ(0, audio_device_->CPULoad(&load));
   EXPECT_EQ(0, load);
 #else
   EXPECT_EQ(-1, audio_device_->CPULoad(&load));
 #endif
 }
 
 // TODO(kjellander): Fix flakiness causing failures on Windows.
 // TODO(phoglund):  Fix flakiness causing failures on Linux.
 #if !defined(_WIN32) && !defined(WEBRTC_LINUX)
@@ skipping 95 matching lines @@
   EXPECT_EQ(48000, sampleRate);
 #elif defined(ANDROID)
   TEST_LOG("Playout sample rate is %u\n\n", sampleRate);
   EXPECT_TRUE((sampleRate == 44000) || (sampleRate == 16000));
 #elif defined(WEBRTC_IOS)
   TEST_LOG("Playout sample rate is %u\n\n", sampleRate);
   EXPECT_TRUE((sampleRate == 44000) || (sampleRate == 16000) ||
               (sampleRate == 8000));
 #endif
 }