Speech recognition: Fixing erroneous DCHECK usage

content/browser/speech/speech_recognizer_impl.cc

 // Copyright (c) 2013 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_impl.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/time/time.h"
 #include "content/browser/browser_main_loop.h"
@@ skipping 155 matching lines @@
   // |input_bus_| should only be provide once.
   waiting_for_input_ = false;
   return 1;
 }
 
 // SpeechRecognizerImpl implementation
 
 SpeechRecognizerImpl::SpeechRecognizerImpl(
     SpeechRecognitionEventListener* listener,
     int session_id,
-    bool is_single_shot,
+    bool continuous,
+    bool provisional_results,
     SpeechRecognitionEngine* engine)
     : SpeechRecognizer(listener, session_id),
       recognition_engine_(engine),
       endpointer_(kAudioSampleRate),
       is_dispatching_event_(false),
-      is_single_shot_(is_single_shot),
+      provisional_results_(provisional_results),
       state_(STATE_IDLE) {
   DCHECK(recognition_engine_ != NULL);
-  if (is_single_shot) {
-    // In single shot recognition, the session is automatically ended after:
+  if (!continuous) {
+    // In single shot (non-continous) recognition,
+    // the session is automatically ended after:
     //  - 0.5 seconds of silence if time <  3 seconds
     //  - 1   seconds of silence if time >= 3 seconds
     endpointer_.set_speech_input_complete_silence_length(
         base::Time::kMicrosecondsPerSecond / 2);
     endpointer_.set_long_speech_input_complete_silence_length(
         base::Time::kMicrosecondsPerSecond);
     endpointer_.set_long_speech_length(3 * base::Time::kMicrosecondsPerSecond);
   } else {
     // In continuous recognition, the session is automatically ended after 15
     // seconds of silence.
@@ skipping 481 matching lines @@
   if (error.code != SPEECH_RECOGNITION_ERROR_NONE)
     listener()->OnRecognitionError(session_id(), error);
 
   listener()->OnRecognitionEnd(session_id());
 
   return STATE_ENDED;
 }
 
 SpeechRecognizerImpl::FSMState SpeechRecognizerImpl::ProcessIntermediateResult(
     const FSMEventArgs& event_args) {
-  // Provisional results can occur only during continuous (non one-shot) mode.
-  // If this check is reached it means that a continuous speech recognition
-  // engine is being used for a one shot recognition.
-  DCHECK_EQ(false, is_single_shot_);
+  // Provisional results can occur only if explicitly enabled in the JS API.
+  DCHECK(provisional_results_);
 
   // In continuous recognition, intermediate results can occur even when we are
   // in the ESTIMATING_ENVIRONMENT or WAITING_FOR_SPEECH states (if the
   // recognition engine is "faster" than our endpointer). In these cases we
   // skip the endpointer and fast-forward to the RECOGNIZING state, with respect
   // of the events triggering order.
   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);
   return STATE_RECOGNIZING;
 }
 
 SpeechRecognizerImpl::FSMState
 SpeechRecognizerImpl::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) {
+      DCHECK(provisional_results_);
       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.
@@ skipping 77 matching lines @@
 SpeechRecognizerImpl::FSMEventArgs::FSMEventArgs(FSMEvent event_value)
     : event(event_value),
       audio_data(NULL),
       engine_error(SPEECH_RECOGNITION_ERROR_NONE) {
 }
 
 SpeechRecognizerImpl::FSMEventArgs::~FSMEventArgs() {
 }
 
 }  // namespace content