Turn audio ducking on by default on Windows again.

content/renderer/media/media_stream_dispatcher_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 <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/common/media/media_stream_messages.h"
 #include "content/public/common/media_stream_request.h"
 #include "content/renderer/media/media_stream_dispatcher.h"
 #include "content/renderer/media/media_stream_dispatcher_eventhandler.h"
+#include "media/audio/audio_parameters.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace content {
 namespace {
 
 const int kRouteId = 0;
 const int kAudioSessionId = 3;
 const int kVideoSessionId = 5;
 const int kRequestId1 = 10;
@@ skipping 378 matching lines @@
 
   dispatcher_->OnMessageReceived(
       MediaStreamMsg_DeviceStopped(kRouteId, label, handler_->video_device_));
   // Verify that MediaStreamDispatcherEventHandler::OnDeviceStopped has been
   // called.
   EXPECT_EQ(label, handler_->device_stopped_label_);
   EXPECT_EQ(dispatcher_->video_session_id(label, 0),
             StreamDeviceInfo::kNoId);
 }
 
+TEST_F(MediaStreamDispatcherTest, CheckDuckingState) {
+  scoped_ptr<MediaStreamDispatcher> dispatcher(new MediaStreamDispatcher(NULL));
+  scoped_ptr<MockMediaStreamDispatcherEventHandler>
+      handler(new MockMediaStreamDispatcherEventHandler);
+  StreamOptions components(true, false);  // audio only.
+  int ipc_request_id1 = dispatcher->next_ipc_id_;
+
+  dispatcher->GenerateStream(kRequestId1, handler.get()->AsWeakPtr(),
+                             components, GURL());
+  EXPECT_EQ(1u, dispatcher->requests_.size());
+
+  // Ducking isn't active at this point.
+  EXPECT_FALSE(dispatcher->IsAudioDuckingActive());
+
+  // Complete the creation of stream1 with a single audio track that has
+  // ducking enabled.
+  StreamDeviceInfoArray audio_device_array(1);
+  StreamDeviceInfo& audio_device_info = audio_device_array[0];
+  audio_device_info.device.name = "Microphone";
+  audio_device_info.device.type = kAudioType;
+  audio_device_info.session_id = kAudioSessionId;
+  audio_device_info.device.input.effects = media::AudioParameters::DUCKING;

[no longer working on chromium, 2014/07/08 10:42:35]

do you mind adding a few lines of code to check ducking is off when the
|effects| is not setup for ducking. 
The existing test already looks great, it is fine if you don't think it is
worthy.

[tommi (sloooow) - chröme, 2014/07/08 12:30:56]

I think that's a good idea given my blunder in the other file! Done.

+
+  StreamDeviceInfoArray video_device_array;  // Empty for this test.
+
+  const char kStreamLabel[] = "stream1";
+  dispatcher->OnMessageReceived(MediaStreamMsg_StreamGenerated(
+      kRouteId, ipc_request_id1, kStreamLabel,
+      audio_device_array, video_device_array));
+  EXPECT_EQ(handler->request_id_, kRequestId1);
+  EXPECT_EQ(0u, dispatcher->requests_.size());
+
+  // Ducking should now be reported as active.
+  EXPECT_TRUE(dispatcher->IsAudioDuckingActive());
+
+  // Stop the device (removes the stream).
+  dispatcher->OnMessageReceived(
+      MediaStreamMsg_DeviceStopped(kRouteId, kStreamLabel,
+            handler->audio_device_));
+
+  // Ducking should now be reported as inactive again.
+  EXPECT_FALSE(dispatcher->IsAudioDuckingActive());
+}
+
 }  // namespace content