Link things together and enable the device selection for linux and mac.

content/browser/renderer_host/media/audio_input_device_manager_unittest.cc

 // Copyright (c) 2011 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/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/renderer_host/media/audio_input_device_manager.h"
 #include "content/browser/renderer_host/media/audio_input_device_manager_event_handler.h"
-#include "media/audio/audio_manager.h"
+#include "media/audio/audio_manager_base.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::InSequence;
 using ::testing::Return;
 using content::BrowserThread;
 
 using content::BrowserThreadImpl;
@@ skipping 25 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(MockAudioInputDeviceManagerListener);
 };
 
 class MockAudioInputDeviceManagerEventHandler
     : public AudioInputDeviceManagerEventHandler {
  public:
   MockAudioInputDeviceManagerEventHandler() {}
   virtual ~MockAudioInputDeviceManagerEventHandler() {}
 
-  MOCK_METHOD2(OnDeviceStarted, void(int, int));
+  MOCK_METHOD2(OnDeviceStarted, void(int, const std::string&));
   MOCK_METHOD1(OnDeviceStopped, void(int));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockAudioInputDeviceManagerEventHandler);
 };
 
 // Returns true if machine has audio input device, else returns false.
 static bool CanRunAudioInputDeviceTests() {
   AudioManager* audio_manager = AudioManager::GetAudioManager();
   if (!audio_manager)
@@ skipping 222 matching lines @@
     session_id[index] = manager_->Open(*iter);
     manager_->Start(session_id[index], audio_input_event_handler.get());
     manager_->Stop(session_id[index]);
     manager_->Close(session_id[index]);
 
     // Expected mock calls with expected return values.
     EXPECT_CALL(*audio_input_listener_, Opened(kAudioCapture,
                                                session_id[index]))
         .Times(1);
     EXPECT_CALL(*audio_input_event_handler,
-                OnDeviceStarted(session_id[index], index))
+                OnDeviceStarted(session_id[index], iter->device_id))
         .Times(1);
     EXPECT_CALL(*audio_input_listener_, Closed(kAudioCapture,
                                                session_id[index]))
         .Times(1);
     SyncWithAudioInputDeviceManagerThread();
   }
 }
 
 // Test the behavior of calling Close without calling Stop.
 TEST_F(AudioInputDeviceManagerTest, CloseWithoutStopDevice) {
@@ skipping 17 matching lines @@
     // Open/start/close the device.
     session_id[index] = manager_->Open(*iter);
     manager_->Start(session_id[index], audio_input_event_handler.get());
     manager_->Close(session_id[index]);
 
     // Expected mock calls with expected return values.
     EXPECT_CALL(*audio_input_listener_, Opened(kAudioCapture,
                                                session_id[index]))
         .Times(1);
     EXPECT_CALL(*audio_input_event_handler,
-                OnDeviceStarted(session_id[index], index))
+                OnDeviceStarted(session_id[index], iter->device_id))
         .Times(1);
     // Event Handler should get a stop device notification as no stop is called
     // before closing the device.
     EXPECT_CALL(*audio_input_event_handler,
                 OnDeviceStopped(session_id[index]))
         .Times(1);
     EXPECT_CALL(*audio_input_listener_, Closed(kAudioCapture,
                                                session_id[index]))
         .Times(1);
     SyncWithAudioInputDeviceManagerThread();
@@ skipping 28 matching lines @@
   manager_->Close(first_session_id);
   manager_->Close(second_session_id);
 
   // Expected mock calls with expected return values.
   EXPECT_NE(first_session_id, second_session_id);
   EXPECT_CALL(*audio_input_listener_, Opened(kAudioCapture, first_session_id))
       .Times(1);
   EXPECT_CALL(*audio_input_listener_, Opened(kAudioCapture, second_session_id))
       .Times(1);
   EXPECT_CALL(*first_audio_input_event_handler,
-              OnDeviceStarted(first_session_id, 0))
+              OnDeviceStarted(first_session_id,
+                              AudioManagerBase::kDefaultDeviceId))
       .Times(1);
   EXPECT_CALL(*second_audio_input_event_handler,
-              OnDeviceStarted(second_session_id, 0))
+              OnDeviceStarted(second_session_id,
+                              AudioManagerBase::kDefaultDeviceId))
       .Times(1);
   EXPECT_CALL(*audio_input_listener_, Closed(kAudioCapture, first_session_id))
       .Times(1);
   EXPECT_CALL(*audio_input_listener_, Closed(kAudioCapture, second_session_id))
       .Times(1);
   SyncWithAudioInputDeviceManagerThread();
 }
 
 }  // namespace media_stream