Move content\browser\renderer_host\media to content namespace.

content/browser/speech/speech_recognition_manager_impl.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 "content/browser/speech/speech_recognition_manager_impl.h"
 
 #include "base/bind.h"
 #include "content/browser/browser_main_loop.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/speech/google_one_shot_remote_engine.h"
@@ skipping 28 matching lines @@
 }
 
 }  // namespace
 
 SpeechRecognitionManager* SpeechRecognitionManager::GetInstance() {
   return SpeechRecognitionManagerImpl::GetInstance();
 }
 
 #if !defined(OS_IOS)
 class SpeechRecognitionManagerImpl::PermissionRequest
-    : public media_stream::MediaStreamRequester {
+    : public MediaStreamRequester {
  public:
   PermissionRequest(int session_id,
                     const base::Callback<void(bool is_allowed)>& callback)
       : session_id_(session_id),
         callback_(callback),
         started_(false) {
   }
 
   virtual ~PermissionRequest() {
     if (started_)
       Abort();
   }
 
   void Start(int render_process_id, int render_view_id, const GURL& origin) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     started_ = true;
     BrowserMainLoop::GetMediaStreamManager()->GenerateStream(
         this,
         render_process_id,
         render_view_id,
-        media_stream::StreamOptions(MEDIA_DEVICE_AUDIO_CAPTURE,
-                                    MEDIA_DEVICE_VIDEO_CAPTURE),
+        StreamOptions(MEDIA_DEVICE_AUDIO_CAPTURE, MEDIA_DEVICE_VIDEO_CAPTURE),
         origin,
         &label_);
   }
 
   void Abort() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     started_ = false;
     BrowserMainLoop::GetMediaStreamManager()->CancelRequest(label_);
   }
 
   int Session() const { return session_id_; }
 
   // MediaStreamRequester methods.
   virtual void StreamGenerated(
       const std::string& label,
-      const media_stream::StreamDeviceInfoArray& audio_devices,
-      const media_stream::StreamDeviceInfoArray& video_devices) OVERRIDE {
+      const StreamDeviceInfoArray& audio_devices,
+      const StreamDeviceInfoArray& video_devices) OVERRIDE {
     // TODO(hans): One day it would be nice to actually use the generated stream
     // but right now we only use it to request permission, and then we dump it.
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     started_ = false;
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
-        base::Bind(&media_stream::MediaStreamManager::StopGeneratedStream,
+        base::Bind(&MediaStreamManager::StopGeneratedStream,
                    base::Unretained(BrowserMainLoop::GetMediaStreamManager()),
                    label));
     callback_.Run(true);
   }
 
   virtual void StreamGenerationFailed(const std::string& label) OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     started_ = false;
     callback_.Run(false);
   }
 
   // The callbacks below are ignored.
   virtual void DevicesEnumerated(
       const std::string& label,
-      const media_stream::StreamDeviceInfoArray& devices) OVERRIDE {}
+      const StreamDeviceInfoArray& devices) OVERRIDE {}
   virtual void DeviceOpened(
       const std::string& label,
-      const media_stream::StreamDeviceInfo& device_info) OVERRIDE {}
+      const StreamDeviceInfo& device_info) OVERRIDE {}
 
  private:
   int session_id_;
   base::Callback<void(bool is_allowed)> callback_;
   std::string label_;
   bool started_;
 };
 #endif  // !defined(OS_IOS)
 
 SpeechRecognitionManagerImpl* SpeechRecognitionManagerImpl::GetInstance() {
@@ skipping 548 matching lines @@
 
 SpeechRecognitionManagerImpl::Session::Session()
   : id(kSessionIDInvalid),
     listener_is_active(true) {
 }
 
 SpeechRecognitionManagerImpl::Session::~Session() {
 }
 
 }  // namespace content