Refactoring of chrome speech recognition architecture (CL1.2)

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/render_view_host_impl.h"
 #include "content/browser/speech/input_tag_speech_dispatcher_host.h"
-#include "content/browser/speech/speech_recognizer_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
+#include "content/public/browser/speech_recognizer.h"
 #include "content/public/browser/render_view_host_delegate.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/speech_recognition_manager_delegate.h"
 #include "content/public/browser/speech_recognition_preferences.h"
 #include "content/public/common/view_type.h"
+#include "media/audio/audio_manager.h"
 
 using content::BrowserMainLoop;
 using content::BrowserThread;
 using content::RenderViewHostImpl;
 using content::SpeechRecognitionManager;
 using content::SpeechRecognitionManagerDelegate;
 
 SpeechRecognitionManager* SpeechRecognitionManager::GetInstance() {
   return speech::SpeechRecognitionManagerImpl::GetInstance();
 }
 
 namespace speech {
 
 struct SpeechRecognitionManagerImpl::SpeechRecognitionParams {
-  SpeechRecognitionParams(InputTagSpeechDispatcherHost* delegate,
-                    int caller_id,
-                    int render_process_id,
-                    int render_view_id,
-                    const gfx::Rect& element_rect,
-                    const std::string& language,
-                    const std::string& grammar,
-                    const std::string& origin_url,
-                    net::URLRequestContextGetter* context_getter,
-                    content::SpeechRecognitionPreferences* recognition_prefs)
+  SpeechRecognitionParams(
+      InputTagSpeechDispatcherHost* delegate,
+      int caller_id,
+      int render_process_id,
+      int render_view_id,
+      const gfx::Rect& element_rect,
+      const std::string& language,
+      const std::string& grammar,
+      const std::string& origin_url,
+      net::URLRequestContextGetter* context_getter,
+      content::SpeechRecognitionPreferences* recognition_prefs)
       : delegate(delegate),
         caller_id(caller_id),
         render_process_id(render_process_id),
         render_view_id(render_view_id),
         element_rect(element_rect),
         language(language),
         grammar(grammar),
         origin_url(origin_url),
         context_getter(context_getter),
         recognition_prefs(recognition_prefs) {
@@ skipping 119 matching lines @@
 
   if (delegate_) {
     delegate_->ShowRecognitionRequested(
         params.caller_id, params.render_process_id, params.render_view_id,
         params.element_rect);
     delegate_->GetRequestInfo(&can_report_metrics_, &request_info_);
   }
 
   Request* request = &requests_[params.caller_id];
   request->delegate = params.delegate;
-  request->recognizer = new SpeechRecognizerImpl(
+  request->recognizer = content::SpeechRecognizer::Create(
       this, params.caller_id, params.language, params.grammar,
       params.context_getter, params.recognition_prefs->FilterProfanities(),
       request_info_, can_report_metrics_ ? params.origin_url : "");
   request->is_active = false;
 
   StartRecognitionForRequest(params.caller_id);
 }
 
 void SpeechRecognitionManagerImpl::StartRecognitionForRequest(int caller_id) {
   SpeechRecognizerMap::iterator request = requests_.find(caller_id);
@@ skipping 15 matching lines @@
           SpeechRecognitionManagerDelegate::MIC_ERROR_NO_DEVICE_AVAILABLE);
     }
   } else if (IsCapturingAudio()) {
     if (delegate_) {
       delegate_->ShowMicError(
           caller_id, SpeechRecognitionManagerDelegate::MIC_ERROR_DEVICE_IN_USE);
     }
   } else {
     recording_caller_id_ = caller_id;
     requests_[caller_id].is_active = true;
-    requests_[caller_id].recognizer->StartRecording();
+    requests_[caller_id].recognizer->StartRecognition();
     if (delegate_)
       delegate_->ShowWarmUp(caller_id);
   }
 }
 
 void SpeechRecognitionManagerImpl::CancelRecognitionForRequest(int caller_id) {
   // Ignore if the caller id was not in our active recognizers list because the
   // user might have clicked more than once, or recognition could have been
   // ended due to other reasons before the user click was processed.
   if (!HasPendingRequest(caller_id))
@@ skipping 11 matching lines @@
   // to the user, abort it since user has switched focus. Otherwise
   // recognition has started and keep that going so user can start speaking to
   // another element while this gets the results in parallel.
   if (recording_caller_id_ == caller_id || !requests_[caller_id].is_active)
     CancelRecognitionAndInformDelegate(caller_id);
 }
 
 void SpeechRecognitionManagerImpl::CancelRecognition(int caller_id) {
   DCHECK(HasPendingRequest(caller_id));
   if (requests_[caller_id].is_active)
-    requests_[caller_id].recognizer->CancelRecognition();
+    requests_[caller_id].recognizer->AbortRecognition();
   requests_.erase(caller_id);
   if (recording_caller_id_ == caller_id)
     recording_caller_id_ = 0;
   if (delegate_)
     delegate_->DoClose(caller_id);
 }
 
 void SpeechRecognitionManagerImpl::CancelAllRequestsWithDelegate(
     InputTagSpeechDispatcherHost* delegate) {
   SpeechRecognizerMap::iterator it = requests_.begin();
   while (it != requests_.end()) {
     if (it->second.delegate == delegate) {
       CancelRecognition(it->first);
       // This map will have very few elements so it is simpler to restart.
       it = requests_.begin();
     } else {
       ++it;
     }
   }
 }
 
 void SpeechRecognitionManagerImpl::StopRecording(int caller_id) {
   // No pending requests on extension popups.
   if (!HasPendingRequest(caller_id))
     return;
 
-  requests_[caller_id].recognizer->StopRecording();
+  requests_[caller_id].recognizer->StopAudioCapture();
 }
 
