Speech input: Do environment estimation and detect the no-speech case.

chrome/browser/speech/speech_input_manager.cc

 // Copyright (c) 2010 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 "chrome/browser/speech/speech_input_manager.h"
 
 #include "app/l10n_util.h"
 #include "base/ref_counted.h"
 #include "base/singleton.h"
 #include "chrome/browser/chrome_thread.h"
@@ skipping 19 matching lines @@
                                 int render_view_id,
                                 const gfx::Rect& element_rect);
   virtual void CancelRecognition(int caller_id);
   virtual void StopRecording(int caller_id);
 
   // SpeechRecognizer::Delegate methods.
   virtual void SetRecognitionResult(int caller_id, bool error,
                                     const string16& value);
   virtual void DidCompleteRecording(int caller_id);
   virtual void DidCompleteRecognition(int caller_id);
-  virtual void OnRecognizerError(int caller_id);
+  virtual void OnRecognizerError(int caller_id,
+                                 SpeechRecognizer::ErrorCode error);
+  virtual void DidCompleteEnvironmentEstimation(int caller_id);
 
   // SpeechInputBubbleController::Delegate methods.
   virtual void RecognitionCancelled(int caller_id);
   virtual void SpeechInputFocusChanged(int caller_id);
 
  private:
   struct SpeechInputRequest {
     SpeechInputManagerDelegate* delegate;
     scoped_refptr<SpeechRecognizer> recognizer;
     int render_process_id;
     int render_view_id;
+    gfx::Rect element_rect;
   };
 
   // Private constructor to enforce singleton.
   friend struct DefaultSingletonTraits<SpeechInputManagerImpl>;
   SpeechInputManagerImpl();
   virtual ~SpeechInputManagerImpl();
 
   bool HasPendingRequest(int caller_id) const;
   SpeechRecognizer* GetRecognizer(int caller_id) const;
   SpeechInputManagerDelegate* GetDelegate(int caller_id) const;
@@ skipping 55 matching lines @@
   if (recording_caller_id_)
     CancelRecognitionAndInformDelegate(recording_caller_id_);
 
   if (!AudioManager::GetAudioManager()->HasAudioInputDevices()) {
     ShowErrorMessage(render_process_id, render_view_id,
                      l10n_util::GetStringUTF16(IDS_SPEECH_INPUT_NO_MIC));
     delegate->DidCompleteRecognition(caller_id);
     return;
   }
 
-  bubble_controller_->CreateBubble(caller_id, render_process_id,
-                                   render_view_id, element_rect);
-
   recording_caller_id_ = caller_id;
   SpeechInputRequest request;
   request.delegate = delegate;
   request.recognizer = new SpeechRecognizer(this, caller_id);
   request.render_process_id = render_process_id;
   request.render_view_id = render_view_id;
+  request.element_rect = element_rect;
   requests_[caller_id] = request;
   request.recognizer->StartRecording();
 }
 
 void SpeechInputManagerImpl::CancelRecognition(int caller_id) {
   DCHECK(HasPendingRequest(caller_id));
   GetRecognizer(caller_id)->CancelRecognition();
   requests_.erase(caller_id);
   if (recording_caller_id_ == caller_id)
     recording_caller_id_ = 0;
@@ skipping 20 matching lines @@
   GetDelegate(caller_id)->DidCompleteRecording(caller_id);
   bubble_controller_->SetBubbleToRecognizingMode(caller_id);
 }
 
 void SpeechInputManagerImpl::DidCompleteRecognition(int caller_id) {
   GetDelegate(caller_id)->DidCompleteRecognition(caller_id);
   requests_.erase(caller_id);
   bubble_controller_->CloseBubble(caller_id);
 }
 
-void SpeechInputManagerImpl::OnRecognizerError(int caller_id) {
+void SpeechInputManagerImpl::OnRecognizerError(
+    int caller_id, SpeechRecognizer::ErrorCode error) {
+  // TODO(satish): Show specific messages for the various error codes and allow
+  // user to retry without ending the recognition session if possible.
   const SpeechInputRequest& request = requests_.find(caller_id)->second;
   ShowErrorMessage(request.render_process_id, request.render_view_id,
                    l10n_util::GetStringUTF16(IDS_SPEECH_INPUT_ERROR));
 }
 
+void SpeechInputManagerImpl::DidCompleteEnvironmentEstimation(int caller_id) {
+  DCHECK(HasPendingRequest(caller_id));
+  DCHECK(recording_caller_id_ == caller_id);
+
+  // Speech recognizer has gathered enough background audio so we can ask the
+  // user to start speaking.
+  const SpeechInputRequest& request = requests_.find(caller_id)->second;

[joth, 2010/09/09 10:51:37]

maybe easier as const SpeechInputRequest& request = requests_[caller_id];
also I'd be tempted to include the DCHECK(HasPendingRequest(caller_id)); here
(i.e. on line immediately proceeding this)

+  bubble_controller_->CreateBubble(caller_id, request.render_process_id,
+                                   request.render_view_id,
+                                   request.element_rect);
+}
+
 void SpeechInputManagerImpl::CancelRecognitionAndInformDelegate(int caller_id) {
   SpeechInputManagerDelegate* cur_delegate = GetDelegate(caller_id);
   CancelRecognition(caller_id);
   cur_delegate->DidCompleteRecording(caller_id);
   cur_delegate->DidCompleteRecognition(caller_id);
 }
 
 void SpeechInputManagerImpl::RecognitionCancelled(int caller_id) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   // Ignore if the caller id was not in our active recognizers list because the
@@ skipping 30 matching lines @@
     int render_process_id, int render_view_id,
     const string16& message) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   TabContents* tab = tab_util::GetTabContentsByID(render_process_id,
                                                   render_view_id);
   if (tab)  // Check in case the tab was closed before we got this request.
     tab->AddInfoBar(new SimpleAlertInfoBarDelegate(tab, message, NULL, true));
 }
 
 }  // namespace speech_input