Move media/audio files into media namespace

content/browser/renderer_host/media/audio_input_device_manager_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/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
@@ skipping 87 matching lines @@
   bool CanRunAudioInputDeviceTests() {
     return audio_manager_->HasAudioInputDevices();
   }
 
  protected:
   virtual void SetUp() {
     // The test must run on Browser::IO.
     message_loop_.reset(new MessageLoop(MessageLoop::TYPE_IO));
     io_thread_.reset(new BrowserThreadImpl(BrowserThread::IO,
                                            message_loop_.get()));
-    audio_manager_.reset(AudioManager::Create());
+    audio_manager_.reset(media::AudioManager::Create());
 
     manager_ = new AudioInputDeviceManager(audio_manager_.get());
     audio_input_listener_.reset(new MockAudioInputDeviceManagerListener());
     manager_->Register(audio_input_listener_.get());
 
     // Gets the enumerated device list from the AudioInputDeviceManager.
     manager_->EnumerateDevices();
     EXPECT_CALL(*audio_input_listener_, DevicesEnumerated(_))
         .Times(1);
 
     // Waits for the callback.
     message_loop_->RunAllPending();
   }
 
   virtual void TearDown() {
     manager_->Unregister();
     io_thread_.reset();
   }
 
   scoped_ptr<MessageLoop> message_loop_;
   scoped_ptr<BrowserThreadImpl> io_thread_;
   scoped_refptr<AudioInputDeviceManager> manager_;
   scoped_ptr<MockAudioInputDeviceManagerListener> audio_input_listener_;
-  scoped_ptr<AudioManager> audio_manager_;
+  scoped_ptr<media::AudioManager> audio_manager_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AudioInputDeviceManagerTest);
 };
 
 // Opens and closes the devices.
 TEST_F(AudioInputDeviceManagerTest, OpenAndCloseDevice) {
   if (!CanRunAudioInputDeviceTests())
     return;
 
@@ skipping 264 matching lines @@
               Opened(content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE,
                      second_session_id))
       .Times(1);
   message_loop_->RunAllPending();
 
   // Calls Start()/Stop()/Close() for the default device twice.
   manager_->Start(first_session_id, first_event_handler.get());
   manager_->Start(second_session_id, second_event_handler.get());
   EXPECT_CALL(*first_event_handler,
               DeviceStarted(first_session_id,
-                            AudioManagerBase::kDefaultDeviceId))
+                            media::AudioManagerBase::kDefaultDeviceId))
       .Times(1);
   EXPECT_CALL(*second_event_handler,
               DeviceStarted(second_session_id,
-                            AudioManagerBase::kDefaultDeviceId))
+                            media::AudioManagerBase::kDefaultDeviceId))
       .Times(1);
   message_loop_->RunAllPending();
 
   manager_->Stop(first_session_id);
   manager_->Stop(second_session_id);
   manager_->Close(first_session_id);
   manager_->Close(second_session_id);
   EXPECT_CALL(*audio_input_listener_,
               Closed(content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE,
                      first_session_id))
@@ skipping 63 matching lines @@
   EXPECT_CALL(*audio_input_listener_,
               Opened(content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE,
                      session_id))
       .Times(1);
   message_loop_->RunAllPending();
 
   // Starts the session, it should succeed.
   manager_->Start(session_id, audio_input_event_handler.get());
   EXPECT_CALL(*audio_input_event_handler,
               DeviceStarted(session_id,
-                            AudioManagerBase::kDefaultDeviceId))
+                            media::AudioManagerBase::kDefaultDeviceId))
       .Times(1);
   message_loop_->RunAllPending();
 
   // Starts the session for the second time, it should fail.
   manager_->Start(session_id, audio_input_event_handler.get());
   EXPECT_CALL(*audio_input_event_handler,
               DeviceStarted(session_id,
                             AudioInputDeviceManager::kInvalidDeviceId))
       .Times(1);
 
   manager_->Stop(session_id);
   manager_->Close(session_id);
   EXPECT_CALL(*audio_input_listener_,
               Closed(content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE,
                      session_id))
       .Times(1);
   message_loop_->RunAllPending();
 }
 
 }  // namespace media_stream