Refactoring of chrome speech recognition architecture (CL1.2)

chrome/browser/speech/speech_input_extension_manager.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 "chrome/browser/speech/speech_input_extension_manager.h"
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
@@ skipping 219 matching lines @@
     SpeechInputExtensionManager::GetSpeechInputExtensionInterface() {
   return speech_interface_ ? speech_interface_ : this;
 }
 
 void SpeechInputExtensionManager::ResetToIdleState() {
   VLOG(1) << "State changed to idle. Deassociating any extensions.";
   state_ = kIdle;
   extension_id_in_use_.clear();
 }
 
-void SpeechInputExtensionManager::SetRecognitionResult(
+void SpeechInputExtensionManager::OnRecognitionResult(
     int caller_id,

[Satish, 2012/03/13 15:30:15]

change 'caller_id' to 'session_id' throughout to match the change in the
signatures in the header

[Primiano Tucci (use gerrit), 2012/03/14 09:40:35]

See previous reply

     const content::SpeechRecognitionResult& result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK_EQ(caller_id, kSpeechCallerId);
 
   // Stopping will start the disassociation with the extension.
   // Make a copy to report the results to the proper one.
   std::string extension_id = extension_id_in_use_;
   ForceStopOnIOThread();
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
@@ skipping 24 matching lines @@
     js_hypothesis_object->SetDouble(kConfidenceKey,
         hypothesis.confidence);
   }
 
   std::string json_args;
   base::JSONWriter::Write(&args, false, &json_args);
   VLOG(1) << "Results: " << json_args;
   DispatchEventToExtension(extension_id, kOnResultEvent, json_args);
 }
 
-void SpeechInputExtensionManager::DidStartReceivingAudio(int caller_id) {
-  VLOG(1) << "DidStartReceivingAudio";
+void SpeechInputExtensionManager::OnRecognitionStart(int caller_id) {
+  DCHECK_EQ(caller_id, kSpeechCallerId);
+}
+
+void SpeechInputExtensionManager::OnAudioStart(int caller_id) {
+  VLOG(1) << "OnAudioStart";
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK_EQ(caller_id, kSpeechCallerId);
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&SpeechInputExtensionManager::DidStartReceivingAudioOnUIThread,
       this));
 }
 
-void SpeechInputExtensionManager::DidCompleteRecording(int caller_id) {
+void SpeechInputExtensionManager::OnAudioEnd(int caller_id) {
   DCHECK_EQ(caller_id, kSpeechCallerId);
 }
 
-void SpeechInputExtensionManager::DidCompleteRecognition(int caller_id) {
+void SpeechInputExtensionManager::OnRecognitionEnd(int caller_id,
+                                                   bool success) {
   DCHECK_EQ(caller_id, kSpeechCallerId);
 }
 
 void SpeechInputExtensionManager::DidStartReceivingAudioOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   base::AutoLock auto_lock(state_lock_);
   if (state_ == kShutdown)
     return;
 
@@ skipping 17 matching lines @@
         prefs::kSpeechInputTrayNotificationShown, true);
   }
 
   VLOG(1) << "Sending start notification";
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_SPEECH_INPUT_RECORDING_STARTED,
       content::Source<Profile>(profile_),
       content::Details<std::string>(&extension_id_in_use_));
 }
 
-void SpeechInputExtensionManager::OnRecognizerError(
-    int caller_id, content::SpeechRecognitionErrorCode error) {
+void SpeechInputExtensionManager::OnRecognitionError(
+    int caller_id, const content::SpeechRecognitionErrorCode& error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK_EQ(caller_id, kSpeechCallerId);
-  VLOG(1) << "OnRecognizerError: " << error;
+  VLOG(1) << "OnRecognitionError: " << error;
 
   base::AutoLock auto_lock(state_lock_);
   if (state_ == kShutdown)
     return;
 
   // Release the recognizer object.
   GetSpeechInputExtensionInterface()->StopRecording(true);
 
   std::string event_error_code;
   bool report_to_event = true;
@@ skipping 35 matching lines @@
       NOTREACHED();
   }
 
   if (!event_error_code.empty()) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&SpeechInputExtensionManager::DispatchError,
         this, event_error_code, report_to_event));
   }
 }
 
