Revert 170668

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::OnSpeechRecognitionEngineResults(
-    const SpeechRecognitionResults& results) {
+void SpeechRecognizer::OnSpeechRecognitionEngineResult(
+    const SpeechRecognitionResult& result) {
   FSMEventArgs event_args(EVENT_ENGINE_RESULT);
-  event_args.engine_results = results;
+  event_args.engine_result = result;
   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_);
   }
 
-  listener_->OnRecognitionResults(session_id_, event_args.engine_results);
+  const SpeechRecognitionResult& result = event_args.engine_result;
+  listener_->OnRecognitionResult(session_id_, result);
   return STATE_RECOGNIZING;
 }
 
 SpeechRecognizer::FSMState
 SpeechRecognizer::ProcessFinalResult(const FSMEventArgs& event_args) {
-  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);
+  const SpeechRecognitionResult& result = event_args.engine_result;
+  if (result.is_provisional) {
+    DCHECK(!is_single_shot_);
+    listener_->OnRecognitionResult(session_id_, result);
     // 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_;
-  }
-
-  recognition_engine_->EndRecognition();
-
-  if (!results_are_empty) {
+  } else {
+    recognition_engine_->EndRecognition();
     // 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.
-    listener_->OnRecognitionResults(session_id_, results);
+    if (result.hypotheses.size() > 0)
+      listener_->OnRecognitionResult(session_id_, result);
+    listener_->OnRecognitionEnd(session_id_);
+    return STATE_IDLE;
   }
-
-  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