Applying changes to the existing speech input code to support the extension API.

content/browser/speech/speech_recognizer.cc

 // Copyright (c) 2011 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_recognizer.h"
 
 #include "base/time.h"
 #include "content/browser/browser_thread.h"
 #include "net/url_request/url_request_context_getter.h"
 
@@ skipping 151 matching lines @@
   if (request_ == NULL) {
     // Guard against the delegate freeing us until we finish our job.
     scoped_refptr<SpeechRecognizer> me(this);
     delegate_->DidCompleteRecognition(caller_id_);
   } else {
     request_->UploadAudioChunk(encoded_data, true /* is_last_chunk */);
   }
 }
 
 // Invoked in the audio thread.
+void SpeechRecognizer::OnRecording(AudioInputController* controller) {
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+      NewRunnableMethod(this, &SpeechRecognizer::HandleOnRecording));
+}
+
+void SpeechRecognizer::HandleOnRecording() {
+  // Guard against the delegate freeing us until we finish our job.
+  scoped_refptr<SpeechRecognizer> me(this);
+  delegate_->OnRecording(caller_id_);
+}
+
+// Invoked in the audio thread.
 void SpeechRecognizer::OnError(AudioInputController* controller,
                                int error_code) {
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                          NewRunnableMethod(this,
                                            &SpeechRecognizer::HandleOnError,
                                            error_code));
 }
 
 void SpeechRecognizer::HandleOnError(int error_code) {
   LOG(WARNING) << "SpeechRecognizer::HandleOnError, code=" << error_code;
@@ skipping 21 matching lines @@
 
 void SpeechRecognizer::HandleOnData(string* data) {
   // Check if we are still recording and if not discard this buffer, as
   // recording might have been stopped after this buffer was posted to the queue
   // by |OnData|.
   if (!audio_controller_.get()) {
     delete data;
     return;
   }
 
+  bool speech_started = endpointer_.DidStartReceivingSpeech();

[Satish, 2011/10/04 20:36:33]

suggest renaming to speech_was_heard to indicate this is the state before the
new audio packet is processed

[Leandro Graciá Gil, 2011/10/05 22:09:00]

Done.

+
   const short* samples = reinterpret_cast<const short*>(data->data());
   DCHECK((data->length() % sizeof(short)) == 0);
   int num_samples = data->length() / sizeof(short);
   encoder_->Encode(samples, num_samples);
   float rms;
   endpointer_.ProcessAudio(samples, num_samples, &rms);
   bool did_clip = Clipping(samples, num_samples);
   delete data;
   num_samples_recorded_ += num_samples;
 
@@ skipping 16 matching lines @@
     // environment estimation and should move on to detect speech/end of speech.
     if (num_samples_recorded_ >= (kEndpointerEstimationTimeMs *
                                   kAudioSampleRate) / 1000) {
       endpointer_.SetUserInputMode();
       delegate_->DidCompleteEnvironmentEstimation(caller_id_);
     }
     return;  // No more processing since we are still estimating environment.
   }
 
   // Check if we have waited too long without hearing any speech.
   if (!endpointer_.DidStartReceivingSpeech() &&

[Satish, 2011/10/04 20:36:33]

perhaps assign the value of DidStartReceivingSpeech to a new bool here and use
that in this if statement and below?

[Leandro Graciá Gil, 2011/10/05 22:09:00]

Done.

       num_samples_recorded_ >= kNoSpeechTimeoutSec * kAudioSampleRate) {
     InformErrorAndCancelRecognition(RECOGNIZER_ERROR_NO_SPEECH);
     return;
   }
 
+  if (!speech_started && endpointer_.DidStartReceivingSpeech())
+    delegate_->DidSpeechInputStart(caller_id_);
+
   // Calculate the input volume to display in the UI, smoothing towards the
   // new level.
   float level = (rms - kAudioMeterMinDb) /
       (kAudioMeterDbRange / kAudioMeterRangeMaxUnclipped);
   level = std::min(std::max(0.0f, level), kAudioMeterRangeMaxUnclipped);
   if (level > audio_level_) {
     audio_level_ += (level - audio_level_) * kUpSmoothingFactor;
   } else {
     audio_level_ += (level - audio_level_) * kDownSmoothingFactor;
   }
 
   float noise_level = (endpointer_.NoiseLevelDb() - kAudioMeterMinDb) /
       (kAudioMeterDbRange / kAudioMeterRangeMaxUnclipped);
   noise_level = std::min(std::max(0.0f, noise_level),
       kAudioMeterRangeMaxUnclipped);
 
   delegate_->SetInputVolume(caller_id_, did_clip ? 1.0f : audio_level_,
                             noise_level);
 
   if (endpointer_.speech_input_complete()) {
     StopRecording();
+    delegate_->DidSpeechInputStop(caller_id_);

[Satish, 2011/10/04 20:36:33]

instead of invoking this here do it inside StopRecording() so if someone else
calls that directly this callback will still get invoked

[Leandro Graciá Gil, 2011/10/05 22:09:00]

Done.

   }
 
   // TODO(satish): Once we have streaming POST, start sending the data received
   // here as POST chunks.
 }
 
 void SpeechRecognizer::SetRecognitionResult(
-    bool error, const SpeechInputResultArray& result) {
-  if (error || result.empty()) {
-    InformErrorAndCancelRecognition(error ? RECOGNIZER_ERROR_NETWORK :
-                                            RECOGNIZER_ERROR_NO_RESULTS);
+    bool error, const SpeechInputResult& result) {
+  if (error) {
+    // Request failed or received an invalid response that couldn't be parsed.
+    InformErrorAndCancelRecognition(RECOGNIZER_ERROR_NETWORK);
     return;
   }
 
-  delegate_->SetRecognitionResult(caller_id_, error, result);
+  switch (result.status) {
+    case kStatusSuccess:
+      break;
+
+    case kStatusAborted:
+      InformErrorAndCancelRecognition(RECOGNIZER_ERROR_INTERNAL);
+      return;
+
+    case kStatusBadGrammar:
+      InformErrorAndCancelRecognition(RECOGNIZER_ERROR_INVALID_PARAMS);
+      return;
+
+    case kStatusAudio:
+      InformErrorAndCancelRecognition(RECOGNIZER_ERROR_CAPTURE);
+      return;
+
+    case kStatusNetwork:
+      InformErrorAndCancelRecognition(RECOGNIZER_ERROR_NETWORK);
+      return;
+
+    case kStatusNoSpeech:
+      InformErrorAndCancelRecognition(RECOGNIZER_ERROR_NO_SPEECH);
+      return;
+
+    case kStatusNoMatch:
+      InformErrorAndCancelRecognition(RECOGNIZER_ERROR_NO_RESULTS);
+      return;
+
+    default:
+      NOTREACHED();
+  }
+
+  StopRecording();

[Satish, 2011/10/04 20:36:33]

why is this call required here? wouldn't recognition have stopped well before
the result was received?

[Leandro Graciá Gil, 2011/10/05 22:09:00]

Done.

 
   // Guard against the delegate freeing us until we finish our job.
   scoped_refptr<SpeechRecognizer> me(this);
+  delegate_->SetRecognitionResult(caller_id_, error, result);
   delegate_->DidCompleteRecognition(caller_id_);
 }
 
 void SpeechRecognizer::InformErrorAndCancelRecognition(ErrorCode error) {
   CancelRecognition();
 
   // Guard against the delegate freeing us until we finish our job.
   scoped_refptr<SpeechRecognizer> me(this);
   delegate_->OnRecognizerError(caller_id_, error);
 }
 
 }  // namespace speech_input