Update the Speech Api to support array(s) of result items

content/browser/speech/speech_recognizer.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_recognizer.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/time.h"
 #include "content/browser/browser_main_loop.h"
@@ skipping 168 matching lines @@
   FSMEventArgs event_args(EVENT_AUDIO_DATA);
   event_args.audio_data = new AudioChunk(data, static_cast<size_t>(size),
                                          kNumBitsPerAudioSample / 8);
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&SpeechRecognizer::DispatchEvent,
                                      this, event_args));
 }
 
 void SpeechRecognizer::OnAudioClosed(AudioInputController*) {}
 
-void SpeechRecognizer::OnSpeechRecognitionEngineResult(
-    const SpeechRecognitionResult& result) {
+void SpeechRecognizer::OnSpeechRecognitionEngineResults(
+    const SpeechRecognitionResults& results) {
   FSMEventArgs event_args(EVENT_ENGINE_RESULT);
-  event_args.engine_result = result;
+  event_args.engine_results = results;
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&SpeechRecognizer::DispatchEvent,
                                      this, event_args));
 }
 
 void SpeechRecognizer::OnSpeechRecognitionEngineError(
     const SpeechRecognitionError& error) {
   FSMEventArgs event_args(EVENT_ENGINE_ERROR);
   event_args.engine_error = error;
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
@@ skipping 344 matching lines @@
   if (state_ == STATE_ESTIMATING_ENVIRONMENT) {
     DCHECK(endpointer_.IsEstimatingEnvironment());
     endpointer_.SetUserInputMode();
     listener_->OnEnvironmentEstimationComplete(session_id_);
   } else if (state_ == STATE_WAITING_FOR_SPEECH) {
     listener_->OnSoundStart(session_id_);
   } else {
     DCHECK_EQ(STATE_RECOGNIZING, state_);
   }
 
-  const SpeechRecognitionResult& result = event_args.engine_result;
-  listener_->OnRecognitionResult(session_id_, result);
+  listener_->OnRecognitionResults(session_id_, event_args.engine_results);
   return STATE_RECOGNIZING;
 }
 
 SpeechRecognizer::FSMState
 SpeechRecognizer::ProcessFinalResult(const FSMEventArgs& event_args) {
-  const SpeechRecognitionResult& result = event_args.engine_result;
-  if (result.is_provisional) {
-    DCHECK(!is_single_shot_);
-    listener_->OnRecognitionResult(session_id_, result);
+  const SpeechRecognitionResults& results = event_args.engine_results;
+  SpeechRecognitionResults::const_iterator i = results.begin();
+  bool provisional_results_pending = false;
+  bool results_are_empty = true;
+  for (; i != results.end(); ++i) {
+    const SpeechRecognitionResult& result = *i;
+    if (result.is_provisional) {
+      provisional_results_pending = true;
+      DCHECK(!is_single_shot_);
+    } else if (results_are_empty) {
+      results_are_empty = result.hypotheses.empty();
+    }
+  }
+
+  if (provisional_results_pending) {
+    listener_->OnRecognitionResults(session_id_, results);
     // We don't end the recognition if a provisional result is received in
     // STATE_WAITING_FINAL_RESULT. A definitive result will come next and will
     // end the recognition.
     return state_;
-  } else {
-    recognition_engine_->EndRecognition();
+  }
+
+  recognition_engine_->EndRecognition();
+
+  if (!results_are_empty) {
     // We could receive an empty result (which we won't propagate further)
     // in the following (continuous) scenario:
     //  1. The caller start pushing audio and receives some results;
     //  2. A |StopAudioCapture| is issued later;
     //  3. The final audio frames captured in the interval ]1,2] do not lead to
     //     any result (nor any error);
     //  4. The speech recognition engine, therefore, emits an empty result to
     //     notify that the recognition is ended with no error, yet neither any
     //     further result.
-    if (result.hypotheses.size() > 0)
-      listener_->OnRecognitionResult(session_id_, result);
-    listener_->OnRecognitionEnd(session_id_);
-    return STATE_IDLE;
+    listener_->OnRecognitionResults(session_id_, results);
   }
+
+  listener_->OnRecognitionEnd(session_id_);
+  return STATE_IDLE;
 }
 
 SpeechRecognizer::FSMState
 SpeechRecognizer::DoNothing(const FSMEventArgs&) const {
   return state_;  // Just keep the current state.
 }
 
 SpeechRecognizer::FSMState
 SpeechRecognizer::NotFeasible(const FSMEventArgs& event_args) {
   NOTREACHED() << "Unfeasible event " << event_args.event
@@ skipping 48 matching lines @@
     : event(event_value),
       audio_error_code(0),
       audio_data(NULL),
       engine_error(SPEECH_RECOGNITION_ERROR_NONE) {
 }
 
 SpeechRecognizer::FSMEventArgs::~FSMEventArgs() {
 }
 
 }  // namespace content