content/browser: Move speech code into 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"
 #include "content/browser/speech/google_streaming_remote_engine.h"
 #include "content/browser/speech/speech_recognition_engine.h"
 #include "content/browser/speech/speech_recognizer.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/speech_recognition_event_listener.h"
 #include "content/public/browser/speech_recognition_manager_delegate.h"
 #include "content/public/browser/speech_recognition_session_config.h"
 #include "content/public/browser/speech_recognition_session_context.h"
 #include "content/public/common/speech_recognition_error.h"
 #include "content/public/common/speech_recognition_result.h"
 #include "media/audio/audio_manager.h"
 
 using base::Callback;
-using content::BrowserMainLoop;
-using content::BrowserThread;
-using content::SpeechRecognitionEventListener;
-using content::SpeechRecognitionManager;
-using content::SpeechRecognitionResult;
-using content::SpeechRecognitionSessionContext;
-using content::SpeechRecognitionSessionConfig;
 
 namespace content {
-SpeechRecognitionManager* SpeechRecognitionManager::GetInstance() {
-  return speech::SpeechRecognitionManagerImpl::GetInstance();
-}
-}  // namespace content
 
 namespace {
-speech::SpeechRecognitionManagerImpl* g_speech_recognition_manager_impl;
+
+SpeechRecognitionManagerImpl* g_speech_recognition_manager_impl;
 
 void ShowAudioInputSettingsOnFileThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   media::AudioManager* audio_manager = BrowserMainLoop::GetAudioManager();
   DCHECK(audio_manager->CanShowAudioInputSettings());
   if (audio_manager->CanShowAudioInputSettings())
     audio_manager->ShowAudioInputSettings();
 }
+
 }  // namespace
 
-namespace speech {
+SpeechRecognitionManager* SpeechRecognitionManager::GetInstance() {
+  return SpeechRecognitionManagerImpl::GetInstance();
+}
 
 #if !defined(OS_IOS)
 class SpeechRecognitionManagerImpl::PermissionRequest
     : public media_stream::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(content::MEDIA_DEVICE_AUDIO_CAPTURE,
-                                    content::MEDIA_DEVICE_VIDEO_CAPTURE),
+        media_stream::StreamOptions(MEDIA_DEVICE_AUDIO_CAPTURE,
+                                    MEDIA_DEVICE_VIDEO_CAPTURE),
         origin,
         &label_);
   }
 
   void Abort() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     started_ = false;
     BrowserMainLoop::GetMediaStreamManager()->CancelRequest(label_);
   }
 
@@ skipping 40 matching lines @@
 #endif  // !defined(OS_IOS)
 
 SpeechRecognitionManagerImpl* SpeechRecognitionManagerImpl::GetInstance() {
   return g_speech_recognition_manager_impl;
 }
 
 SpeechRecognitionManagerImpl::SpeechRecognitionManagerImpl()
     : primary_session_id_(kSessionIDInvalid),
       last_session_id_(kSessionIDInvalid),
       is_dispatching_event_(false),
-      delegate_(content::GetContentClient()->browser()->
+      delegate_(GetContentClient()->browser()->
                     GetSpeechRecognitionManagerDelegate()),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   DCHECK(!g_speech_recognition_manager_impl);
   g_speech_recognition_manager_impl = this;
 }
 
 SpeechRecognitionManagerImpl::~SpeechRecognitionManagerImpl() {
   DCHECK(g_speech_recognition_manager_impl);
   g_speech_recognition_manager_impl = NULL;
   // Recognition sessions will be aborted by the corresponding destructors.
@@ skipping 104 matching lines @@
     return;
   }
   permission_request_.reset();
 #endif  // defined(OS_IOS)
 
   if (is_allowed) {
     MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(&SpeechRecognitionManagerImpl::DispatchEvent,
                    weak_factory_.GetWeakPtr(), session_id, EVENT_START));
   } else {
-    OnRecognitionError(session_id, content::SpeechRecognitionError(
-        content::SPEECH_RECOGNITION_ERROR_NOT_ALLOWED));
+    OnRecognitionError(session_id, SpeechRecognitionError(
+        SPEECH_RECOGNITION_ERROR_NOT_ALLOWED));
     MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(&SpeechRecognitionManagerImpl::DispatchEvent,
                    weak_factory_.GetWeakPtr(), session_id, EVENT_ABORT));
   }
 }
 
 void SpeechRecognitionManagerImpl::AbortSession(int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!SessionExists(session_id))
     return;
@@ skipping 102 matching lines @@
   if (SpeechRecognitionEventListener* delegate_listener = GetDelegateListener())
     delegate_listener->OnAudioEnd(session_id);
   if (SpeechRecognitionEventListener* listener = GetListener(session_id))
     listener->OnAudioEnd(session_id);
   MessageLoop::current()->PostTask(FROM_HERE,
       base::Bind(&SpeechRecognitionManagerImpl::DispatchEvent,
                  weak_factory_.GetWeakPtr(), session_id, EVENT_AUDIO_ENDED));
 }
 
 void SpeechRecognitionManagerImpl::OnRecognitionResult(
-    int session_id, const content::SpeechRecognitionResult& result) {
+    int session_id, const SpeechRecognitionResult& result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!SessionExists(session_id))
     return;
 
   if (SpeechRecognitionEventListener* delegate_listener = GetDelegateListener())
     delegate_listener->OnRecognitionResult(session_id, result);
   if (SpeechRecognitionEventListener* listener = GetListener(session_id))
     listener->OnRecognitionResult(session_id, result);
 }
 
 void SpeechRecognitionManagerImpl::OnRecognitionError(
-    int session_id, const content::SpeechRecognitionError& error) {
+    int session_id, const SpeechRecognitionError& error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!SessionExists(session_id))
     return;
 
   if (SpeechRecognitionEventListener* delegate_listener = GetDelegateListener())
     delegate_listener->OnRecognitionError(session_id, error);
   if (SpeechRecognitionEventListener* listener = GetListener(session_id))
     listener->OnRecognitionError(session_id, error);
 }
 
@@ skipping 268 matching lines @@
 }
 
 SpeechRecognitionManagerImpl::Session::Session()
   : id(kSessionIDInvalid),
     listener_is_active(true) {
 }
 
 SpeechRecognitionManagerImpl::Session::~Session() {
 }
 
-}  // namespace speech
+}  // namespace content