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 127 matching lines @@
 
   // If audio recording has already stopped and we are in recognition phase,
   // silently ignore any more calls to stop recording.
   if (!audio_controller_.get())
     return;
 
   VLOG(1) << "SpeechRecognizer stopping record.";
   audio_controller_->Close();
   audio_controller_ = NULL;  // Releases the ref ptr.
 
+  delegate_->DidStopReceivingSpeech(caller_id_);
   delegate_->DidCompleteRecording(caller_id_);
 
   // UploadAudioChunk requires a non-empty final buffer. So we encode a packet
   // of silence in case encoder had no data already.
   std::vector<short> samples((kAudioSampleRate * kAudioPacketIntervalMs) /
                              1000);
   encoder_->Encode(&samples[0], samples.size());
   encoder_->Flush();
   string encoded_data;
   encoder_->GetEncodedDataAndClear(&encoded_data);
@@ skipping 21 matching lines @@
 
 void SpeechRecognizer::HandleOnError(int error_code) {
   LOG(WARNING) << "SpeechRecognizer::HandleOnError, code=" << error_code;
 
   // Check if we are still recording before canceling recognition, as
   // recording might have been stopped after this error was posted to the queue
   // by |OnError|.
   if (!audio_controller_.get())
     return;
 
-  InformErrorAndCancelRecognition(RECOGNIZER_ERROR_CAPTURE);
+  InformErrorAndCancelRecognition(kErrorAudio);
 }
 
 void SpeechRecognizer::OnData(AudioInputController* controller,
                               const uint8* data, uint32 size) {
   if (size == 0)  // This could happen when recording stops and is normal.
     return;
 
   string* str_data = new string(reinterpret_cast<const char*>(data), size);
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                          NewRunnableMethod(this,
                                            &SpeechRecognizer::HandleOnData,
                                            str_data));
 }
 
 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_was_heard_before_packet = endpointer_.DidStartReceivingSpeech();
+
   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() &&
+  bool speech_was_heard_after_packet = endpointer_.DidStartReceivingSpeech();
+  if (!speech_was_heard_after_packet &&
       num_samples_recorded_ >= kNoSpeechTimeoutSec * kAudioSampleRate) {
-    InformErrorAndCancelRecognition(RECOGNIZER_ERROR_NO_SPEECH);
+    InformErrorAndCancelRecognition(kErrorNoSpeech);
     return;
   }
 
+  if (!speech_was_heard_before_packet && speech_was_heard_after_packet)
+    delegate_->DidStartReceivingSpeech(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()) {
+  if (endpointer_.speech_input_complete())
     StopRecording();
-  }
-
-  // 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);
+    const SpeechInputResult& result) {
+  if (result.error != kErrorNone) {
+    InformErrorAndCancelRecognition(result.error);
     return;
   }
 
-  delegate_->SetRecognitionResult(caller_id_, error, result);
-
   // Guard against the delegate freeing us until we finish our job.
   scoped_refptr<SpeechRecognizer> me(this);
+  delegate_->SetRecognitionResult(caller_id_, result);
   delegate_->DidCompleteRecognition(caller_id_);
 }
 
-void SpeechRecognizer::InformErrorAndCancelRecognition(ErrorCode error) {
+void SpeechRecognizer::InformErrorAndCancelRecognition(
+    SpeechInputError error) {
+  DCHECK_NE(error, kErrorNone);
   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