-void SpeechRecognitionManagerImpl::SetRecognitionResult(
+// -------- SpeechRecognitionEventListener interface implementation. ---------
+
+void SpeechRecognitionManagerImpl::OnRecognitionResult(
     int caller_id, const content::SpeechRecognitionResult& result) {
   DCHECK(HasPendingRequest(caller_id));
   GetDelegate(caller_id)->SetRecognitionResult(caller_id, result);
 }
 
-void SpeechRecognitionManagerImpl::DidCompleteRecording(int caller_id) {
-  DCHECK(recording_caller_id_ == caller_id);
+void SpeechRecognitionManagerImpl::OnAudioEnd(int caller_id) {
+  DCHECK_EQ(recording_caller_id_, caller_id);
   DCHECK(HasPendingRequest(caller_id));
   recording_caller_id_ = 0;
   GetDelegate(caller_id)->DidCompleteRecording(caller_id);
   if (delegate_)
     delegate_->ShowRecognizing(caller_id);
 }
 
-void SpeechRecognitionManagerImpl::DidCompleteRecognition(int caller_id) {
+void SpeechRecognitionManagerImpl::OnRecognitionEnd(int caller_id) {
   GetDelegate(caller_id)->DidCompleteRecognition(caller_id);
   requests_.erase(caller_id);
   if (delegate_)
     delegate_->DoClose(caller_id);
 }
 
-void SpeechRecognitionManagerImpl::DidStartReceivingSpeech(int caller_id) {
+void SpeechRecognitionManagerImpl::OnSoundStart(int caller_id) {
 }
 
-void SpeechRecognitionManagerImpl::DidStopReceivingSpeech(int caller_id) {
+void SpeechRecognitionManagerImpl::OnSoundEnd(int caller_id) {
 }
 
-void SpeechRecognitionManagerImpl::OnRecognizerError(
-    int caller_id, content::SpeechRecognitionErrorCode error) {
+void SpeechRecognitionManagerImpl::OnRecognitionError(
+    int caller_id, const content::SpeechRecognitionErrorCode& error) {
   if (caller_id == recording_caller_id_)
     recording_caller_id_ = 0;
   requests_[caller_id].is_active = false;
   if (delegate_)
     delegate_->ShowRecognizerError(caller_id, error);
 }
 
-void SpeechRecognitionManagerImpl::DidStartReceivingAudio(int caller_id) {
+void SpeechRecognitionManagerImpl::OnAudioStart(int caller_id) {
   DCHECK(HasPendingRequest(caller_id));
-  DCHECK(recording_caller_id_ == caller_id);
+  DCHECK_EQ(recording_caller_id_, caller_id);
   if (delegate_)
     delegate_->ShowRecording(caller_id);
 }
 
-void SpeechRecognitionManagerImpl::DidCompleteEnvironmentEstimation(
+void SpeechRecognitionManagerImpl::OnRecognitionStart(int caller_id) {
+}
+
+void SpeechRecognitionManagerImpl::OnEnvironmentEstimationComplete(
     int caller_id) {
   DCHECK(HasPendingRequest(caller_id));
-  DCHECK(recording_caller_id_ == caller_id);
+  DCHECK_EQ(recording_caller_id_, caller_id);
 }
 
-void SpeechRecognitionManagerImpl::SetInputVolume(int caller_id, float volume,
-                                                  float noise_volume) {
+void SpeechRecognitionManagerImpl::OnAudioLevelsChange(
+    int caller_id, float volume, float noise_volume) {
   DCHECK(HasPendingRequest(caller_id));
   DCHECK_EQ(recording_caller_id_, caller_id);
   if (delegate_)
     delegate_->ShowInputVolume(caller_id, volume, noise_volume);
 }
 
 void SpeechRecognitionManagerImpl::CancelRecognitionAndInformDelegate(
     int caller_id) {
   InputTagSpeechDispatcherHost* cur_delegate = GetDelegate(caller_id);
   CancelRecognition(caller_id);
   cur_delegate->DidCompleteRecording(caller_id);
   cur_delegate->DidCompleteRecognition(caller_id);
 }
 
 SpeechRecognitionManagerImpl::Request::Request()
     : delegate(NULL),
       is_active(false) {
 }
 
 SpeechRecognitionManagerImpl::Request::~Request() {
 }
 
 }  // namespace speech