-void SpeechInputExtensionManager::DidCompleteEnvironmentEstimation(
+void SpeechInputExtensionManager::OnEnvironmentEstimationComplete(
     int caller_id) {
   DCHECK_EQ(caller_id, kSpeechCallerId);
 }
 
-void SpeechInputExtensionManager::DidStartReceivingSpeech(int caller_id) {
+void SpeechInputExtensionManager::OnSoundStart(int caller_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK_EQ(caller_id, kSpeechCallerId);
-  VLOG(1) << "DidStartReceivingSpeech";
+  VLOG(1) << "OnSoundStart";
 
   std::string json_args;
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&SpeechInputExtensionManager::DispatchEventToExtension,
       this, extension_id_in_use_, std::string(kOnSoundStartEvent),
       json_args));
 }
 
-void SpeechInputExtensionManager::DidStopReceivingSpeech(int caller_id) {
+void SpeechInputExtensionManager::OnSoundEnd(int caller_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK_EQ(caller_id, kSpeechCallerId);
-  VLOG(1) << "DidStopReceivingSpeech";
+  VLOG(1) << "OnSoundEnd";
 
   std::string json_args;
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&SpeechInputExtensionManager::DispatchEventToExtension,
       this, extension_id_in_use_, std::string(kOnSoundEndEvent),
       json_args));
 }
 
 void SpeechInputExtensionManager::DispatchEventToExtension(
     const std::string& extension_id, const std::string& event,
@@ skipping 166 matching lines @@
 }
 
 void SpeechInputExtensionManager::IsRecordingOnUIThread(
     const IsRecordingCallback& callback,
     bool result) {
   BrowserThread::CurrentlyOn(BrowserThread::UI);
   callback.Run(result);
 }
 
 void SpeechInputExtensionManager::StartRecording(
-    content::SpeechRecognizerDelegate* delegate,
+    content::SpeechRecognitionEventListener* delegate,

[hans, 2012/03/13 14:32:46]

event_listener?

[Primiano Tucci (use gerrit), 2012/03/14 09:40:35]

Right.
Renaming to just "listener", as agreed offline.

     net::URLRequestContextGetter* context_getter,
     int caller_id,
     const std::string& language,
     const std::string& grammar,
     bool filter_profanities) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!recognizer_);
   recognizer_ = content::SpeechRecognizer::Create(
       delegate, caller_id, language, grammar, context_getter,
       filter_profanities, "", "");
-  recognizer_->StartRecording();
+  recognizer_->StartRecognition();
 }
 
 bool SpeechInputExtensionManager::HasValidRecognizer() {
   return !!recognizer_;
 }
 
 bool SpeechInputExtensionManager::Stop(const std::string& extension_id,
     std::string* error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(error);
@@ skipping 48 matching lines @@
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&SpeechInputExtensionManager::StopSucceededOnUIThread, this));
 }
 
 void SpeechInputExtensionManager::StopRecording(bool recognition_failed) {
   if (recognizer_) {
     // Recognition is already cancelled in case of failure.
     // Double-cancelling leads to assertion failures.
     if (!recognition_failed)
-      recognizer_->CancelRecognition();
+      recognizer_->AbortRecognition();
     recognizer_.release();
   }
 }
 
 void SpeechInputExtensionManager::StopSucceededOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   VLOG(1) << "Stop succeeded (UI thread)";
 
   base::AutoLock auto_lock(state_lock_);
   if (state_ == kShutdown)
     return;
 
   std::string extension_id = extension_id_in_use_;
   ResetToIdleState();
 
   DCHECK(notification_.get());
   notification_->Hide();
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_SPEECH_INPUT_RECORDING_STOPPED,
       // Guarded by the state_ == kShutdown check.
       content::Source<Profile>(profile_),
       content::Details<std::string>(&extension_id));
 }
 
-void SpeechInputExtensionManager::SetInputVolume(int caller_id,
-                                                 float volume,
-                                                 float noise_volume) {
+void SpeechInputExtensionManager::OnAudioLevelsChanged(int caller_id,
+                                                       float volume,
+                                                       float noise_volume) {
   DCHECK_EQ(caller_id, kSpeechCallerId);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&SpeechInputExtensionManager::SetInputVolumeOnUIThread,
       this, volume));
 }
 
 void SpeechInputExtensionManager::SetInputVolumeOnUIThread(
     float volume) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(notification_.get());
   notification_->SetVUMeterVolume(volume);
 }